diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 18bed9f5..da5ddcb5 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -2,7 +2,7 @@ name: "Build" on: push: - branches: [main, Controller-Expansion, Experience] + branches: [main, Controller-Expansion, Experience, feature/playable-bosses-upstream] tags: ['v*'] pull_request: workflow_dispatch: @@ -49,6 +49,8 @@ jobs: - name: Experience privacy and branding run: | python tools/brandingtest.py + python tools/experience/test_bosses.py + python tools/experience/test_boss_catalog.py python tools/experience/test_repository.py python tools/experience/test_diagnostics.py python tools/experience/test_normal_lifecycle.py @@ -150,7 +152,7 @@ jobs: experience-native: needs: verify - if: github.ref_name == 'Experience' + if: (github.ref_name == 'Experience' || github.ref_name == 'feature/playable-bosses-upstream') runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 @@ -218,7 +220,7 @@ jobs: # short SHA, so a downloaded artifact says which commit built it. # The window title, --version and the zip names read this one line. - name: Stamp the version - if: github.ref_name != 'Experience' + if: github.ref_name != 'Experience' && github.ref_name != 'feature/playable-bosses-upstream' shell: bash run: | if [ "$GITHUB_REF_TYPE" = "tag" ]; then @@ -339,13 +341,13 @@ jobs: fi - uses: actions/download-artifact@v4 - if: github.ref_name == 'Experience' + if: (github.ref_name == 'Experience' || github.ref_name == 'feature/playable-bosses-upstream') with: name: experience-native path: build/experience-native - name: Assemble Experience Windows package - if: github.ref_name == 'Experience' + if: (github.ref_name == 'Experience' || github.ref_name == 'feature/playable-bosses-upstream') shell: bash run: | python tools/experience/catalog_input.py unpack tools/experience/ci/catalog.json.xz build/catalog @@ -368,7 +370,7 @@ jobs: # -src: GitHub adds its own "Source code" zip to every release, and # two of those confuse. - name: Zip - if: github.ref_type != 'tag' && github.ref_name != 'Experience' + if: github.ref_type != 'tag' && github.ref_name != 'Experience' && github.ref_name != 'feature/playable-bosses-upstream' shell: bash run: | python tools/package.py dist "$artifact" diff --git a/README.md b/README.md index c885a06f..e1760483 100644 --- a/README.md +++ b/README.md @@ -44,6 +44,19 @@ The upstream patcher remains the foundation. Its [game fixes](docs/PATCHER.md#wh remain available alongside the original controller profiles. +## Playable Bosses (development branch) + +Optional single-player Jaguarandi and Z-Gradt support comes from **Vortyne's** +implementation in **Pairomaniac's V-On Patcher**. **Playable bosses** is off by +default; **Pre-unlock the bosses** requires it. Earned unlocks are stored in +`bosses.bin` and survive Restore Original. Z-Gradt's special laser uses the +existing Dash/turbo input. Local VS and online selection retain the original +eight machines. + +This branch is an integration candidate, not a new published release. See the +[upstream boss reference](docs/BOSSES.md) and +[Experience integration and validation](docs/project/PLAYABLE-BOSSES.md). + ## Display Expansion Configure **F5 → Graphic Settings → Display...** after installing with the original diff --git a/asm/README.md b/asm/README.md index 4f13675e..b6e2f81e 100644 --- a/asm/README.md +++ b/asm/README.md @@ -42,6 +42,7 @@ and release workflow see [DEVELOPING.md](../docs/DEVELOPING.md). | `nameentry.asm` | ending screens: adds A to the initials screen, beside the triggers | | `camskip.asm` | gamepad: lets A skip the win and lose screens, as Select does | | `lockline.asm` | Fix the lock-on line: the clippers project 2D quads with the 2D scale | +| `bosses.asm` | Playable bosses: the bosses in the select's row once unlocked, the unlocks and their screen, the boss's colour, and every place the game only handled the eight machines | | `ui.asm` | Native widescreen: the resolution blob, built by `tools/uibuild.py` (see below) | | `layout.py` | data blob layout and string table, shared by `vocd.asm` and the blob | | `padtables.py` | gamepad: what each pad input is, what it is called, the F7 device list | @@ -187,19 +188,19 @@ resolution blob on the retail file only. ## Where the blobs go -Every blob but two is in the annex: a section, `.vojp`, that the patcher +Every blob but three is in the annex: a section, `.vojp`, that the patcher appends before any patch is written, executable, and fills through the site table like any other site. Where it lands is fixed by the file's own headers, so its addresses are known when the patcher loads and nothing -is relinked at apply time; `.voxt` and `.vocd`, the sections two patches -append at apply time, land after it. Every entry reads its length from the +is relinked at apply time; `.vobs`, `.voxt` and `.vocd`, the sections +three patches append at apply time, land after it. Every entry reads its length from the blob, so a routine can change size with a rebuild and nothing else. -The two exceptions are places the game itself reaches: the F7 device +Two of the exceptions are places the game itself reaches: the F7 device list, which `padtables.py` writes into the game's own run in `.data`, and `levers.asm`, written straight after `padxinput.asm` because the epilogue it replaces falls through into it. Those are the `caves` table of each -`Build`. +`Build`. The third is `bosses.asm`, in a section of its own (below). Nothing goes in a run of zeros in `.rdata`. A run there is never known to be free: a pointer just before it means the tail of a structure or the @@ -208,9 +209,13 @@ reference the file shows, and both have crashed the game before. Two runs, at `0x5f80e0` and `0x623d98`, are `qword` constants that scan as zeros; `0x5fb140` is a scoreboard template the attract loop copies. -Three patches append a section of their own rather than use the annex, +Four patches append a section of their own rather than use the annex, because what they carry is too big for it and only exists once the patch -is applied. The third, `.vohr`, is **Native widescreen**'s: its code is +is applied. `.vobs` is **Playable bosses**' (`bosses.asm`, below): built +and linked like the annex's blobs, since its place follows from the +annex's, but written only when ticked and only as far as its last byte +that is not zero - the buffers at its end are the section's virtual size. +The fourth, `.vohr`, is **Native widescreen**'s: its code is `ui.asm` here, the same nasm as everything else, but built by `tools/uibuild.py` rather than `build.py` - it is position independent (no `org`) and carries its own address list, so the blob and its offset @@ -789,6 +794,43 @@ the flag is up and the 3D slot otherwise. Two renderers, two flags, two pairs of projection slots. How it was found is in [HIRES.md](../docs/HIRES.md), *The lock-on line*. +## bosses.asm + +Jaguarandi and Z-Gradt as the player's machine in a one-player game, once +unlocked. The select's row gets two more places, and every place the game +handled the eight alone gets a hook. The player's guide and the design +are in [BOSSES.md](../docs/BOSSES.md). + +The file is in sections, each a hook or a few, in this order: + +- the per-frame tick from the loop's idle call, which follows the select + and keeps the flag `boss`, and confirm +- the select: its row, its tables made ten long, the bosses' own select + models posed from their fight models, the palettes (a boss borrows two + rows the select leaves alone), and the portraits, marks and frame + shifted left +- the palette loaders, PLAYER DATA's turntable, the unlocks with their + screen and `bosses.bin`, the round's animation loads, and the ending +- Z-Gradt's chase camera; the player's Z-Gradt - its fly-in, its laser's + button, its floor - and Z-Gradt against Z-Gradt, where the player's + gets its own model header and AI state; Z-Gradt's gold +- the KO replay's ring, Jaguarandi's red segments, Z-Gradt's laser gauge + and its weapons on the strips, and the replay and the win and lose + screens + +The data is at the end, the zeroed buffers last so the file carries none +of them. + +Every hook is in player 1's copy of the fight machine, `A` in the names, +as [HIRES.md](../docs/HIRES.md) letters the renderers. The other copy's +tick is only called in the loop's two-player branch, and the bosses are +one player only. A hook that replaces more than one instruction replays +what it displaced. The hooks in code every machine runs, the polygon +queue, load identity and the shadow draws, test `boss` first and fall +through to the original otherwise. The replay's ring is the one +exception: it keeps Z-Gradt's AI globals in every fight, whoever is in +it. + ## titlever.asm Prints `v-on-patcher ` in the bottom right of the title screen. diff --git a/asm/bosses.asm b/asm/bosses.asm new file mode 100644 index 00000000..bb0b00e8 --- /dev/null +++ b/asm/bosses.asm @@ -0,0 +1,5328 @@ +bits 32 +; Playable bosses: Jaguarandi (VR id 8) and Z-Gradt (9) for one player. +; +; Unlocked, not given: beating Jaguarandi on Very Hard without a lost match +; in the run unlocks it, and finishing the game the same way after that +; unlocks Z-Gradt. Each is shown on a screen of its own in the report's +; state, and the unlocks are kept in bosses.bin beside the game (a dword: +; 0 none, 1 Jaguarandi, 2 both; the patcher's Pre-unlock the bosses +; writes 2). +; +; On the 1P select an unlocked boss stands in the row after Raiden, cursor +; 8 and 9: two more scene objects, the row and its marks moved left to +; make room, the countdown 20 seconds longer, and the boss drawn in +; palette rows of its own. Confirming on a boss stores its id in the +; player's machine global, and the game spawns that. +; The initials demo already fights 8 against 9, so the objects themselves +; work as a player's; what does not is everything the game only ever did +; with the eight, which is the rest of this file. +; +; The game keeps two copies of its fight machine, one per player: A, at +; 0x1ae0xxxx, player 1's, and B, at 0x1ef8xxxx, player 2's, whose tick +; (0x40f528) only the frame loop's two-player branch calls - the letters +; docs/HIRES.md gives their renderers. The bosses are one player only, so +; every hook here is A's. +; +; One player only: in two-player and network play (GAMEMODE not 0) the +; row stays the eight and confirm stores what it always did. Confirm notes +; a boss taken in one player in `boss`, and the hooks further down ask +; that one flag whether the player is a boss, or which. +; +; Colour. With Machine Color Select on, up and down on the select cycle the +; machine under the cursor through eight colours, 0 being its own. Each +; machine's eight are pairs of palettes from one shared pool - the other +; colours are mostly other machines' palettes - so a boss can wear any of +; them, chosen on it in the row. The palette loader (0x4f358b) gives the +; boss that pair in place of its own when it is not 0. A boss has no +; colours of its own: the loader sends ids above 7 to a +; fixed table without reading one. +; +; Which side of the palette slots a player's machine uses depends on the +; copy and its mode, and the select writes the colour into the array that +; side reads - 0x69fff0 for slots 1/3, 0x6a0010 for 5/7. Confirm records +; which, and only a load from that side is recoloured, which keeps a CPU +; boss of the same id (Z-Gradt on the last stage) in its own colours. +; +; Z-Gradt against Z-Gradt, the last stage, needs the most: both share one +; model header and one block of AI state, so the player's gets a copy of +; each, and its fly-in is skipped so the CPU's descent is not ticked twice. + +extern GAMEMODE ; 0 one player, 1 two, 2 network +extern BS_IDLE ; the loop's idle call, both sites +extern BS_SFX ; play a sound effect, cdecl (id) +extern BS_SCENEA ; the scene word: [0x20, 0x30) is the + ; select and the encounter +extern BS_G1PA ; the player's machine id +extern BS_MODEA ; A's mode: 0 puts its player on slots 1/3 +extern BS_COL0 ; colour per machine for slots 1/3 +extern BS_COL1 ; and for 5/7 + +; The player's object and its fields +extern BS_OBJA ; the player's object +extern BS_CPUA ; and the CPU's +extern BS_IDA ; object + 0x64: its machine id +extern BS_MDLA ; object + 0x6c: its model header +extern BS_JAGA ; the bosses' model headers +extern BS_ZGA +extern BS_STAGEA ; the stage, 0 Temjin to 9 Z-Gradt + +; Palettes +extern BS_PALA ; per palette id: a machine's eight pairs +extern BS_PALSETA ; (slot, palette): expand it into the bank +extern BS_PALFIXA ; the loader's own path for ids above 7 +extern BS_PALRETA ; and its epilogue + +; PLAYER DATA, after stage 5 +extern BS_RPARTA ; its rotating model's parts, (machine) +extern BS_MPUSHA ; the matrix stack: push, pop, scale (x, +extern BS_MPOPA ; y, z) +extern BS_MSCALEA +extern BS_RFLAG ; the renderer flag a machine's draw sets +extern BS_MATA ; the current matrix +extern BS_IDENTA ; load identity, past its prologue +extern BS_LIGHTA ; a machine's shadow: the light it reads, +extern BS_SHADEA ; where it carries on, and past it +extern BS_NOSHADEA +extern BS_ZSHADEA ; Z-Gradt's shadow (its timer BS_ZTIMA): + ; where it carries on, and past it +extern BS_ZNOSHADEA +extern BS_ECBLKA ; the ending's camera's block (its move + ; the view translate, BS_VIEWA) +extern BS_ESTEPA ; and the ending's step +extern BS_WALLA ; the floor's height, from a beam segment +extern BS_SPDA ; Z-Gradt's beam's speed +extern BS_SCANA ; the ending camera's slot scan, after its +extern BS_FOUNDA ; start, and where it takes a slot found +extern BS_SCANBASE ; what the scan adds to its start +extern BS_ZTAB0 ; Z-Gradt's tables, per side +extern BS_ZTAB1 +extern BS_ZINITA ; Z-Gradt's setup +extern BS_PH0A ; the ending's phase 0 +extern BS_SCRPTR ; the scene script being read +extern BS_SELSCRA ; the select's, A's +extern BS_SELCUR ; a player's cursor on the select +extern BS_SELINVA ; the cursor of a machine +extern BS_COLSEL ; Machine Color Select +extern BS_SELMDLA ; the select's model of a machine +extern BS_SELINFOA ; and its text for a cursor +extern BS_FRAMEA ; the frame counter +extern BS_SELMODE +extern BS_SELQINFOA ; the quick select's texts for a cursor, +extern BS_QTXTX ; and where it puts them: the column, +extern BS_QTXTY ; the row +extern BS_SELHIDEX ; the confirm's hiding of the machines, past +extern BS_PRINT1A ; text: print on one plane or the other, +extern BS_PRINT2A ; place, clear a block, a block of tiles +extern BS_TXTPOSA +extern BS_TCLEARA +extern BS_TBLOCKA +extern BS_LOGOJ ; the bosses' names, as tiles +extern BS_LOGOZ +extern BS_ROW ; the eight's portraits, a block of tiles +extern BS_SELROWS ; the select's models, a row a machine +extern BS_SELSWAP ; per machine, the bone given spare +extern BS_SELSPEC ; meshes and the one drawn apart +extern BS_SELLCAM ; the launch's camera, a machine's +extern BS_SELAHEAD ; how far ahead a machine is drawn +extern BS_MFRAMEA ; the frame a machine's motion is drawn at +extern BS_SELPADS ; the pads' presses this frame, two +extern BS_SELFLAME ; a machine's booster flames, per frame +extern BS_SELSKY ; the hangar's outside shown, +extern BS_SELIN ; and its inside +extern BS_SELTICKS +extern BS_SLOTS ; files loaded: where, how much +extern BS_LOADFILE ; load a machine's (id, -1, 0, 1), as the select +extern BS_MALLOC ; the C library's +extern BS_FRX ; the portrait frame's two x doubles +extern BS_TXTX ; the text cursor's column +extern BS_PLANE ; the plane the portraits' marks are on +extern BS_RBNAMES ; the fight models' files: name, size +extern BS_RBDIR ; the folder they are read from +extern BS_PATHFMT ; "%s%s", as the loader joins them +extern BS_RBMODE ; "rb" +extern BS_SPRINTF ; the C library's +extern BS_FOPEN +extern BS_FREAD +extern BS_FCLOSE +extern BS_PALLOADA ; A's palette load (slot, palette) +extern BS_PALRAMA ; and A's palettes +extern BS_POLYCOL ; the polygon being queued's light +extern BS_KEYA ; the polygon's depth key, as the mesh draw keeps it +extern BS_COLTAB ; the polygons' colours, a row a plane +extern BS_SELOBJ ; the scene's objects +extern BS_SELCAM ; the scene camera's place, as the hangar + ; reads it (0x345bd58) +extern BS_HSITE ; the hangar's draw of a machine, and +extern BS_HDOFF ; where the widescreen one is in its blob +extern BS_MESHA ; a part's meshes (the three, 0) +extern BS_MIDENTA ; the matrix made the identity +extern BS_BARMESHA ; the HUD's bar: a quad 2 by 2 about the origin, +extern BS_BARONA ; its materials, a weapon's and the red of one +extern BS_BARREDA ; not ready +extern BS_CHARGEA ; the strips' CHARGING block at the cursor (1), or + ; its rows cleared (0) +extern BS_BARLIVEA ; and a live bar's, full and pulsing in height +extern BS_ROTXA ; turn it about x (the angle) +extern BS_POSEA ; a fight model posed by a motion +extern BS_ROTYA ; turn the matrix about y (the angle) +extern BS_ROTZA ; and about z +extern BS_CREATEF ; IAT: CreateFileA, SetFilePointer, +extern BS_SEEKF ; ReadFile, CloseHandle +extern BS_READF +extern BS_CLOSEF +extern BS_ZPARTS ; Z-Gradt's parts its draw places +extern BS_ZRINGS +extern BS_ZCROWN +extern BS_ZSIDES +extern BS_MSETA ; and hand it to the renderer +extern BS_MDRAWA ; the eight's draw, from their per-frame routine +extern BS_ZDRAWA ; Z-Gradt's draw, without its moves +extern BS_FXA ; the effects tables: 24 of 0x24, 24 of 0x38 +extern BS_FX2A +extern SEMUTE ; nonzero: no sound effects +extern BS_NAMEA ; its machine names, 15 bytes each + +; The round's animation loads +extern BS_LDA ; resume, past mov eax, [id] + +; Unlocking +extern BS_STATEA ; A's state machine, the one a 1P game runs +extern BS_DIFF ; the difficulty: 2 Very Hard +extern BS_LOSSA ; A's lost matches with this machine +extern BS_REPLOGICA ; PLAYER DATA's state 0x1e, its text, +extern BS_REPTEXTA ; its turning model (scale), the frame +extern BS_REPMODELA ; it counts +extern BS_REPCNT +extern BS_TCLRALL ; text: clear the planes, reset the cursor, +extern BS_TRESET ; print in the large white font +extern BS_PRINTBIG +extern BS_PADEDGE ; the buttons held this frame +extern BS_FADE ; fade (level), and a scene's end +extern BS_SCNEND +extern BS_FWRITE ; the C library's, and "wb" +extern BS_WBMODE +extern BS_ARTPOOL ; the 2D art: tile n at + n * 0x80, n +extern BS_ARTPOOL2 ; below the count; with 0x4000, the other +extern BS_ARTCOUNT ; bank's; and where .data ends +extern BS_ARTEND +extern BS_SCNNOW ; texture bank (bank, half) +extern BS_LOADTEX +extern BS_FCBUF ; the scene's floor texture and model, as +extern BS_FLDBUF ; loaded, and three of its glow's states +extern BS_GLOW1 +extern BS_GLOW2 +extern BS_GLOW3 +extern BS_MTSELMEM ; where MT_sel.bin is read to, when its +extern BS_SEGA ; segment (0xa) is empty, and that segment +extern BS_LDXA ; the extras that follow the loads +extern BS_DRFA ; the deref: fall through, its je, and past +extern BS_DRJA ; the stand overlay +extern BS_DRSA +extern BS_C2A ; mode 0xa: resume +%include "frames.inc" ; DR_FLAG: the deref's local; CAM_PTR: the + ; live camera's; SCAN_SLOT: the ending + ; camera's slot found; PAL_CPU: the palette + ; events' side flag. A recompile moves them + +; The ending +extern BS_TIMEA ; the ending's frame counter +extern BS_PHASEA ; and its phase +extern BS_ENDA ; resume, phase 1, epilogue (the button +extern BS_END1A ; wait) +extern BS_ENDEA + +; Z-Gradt's chase camera +extern BS_VIEWA ; translate the matrix (x, y, z): the view + ; translate; and sin and cos +extern BS_SINA +extern BS_COSA +extern BS_YAW4 ; the yaw the opening shots place the eye by +extern BS_LIVEA ; resume past the live camera's load + +; Z-Gradt against Z-Gradt +extern BS_READYA ; frames since GET READY +extern BS_INITA ; Z-Gradt's init, resume +extern BS_FLYA ; fly-in: resume, after landing, epilogue +extern BS_FLYPA +extern BS_FLYEA +extern BS_ZMODA ; the model header Z-Gradt's code reads +extern BS_ZTIMA ; the fly-in timer +extern BS_RCOUNTA ; A's frames left in a state +extern BS_ARENA ; the arena loaded, 0 to 9 +extern BS_ZBOXA ; Z-Gradt's own floor query, the moon +extern BS_FLOORA ; gate's box; and the arena's, the eight's +extern BS_TM2 ; two timer locks: resume and skip each +extern BS_TM2S +extern BS_TM4 +extern BS_TM4S +extern BS_CLIP0A ; the clip bank: 0 the pad's, 3 the AI's +extern BS_CLIP3A +extern BS_CLONEA ; resume +extern BS_CLONEFRAME ; and the frame its prologue makes +extern BS_BSSA ; Z-Gradt's AI state: its globals' first, +extern BS_AIDW ; their length in dwords, and seven of +extern BS_AI1C ; them from the first - the build's own, +extern BS_AITIMER ; the rerelease laying them out apart +extern BS_AILASER ; (retail's +0x1c, the fly-in timer at +extern BS_AITAB ; +0x1b8, the laser's state at +0x1c4, +extern BS_AITAB2 ; the side's four tables at +0x1bc, +extern BS_AITAB3 ; +0x1c0, +0x4 and +0xd0) +extern BS_AITAB4 +extern BS_TICKA ; its tick, resume + +; Z-Gradt's gold +extern BS_EVA ; the palette event its handler takes, 0xff none +extern BS_ZEVA ; the one Z-Gradt's AI state asks for +extern BS_ZRA5 ; event 0x200, its own palettes back: +extern BS_ZRA1 ; slots 5/7, slots 1/3, and the end +extern BS_ZRAX +extern BS_ZGA5 ; event 0x21f, gold: slots 5/7, 1/3 +extern BS_ZGA1 +extern BS_ZDA5 ; events 0x401 on, darker: slots 5/7, 1/3 +extern BS_ZDA1 +extern BS_ZFA5 ; and 0x420 on, fading +extern BS_ZFA1 + +; The KO replay and the win and lose screens +extern BS_WIND1 ; the win camera's distance +extern BS_RPITCH1 ; the replay camera's pitch and yaw +extern BS_RYAW1 + +JAG equ 8 +ZGRADT equ 9 +SELECT_LO equ 0x20 ; scene: select and encounter +SELECT_HI equ 0x30 +ATTRACT_LO equ 0x10 ; scene: title and attract, the demo +ATTRACT_HI equ 0x20 ; included +LAST_STAGE equ 9 +ARENA_MOON equ 6 ; the moon gate, the last stage's arena +READY_GO equ 5 ; frames after GET READY before the + ; player's Z-Gradt moves +MODEL_COPY equ 0x800 +OBJECT equ 0x600 ; a fight object, 0x1ae0c40 to 0x1ae1240 +AI_STATE equ 0x1e8 ; room for the longest build's (BS_AIDW) +FX equ 24 * 0x24 ; the effects tables, BS_FXA and BS_FX2A +FX2 equ 24 * 0x38 + +%macro COPYN 3 ; dst, src, bytes + mov esi, %2 + mov edi, %1 + mov ecx, %3 / 4 + cld + rep movsd +%endmacro + +%macro COPYAI 2 ; dst, src: an AI state, BS_AIDW dwords + push esi + push edi + push ecx + mov esi, %2 + mov edi, %1 + mov ecx, BS_AIDW + cld + rep movsd + pop ecx + pop edi + pop esi +%endmacro + +; The standing copy: the player's boss object and its AI state, the first +; time the tick sees GET READY over in a round - for Z-Gradt, ZSTAND frames +; later, its flight in being over by then. From the tick, pushad'd. +ZSTAND equ 90 +%macro STAND 6 ; the object, frames since GET READY, + cmp dword [%2], 0 ; AI state, the copies, taken flag + jne %%run + mov byte [%6], 0 ; a round still to start + jmp %%out +%%run: cmp byte [%6], 0 + jne %%out + mov eax, [%1 + 0x64] + cmp eax, JAG + je %%take + cmp eax, ZGRADT + jne %%out + cmp dword [%2], ZSTAND ; Z-Gradt is still flying in + jb %%out +%%take: mov byte [%6], 1 + COPYN %4, %1, OBJECT + COPYAI %5, %3 +%%out: +%endmacro + +; --- the select ------------------------------------------------------------ + +; In place of the idle call at both its sites. Entering the select puts a +; leftover boss id back to Temjin so the cursor wraps; the title and the +; demo forget the boss's colour. Then, on the select in one player, the +; bosses' palettes and Z-Gradt's lift. +tick: + pushad + call unl_load + call unl_tick + call selframex + call selpalguard + mov dword [win_tries], 0 + xor edx, edx + movzx eax, word [BS_SCENEA] + cmp eax, SELECT_LO + jb .out + cmp eax, SELECT_HI + jae .out +.in: inc edx +.out: mov ecx, [was] + mov [was], edx + test ecx, ecx + jz .enter + test edx, edx + jnz .attract + call selpalback ; left: the bosses' rows the game's + jmp .attract +.enter: test edx, edx + jz .attract + call selrow_make + mov dword [boss], 0 ; no boss taken yet + mov dword [sel_ztilt], 0 ; Z-Gradt upright + mov dword [sel_zhead], 0 + mov dword [sel_zspin], 0 + mov dword [end_g1p], 0 + mov dword [banked_a], 0 ; a fight's Z-Gradt starts from the + ; CPU's state just initialised (ZINIT) + mov byte [zfly_on], 0 ; and a player's Z-Gradt on the ground + call zbeam_off + cmp dword [BS_G1PA], 7 + jbe .attract + mov dword [BS_G1PA], 0 +.attract: + movzx eax, word [BS_SCENEA] + sub eax, ATTRACT_LO + cmp eax, ATTRACT_HI - ATTRACT_LO + jae .mode +.forget: + cmp dword [BS_STATEA], ST_TITLE ; the title, not a fight's end, + ja .mode ; which shows a scene in that range too + mov dword [boss], 0 +.mode: STAND BS_OBJA, BS_READYA, BS_BSSA, stand_a, standai_a, stood_a + cmp dword [GAMEMODE], 0 + jne .done + test edx, edx + jz .done + call seljagpal + call selzlift +.done: popad + jmp BS_IDLE + +; In place of `mov [player], eax; mov eax, [player]`, five nops after the +; call. eax is the machine under the cursor; a boss of the lineup is +; noted, with the colour it was given here. +confirm_a: + mov ecx, BS_COL0 ; A's picks by its mode, as 0x5a0149 does + cmp dword [BS_MODEA], 0 + je .c + mov ecx, BS_COL1 +.c: mov edx, BS_G1PA + mov dword [boss], 0 + cmp dword [GAMEMODE], 0 + jne .store + cmp eax, JAG ; the cursor on a boss of the lineup + jb .store + mov [bside], ecx ; in the colours it was given here + push eax + push edx + call selbcol ; eax the machine, edx the colour + mov [bsrc], eax + mov [bcolor], edx + pop edx + pop eax + mov [boss], eax +.store: mov [edx], eax + ret + +; --- the lineup ------------------------------------------------------------ + +; The select's lineup is a scene script: the camera, then the eight in a +; row 20 apart, Temjin to Raiden, then the hangar. The cursor runs 0 to 7 +; and a table turns it into a machine. In one player the lineup goes on +; past Raiden to Jaguarandi and Z-Gradt, cursor 8 and 9: two more records +; after Raiden's, the cursor's limit 9, and the tables (0x621870, the +; machine of an object, and 0x621878, of the cursor, two on) ten long, in +; place of the game's at every read. A machine's object is the cursor's +; plus two, so the two go in before the hangar's. +; +SEL_REC equ 0x30 ; a script record +SEL_EIGHT equ 10 ; the camera, its own, and the eight +SEL_REST equ 14 ; the hangar's, to the end marker +SEL_Y equ 0x18 ; a record's height, +SEL_Z equ 0x1c ; its place along the row +SEL_FLAGS equ 0x10 ; and its flags, the machine twice + +; In place of `mov [script], select's`, five nops after the call. +selscr_a: + pushad + cmp byte [selbuilt], 0 + jne .set + COPYN selscript, BS_SELSCRA, SEL_EIGHT * SEL_REC + COPYN selscript + SEL_EIGHT * SEL_REC, BS_SELSCRA + (SEL_EIGHT - 1) * SEL_REC, SEL_REC + COPYN selscript + (SEL_EIGHT + 1) * SEL_REC, BS_SELSCRA + (SEL_EIGHT - 1) * SEL_REC, SEL_REC + COPYN selscript + (SEL_EIGHT + 2) * SEL_REC, BS_SELSCRA + SEL_EIGHT * SEL_REC, SEL_REST * SEL_REC + mov ebx, selscript + SEL_EIGHT * SEL_REC + mov dword [ebx + SEL_FLAGS], JAG * 2 + fld dword [ebx + SEL_Z] + fadd dword [sel_step] + fst dword [ebx + SEL_Z] + fadd dword [sel_zgap] + fstp dword [ebx + SEL_REC + SEL_Z] + fld dword [ebx + SEL_REC + SEL_Y] ; Z-Gradt on the lip + fadd dword [sel_zy] + fstp dword [ebx + SEL_REC + SEL_Y] + mov dword [ebx + SEL_REC + SEL_FLAGS], ZGRADT * 2 + COPYN selrows, BS_SELROWS, 8 * SEL_ROWS ; and the models' rows, + COPYN selrows + JAG * SEL_ROWS + 8, BS_SELROWS + SEL_RAIDEN * SEL_ROWS + 8, 16 + COPYN seld68, BS_SELSWAP, 8 * 4 ; the bone given spare + COPYN selda8, BS_SELSPEC, 8 * 4 ; meshes, and the one drawn + mov eax, -1 ; apart: none for a boss + mov [seld68 + JAG * 4], eax + mov [seld68 + ZGRADT * 4], eax + mov [selda8 + JAG * 4], eax + mov [selda8 + ZGRADT * 4], eax + COPYN sellcam, BS_SELLCAM, 8 * SEL_LCAM ; the launch's camera: + COPYN sellcam + JAG * SEL_LCAM, sel_jagcam, SEL_LCAM ; Raiden's, + COPYN sellcam + ZGRADT * SEL_LCAM, sel_jagcam, SEL_LCAM ; further + mov eax, [BS_JAGA + SEL_PARTS] ; Jaguarandi's with them + mov [selrows + JAG * SEL_ROWS], eax + mov eax, [BS_JAGA + SEL_POSED] + mov [selrows + JAG * SEL_ROWS + 4], eax + mov byte [selbuilt], 1 +.set: mov eax, BS_SELSCRA ; the game's lineup in two players: + mov dword [selhas], 0 ; no boss stands there + cmp dword [GAMEMODE], 0 + jne .script + mov eax, selscript + mov dword [selhas], 1 +.script: + mov [BS_SCRPTR], eax + popad + ret + +; Confirming hides the machines, objects 2 up to the bound, before the +; one taken launches: the eight's, and the bosses' two with them when +; they stand in the row. In place of `cmp [i], 10; jge past`, five nops +; after the call; [ebp-0x54] the object. +selhide_a: + mov eax, SEL_EIGHT + cmp dword [selhas], 0 + je .bound + add eax, 2 +.bound: cmp [ebp - 0x54], eax + jge .past + ret +.past: add esp, 4 + jmp BS_SELHIDEX + +; In place of `cmp [cursor], 7`, three nops after the call; the flags as +; it leaves them. eax the player times 21, as the game indexes. +selmax_a: + push ecx + mov ecx, 7 + cmp dword [GAMEMODE], 0 + jne .c + add ecx, [unl_level] ; as far as the bosses unlocked +.c: cmp [eax * 4 + BS_SELCUR], ecx + pop ecx + ret + +; In place of `mov eax, [eax*4 + cursor of machine]` for the cursor the +; select starts on, the last machine taken: a boss's own in one player, +; Raiden's otherwise. Two nops after the call. +selinit_a: + cmp eax, JAG + jb .eight + cmp dword [GAMEMODE], 0 + jne .raiden + ret +.raiden: + mov eax, 7 + ret +.eight: mov eax, [eax * 4 + BS_SELINVA] + ret + +; In place of `cmp [colour select], 0`, two nops after the call; the flags +; as it leaves them. Up and down cycle the eight's colours, eight each; on +; a boss, with the option on, they cycle its own here instead - its own, +; then each of the eight's eight (SEL_BCOLS in all) - and to the +; game it is as if the option were off. ebp the select's frame, [ebp+8] +; the player. +SEL_BCOLS equ 1 + 8 * 8 ; its own, and the eight's eight each +SEL_UP equ 0x20 ; the pads' bits +SEL_DOWN equ 0x10 +selcol_a: + push eax + mov eax, [ebp + 8] + imul eax, eax, 0x54 + mov eax, [eax + BS_SELCUR] + cmp eax, JAG + jae .boss + pop eax + cmp dword [BS_COLSEL], 0 + ret +.boss: cmp dword [BS_COLSEL], 0 + je .off + push ecx + lea ecx, [sel_bcol + (eax - JAG) * 4] + mov al, [BS_SELPADS] + or al, [BS_SELPADS + 1] + test al, SEL_UP + jz .down + dec dword [ecx] + jns .moved + mov dword [ecx], SEL_BCOLS - 1 + jmp .moved +.down: test al, SEL_DOWN + jz .kept + inc dword [ecx] + cmp dword [ecx], SEL_BCOLS + jb .moved + mov dword [ecx], 0 +.moved: pushad + push 1 ; the select's own tick + call BS_SFX + add esp, 4 + popad +.kept: pop ecx +.off: pop eax + cmp eax, eax + ret + +; The select draws a machine as a list of parts, three meshes each, posed +; by one of its motions; its row in a table (0x621708) names the parts and +; the motions. Jaguarandi has no select model, but its fight model's body +; is such a list (its header's ninth field, and the eighth, as the posed +; draw reads it, a part for the root first), with Raiden's parts, so its +; row is that posed by Raiden's motions. Its meshes are in RB_jag.bin, +; which nothing loads on the select: the first time it is drawn there it +; is read into its file slot as the loader would, at the pool's end. +; +; Z-Gradt has neither: it is drawn as its fight draws its body, at its +; size in a fight, posed by its battle stance, the one motion of its that +; loops (MT_zig.bin's, read on the select into selzmotion; failing that, +; one frame of another, selzpose, as it has it); its meshes are in +; RB_zig.bin, loaded as Jaguarandi's. +; +; In place of the prologue of the select's model of a machine (cdecl, the +; machine first). +SEL_ROWS equ 0x18 ; a machine's row +SEL_LCAM equ 0xc ; its launch camera: out, up, turn a frame +SEL_RAIDEN equ 3 +SEL_JAGFILE equ 5 ; Jaguarandi's file slot +SEL_RAIFILE equ 7 ; Raiden's +SEL_PARTS equ 0x20 ; a fight model's body, the two ways +SEL_POSED equ 0x1c ; a select row has it +SEL_ZFILE equ 9 ; Z-Gradt's file slot +selmdl_a: + cmp dword [esp + 4], JAG + jae .boss +.draw: push ebp + mov ebp, esp + sub esp, 0x30 + jmp BS_SELMDLA + 6 +.none: jmp sel_slotsout +.boss: cmp dword [GAMEMODE], 0 ; two players: not in the row + jne .none + mov eax, [esp + 4] ; a boss still locked: not there + sub eax, 7 + cmp eax, [unl_level] + ja .none + mov eax, [sel_launch] ; the other boss launching: not there + test eax, eax ; (out of sight; its rows lent) + jle .mine + cmp eax, [esp + 4] + jne .none +.mine: mov eax, [esp + 4] ; its shade at the hangar's right edge + call selfade + mov eax, SEL_JAGFILE + cmp dword [esp + 4], ZGRADT + jne .load + mov eax, SEL_ZFILE +.load: call sel_loadrb + call sel_slotsin + mov eax, [esp + 4] ; its palettes, in rows of its own, + call selremap + call seldrawpal ; there again as it is drawn + cmp dword [esp + 4], ZGRADT + jne .jag + call selzdraw + jmp .done +.jag: mov byte [seljagdraw], 1 ; drawn with its head (selpart_a) +%rep 4 + push dword [esp + 16] +%endrep + call .draw + add esp, 16 + mov byte [seljagdraw], 0 +.done: mov byte [sel_remap], 0 + jmp sel_slotsout + +; Jaguarandi's head is a group of its own in its fight model, posed apart +; from its body; Raiden's select model, whose motions it takes, has the +; head in its chest. So after the chest, the head, at the neck: its fight +; model's head joint as its chest's mesh sees it (bone 10 and 7 of its +; upper body: the chest's mesh at (0, 16.4, 1.39) turned -3778 about x, +; the head at (0, 18.39, 2.12) turned -3775), handed to the renderer as +; the posed draw does each part. In place of the posed draw's +; call of a part's meshes (cdecl, the three and 0); ebp the select model's +; frame, [ebp-0x18] the bone. +SEL_CHEST equ 7 +SEL_HEAD equ 0x18 ; a fight model's head, its first group +SEL_NECKX equ -3775 + 3778 ; the head's turn from the chest's +selpart_a: + cmp byte [seljagdraw], 0 + je BS_MESHA + cmp dword [ebp - 0x18], SEL_CHEST + jne BS_MESHA +%rep 4 + push dword [esp + 16] +%endrep + call BS_MESHA + add esp, 16 + call BS_MPUSHA + push dword [sel_neck + 8] + push dword [sel_neck + 4] + push dword [sel_neck] + call BS_VIEWA + add esp, 12 + push SEL_NECKX + call BS_ROTXA + add esp, 4 + call BS_MSETA + mov eax, [BS_JAGA + SEL_HEAD] + push 0 + push dword [eax + 0xc + 8] + push dword [eax + 0xc + 4] + push dword [eax + 0xc] + call BS_MESHA + add esp, 16 + call BS_MPOPA + call BS_MSETA + ret + +; Z-Gradt's body, on the matrix the hangar puts a machine on (cdecl, as +; the select's model); then the parts its fight draws by hand, at its +; root bone, as its idle has them (selzparts). +SEL_ZBONES equ 26 +SEL_ZPART equ 20 ; a part: its meshes, place, turn +SEL_ZROOT equ 25 ; its root bone, +SEL_ZPODS equ 4 ; its parts before its head +SEL_ZREC equ 0x14 ; a bone's turn and place in a frame +selzdraw: + pushad + call BS_MPUSHA + cmp dword [boss], ZGRADT ; flying out: leant and turning + jne .pose + cmp dword [BS_SELOBJ + SEL_ZOBJ * SEL_OBJ + SEL_OBJST], 2 + jne .pose + push 0 + push dword [sel_zpivot] + push 0 + call BS_VIEWA + add esp, 12 + sub esp, 4 + fld dword [sel_ztilt] + fistp dword [esp] + call BS_ROTXA + push dword [sel_zspin] + call BS_ROTYA + add esp, 8 + push 0 + push dword [sel_zpivotn] + push 0 + call BS_VIEWA + add esp, 12 +.pose: +%rep 3 + push dword [sel_zscale] +%endrep + call BS_MSCALEA + add esp, 12 + call sel_loadzmot ; its motion (esi) and frame (edi): + mov esi, selzmot ; standing still till taken, + xor edi, edi + cmp dword [boss], ZGRADT + jne .posed + cmp dword [BS_SELOBJ + SEL_ZOBJ * SEL_OBJ + SEL_OBJST], 2 + jne .posed + mov eax, [BS_SELOBJ + SEL_ZOBJ * SEL_OBJ] + lea ecx, [eax - SEL_LAUNCH] + test ecx, ecx ; then in its stance; + jl .stance + cmp ecx, SEL_ZDIPN + jge .rec + lea edi, [ecx + ecx] ; as its thrusters light, its jump's + mov esi, selzdip ; dip, twice as fast, + jmp .clamp +.rec: cmp ecx, 2 * SEL_ZDIPN + jge .stance + lea edi, [ecx - SEL_ZDIPN] ; and its spring as it lifts off; + add edi, edi + mov esi, selzrec + jmp .clamp +.stance: + movzx ecx, word [esi + 4] ; then its stance again + xor edx, edx + div ecx + mov edi, edx +.clamp: movzx ecx, word [esi + 4] ; (a motion of one frame if they + cmp edi, ecx ; could not be read) + jb .posed + lea edi, [ecx - 1] +.posed: push 0 ; its meshes as a fight has them, + push 1 ; drawn, + push edi ; at that frame + push selzvar + push selzout + push dword [BS_ZGA + 0x10] ; its bones + push esi + call BS_POSEA + add esp, 28 + imul edi, edi, SEL_ZBONES ; the root bone, as the frame has it + add edi, SEL_ZROOT + imul edi, edi, SEL_ZREC + add edi, [esi] + push dword [edi + 0x10] + push dword [edi + 0xc] + push dword [edi + 8] + call BS_VIEWA + add esp, 12 + movsx eax, word [edi + 4] + push eax + call BS_ROTZA + movsx eax, word [edi + 2] + mov [esp], eax + call BS_ROTYA + movsx eax, word [edi] + mov [esp], eax + call BS_ROTXA + add esp, 4 + mov esi, selzparts +.part: cmp dword [esi], 0 + je .parts + cmp esi, selzparts + SEL_ZPODS * SEL_ZPART + jne .draw + call BS_MPUSHA ; past its pods, the rest bounced + call selzbounce +.draw: + call BS_MPUSHA + push dword [esi + 12] + push dword [esi + 8] + push dword [esi + 4] + call BS_VIEWA + add esp, 12 + push dword [esi + 16] + call BS_ROTYA + add esp, 4 + call BS_MSETA + mov eax, [esi] + push 0 + push dword [eax + 8] + push dword [eax + 4] + push dword [eax] + call BS_MESHA + add esp, 16 + call BS_MPOPA + add esi, SEL_ZPART + jmp .part +.parts: call BS_MPOPA + cmp dword [boss], ZGRADT ; flying out: its thruster lit, + jne .done + mov eax, [BS_SELOBJ + SEL_ZOBJ * SEL_OBJ] + cmp dword [BS_SELOBJ + SEL_ZOBJ * SEL_OBJ + SEL_OBJST], 2 + jne .done + cmp eax, SEL_LAUNCH + jle .done + cmp dword [BS_SLOTS + SEL_RAIFILE * 4], 0 ; the flames are + jne .lit ; meshes of Raiden's fight model, which + push 1 ; the select loads as it draws Raiden: + push 0 ; not yet on a continue, the cursor + push -1 ; already on Z-Gradt. Loaded as the + push SEL_RAIDEN ; select does (0x59cbfe), by machine + call BS_LOADFILE + add esp, 16 +.lit: xor ebx, ebx ; Raiden's booster's, larger, under +.flame: call BS_MPUSHA ; it, twice, a quarter turn apart: + push 0 ; four jets + push dword [sel_zflamey] + push 0 + call BS_VIEWA + add esp, 12 + push ebx + call BS_ROTYA + add esp, 4 + mov eax, [BS_SELOBJ + SEL_ZOBJ * SEL_OBJ] + sub eax, SEL_LAUNCH ; lighting: the jets grow out of it, + cmp eax, SEL_ZJET ; down, over the first frames + jbe .grow + mov eax, SEL_ZJET +.grow: push dword [sel_one] + push eax + fild dword [esp] + fidiv dword [sel_zjet] + fstp dword [esp] + push dword [sel_one] + call BS_MSCALEA + add esp, 12 + push dword [sel_zflamerx] + call BS_ROTXA + add esp, 4 +%rep 3 + push dword [sel_zflames] +%endrep + call BS_MSCALEA + add esp, 12 + call BS_MSETA + mov eax, [BS_SELOBJ + SEL_ZOBJ * SEL_OBJ] + dec eax ; its flicker, four frames + and eax, 3 + lea eax, [eax + eax * 2] + shl eax, 2 + add eax, [BS_SELFLAME + SEL_RAIDEN * 4] + push 0 + push dword [eax + 8] + push dword [eax + 4] + push dword [eax] + call BS_MESHA + add esp, 16 + call BS_MPOPA + add ebx, 0x4000 + cmp ebx, 0x8000 + jb .flame +.done: call BS_MPOPA + call BS_MSETA + popad + ret + +; Z-Gradt's head - its core, crown, rings and the rest past its pods - +; bouncing, as its fight's jump bounces it: for sel_zhead frames, about z +; and y while more than SEL_ZSHAKE are left, about x, and up and down, by +; as much as are left, with the frame. +SEL_ZSHAKE equ 0x18 +selzbounce: + mov ecx, [sel_zhead] + test ecx, ecx + jz .out + sub esp, 4 + mov eax, [BS_FRAMEA] + sub ecx, SEL_ZSHAKE + jle .nod + mov edx, eax ; about z + shl edx, 11 + lea edx, [edx + edx * 2] + mov [esp], ecx + fild dword [esp] + fmul dword [sel_eight] + call .sin + fistp dword [esp] + call BS_ROTZA + mov eax, [BS_FRAMEA] ; and y + mov edx, eax + shl edx, 12 + mov ecx, [sel_zhead] + sub ecx, SEL_ZSHAKE + mov [esp], ecx + fild dword [esp] + fmul dword [sel_four] + call .sin + fistp dword [esp] + call BS_ROTYA +.nod: mov eax, [BS_FRAMEA] ; about x + mov edx, eax + shl edx, 10 + lea edx, [edx + edx * 2] + fild dword [sel_zhead] + fmul dword [sel_four] + call .sin + fistp dword [esp] + call BS_ROTXA + add esp, 4 + mov eax, [BS_FRAMEA] ; and up and down + add eax, 10 + lea edx, [eax * 8] + sub edx, eax + shl edx, 10 + push 0 + fild dword [sel_zhead] + fmul dword [sel_zbob] + call .sin + sub esp, 4 + fstp dword [esp] + push 0 + call BS_VIEWA + add esp, 12 +.out: ret +; st0 times the sine of the angle dx (a word); eax, edx spent. +.sin: push edx + fild word [esp] + fmul dword [sel_zturn] + fsin + fmulp st1, st0 + pop edx + ret + +; Z-Gradt's motions from MT_zig.bin, the first time it is drawn: its +; battle stance (the one that loops) and its jump - the dip as it is +; pressed, the spring back as it is let go - each read into its own buffer +; and its motion pointed at it (selzmots). +SEL_ZFRAMES equ 120 ; the stance's frames, +SEL_ZJUMPF equ 60 ; the dip's and the spring's +SEL_ZDIPN equ SEL_ZJUMPF / 2 ; frames, played twice as fast +%define ZMOTSZ(n) ((n) * SEL_ZBONES * SEL_ZREC) +sel_loadzmot: + cmp byte [selzmotok], 0 + jne .out + mov byte [selzmotok], 1 ; tried, once + pushad + push selzmtname + push BS_RBDIR + push BS_PATHFMT + push selpath + call BS_SPRINTF + add esp, 16 + push 0 + push 0x80 ; normal + push 3 ; existing + push 0 + push 1 ; shared for reading + push 0x80000000 ; reading + push selpath + call [BS_CREATEF] + cmp eax, -1 + je .done + mov ebx, eax + mov esi, selzmots +.next: cmp dword [esi], 0 + je .shut + push 0 ; from the start + push 0 + push dword [esi] + push ebx + call [BS_SEEKF] + push 0 + push selzgot + push dword [esi + 4] + push dword [esi + 8] + push ebx + call [BS_READF] + mov eax, [esi + 4] + cmp [selzgot], eax + jne .shut + mov edi, [esi + 12] ; read: the motion is these frames + mov eax, [esi + 8] + mov [edi], eax + mov eax, [esi + 16] + mov [edi + 4], ax + add esi, 20 + jmp .next +.shut: push ebx + call [BS_CLOSEF] +.done: popad +.out: ret + +; The hangar draws a machine only within 28.43 ahead of the camera along +; the row (BS_SELAHEAD), and the widescreen hangar fades one to black +; there, so a machine comes into the drawn stretch unseen. A boss is +; further along than the eight's 20 apart, and selfade shades it in the +; eight's measure, each gap to the camera counted as 20: so the stretch +; reaches to where that measure comes to 28.43 - Jaguarandi's gap and +; what is left of the 28.43 past 20, Z-Gradt's first gap and the +; remainder in its second gap's units - and a boss comes in black too. +; In place of `fadd qword [28.43]`, a nop after; [ebp+0xc] the scene +; object, st0 the camera's place. +SEL_JOBJ equ SEL_EIGHT ; Jaguarandi's scene object, and +SEL_ZOBJ equ SEL_EIGHT + 1 ; Z-Gradt's +selcull_a: + fadd qword [BS_SELAHEAD] + cmp dword [ebp + 0xc], SEL_JOBJ + je .jag + cmp dword [ebp + 0xc], SEL_ZOBJ + jne .out + fld qword [BS_SELAHEAD] + fsub dword [sel_twenty] ; the measure left past the first gap, + fmul dword [sel_step] ; in the second gap's units + fdiv dword [sel_twenty] + fadd dword [sel_zgap] ; the way to it in all, + fsub qword [BS_SELAHEAD] ; past the eight's + faddp st1, st0 + ret +.jag: fadd dword [sel_step] ; its gap counted as 20 + fsub dword [sel_twenty] +.out: ret + +; The launch's sled, under the machine taken as it goes, is for the eight +; and Jaguarandi: Z-Gradt flies. In place of `cmp [the player's state], 0` +; in the sled's draw, a nop after; eax the player times 0x15, and the +; cursor, once taken, the machine's scene object. +selsled_a: + cmp dword [eax * 4 + BS_SELCUR + SEL_STATE], 0 + je .out ; nothing taken: no sled + cmp dword [eax * 4 + BS_SELCUR], SEL_ZOBJ ; Z-Gradt: as if +.out: ret ; nothing + +; Z-Gradt's launch: the launch carries it along the row and out of the +; hangar as it does the eight, but in the air - it lifts off the deck as +; the launch sets off (SEL_ZRISE frames, sel_zup a frame), flies at that +; height through the hangar and its tunnel, and once past the tunnel's +; mouth (sel_zexit, where the camera waits outside) speeds up, drops to +; skim the water as the eight do, and far out climbs away. Its height is set from its frame and place each +; tick, the launch's own (its hop, its arc) not stored (selzy_a). It leans +; into its flight, its thruster underneath trailing (sel_ztilt, eased +; towards the way it moved this frame), and outside it turns about itself +; (sel_zspin); selzdraw applies both. The camera of the player who +; took it looks up as it rises, by sel_zeye of each step. From the tick, +; on the select in one player. +SEL_STATE equ 0x8 - 0x44 ; a player's state, from its cursor +SEL_OBJST equ 0xc ; a scene object's state: 2 launching +SEL_OBJY equ 0x34 ; its height +SEL_LAUNCH equ 0xb0 ; its frame as the launch moves it +SEL_ZRISE equ 40 +SEL_ZHIT equ 0x14 ; its sounds (the sound test's names): +SEL_ZFSE equ 0x1c ; SDE_hit_03 and SDE_fse_05, +SEL_ZJUMP equ 0x19 ; SDE_jump_02, SDE_bom_12 - common +SEL_ZBLAST equ 7 ; ones (its own aren't loaded here) +SEL_ZHEAD equ 0x20 ; its head's bounce, frames (its jump's) +SEL_ZCHARGE equ 40 ; the first two, frames before it lifts + ; (any sooner and the select's end, + ; 128 frames in, cuts it off) +SEL_ZJET equ 20 ; the frames its thruster takes to light +SEL_ZSPIN equ 0x200 ; its turn a frame out there +SEL_TGTZ equ 0x20 - 0x44 ; what a player's camera looks at's place +selzlift: + cmp dword [boss], ZGRADT + jne .out + mov edx, BS_SELOBJ + SEL_ZOBJ * SEL_OBJ + cmp dword [edx + SEL_OBJST], 2 + jne .out + cmp dword [sel_zhead], 0 ; its head's bounce running down + je .headed + dec dword [sel_zhead] +.headed: + mov eax, [edx] + sub eax, SEL_LAUNCH + jg .fly + cmp eax, -SEL_ZCHARGE ; not off yet: just before, its + jne .wait ; thrusters charging, its head + mov dword [sel_zhead], SEL_ZHEAD ; bouncing + push edx + push SEL_ZHIT + call BS_SFX + push SEL_ZFSE + call BS_SFX + add esp, 8 + pop edx +.wait: mov eax, [edx + SEL_OBJZ] ; and where it starts from + mov [sel_zprevz], eax + ret +.fly: cmp eax, 1 ; its thrusters lighting: a jet's + jne .lit ; lift + push eax + push edx + push SEL_ZJUMP + call BS_SFX + add esp, 4 + pop edx + pop eax +.lit: cmp eax, SEL_ZRISE + 1 ; off, setting off along: a blast + jne .go + push eax + push edx + push SEL_ZBLAST + call BS_SFX + add esp, 4 + pop edx + pop eax +.go: fld dword [sel_zy] ; the deck, + mov ecx, eax + cmp ecx, SEL_ZRISE + jbe .rise + mov ecx, SEL_ZRISE +.rise: push ecx + fild dword [esp] + pop ecx + fmul dword [sel_zup] ; lifted off it, + faddp st1, st0 + cmp eax, SEL_ZRISE ; and, off, flying faster than the + jbe .lifting ; sled would carry it + fld dword [sel_zthrust] + call .ahead +.lifting: + fld dword [sel_zexit] ; and, past the tunnel's mouth, + fsub dword [edx + SEL_OBJZ] + fldz + fcomip st0, st1 + jb .out2 + fstp st0 + jmp .set +.out2: add dword [sel_zspin], SEL_ZSPIN ; turning, + fld dword [sel_zfast] ; faster again, + call .ahead + fld st0 ; down over the water, + fmul dword [sel_zdive] + fld dword [sel_zdivemax] + fcomi st0, st1 + jb .deep + fstp st0 + jmp .dive +.deep: fstp st1 +.dive: fsubp st2, st0 + fsub dword [sel_zskim] ; and, far out, climbing away + fldz + fcomip st0, st1 + jb .climb + fstp st0 + jmp .set +.climb: fmul st0, st0 + fmul dword [sel_zclimb] + faddp st1, st0 +.set: fld st0 ; the step up, + fsub dword [edx + SEL_OBJY] + fxch st1 + fstp dword [edx + SEL_OBJY] + fld dword [edx + SEL_OBJZ] ; and along + fld st0 + fsub dword [sel_zprevz] + fxch st1 + fstp dword [sel_zprevz] + fld st1 ; the way it went: its lean + fpatan + fmul dword [sel_zrad] + fsub dword [sel_ztilt] + fmul dword [sel_zease] + fadd dword [sel_ztilt] + fstp dword [sel_ztilt] + fmul dword [sel_zeye] + xor ecx, ecx ; the camera of whichever player took it +.cam: cmp dword [BS_SELCUR + ecx], SEL_ZOBJ + jne .next + fld dword [BS_SELCUR + ecx + SEL_TGTY] + fadd st0, st1 + fstp dword [BS_SELCUR + ecx + SEL_TGTY] +.next: add ecx, 0x54 + cmp ecx, 2 * 0x54 + jb .cam + fstp st0 +.out: ret +; Z-Gradt st0 further along its way this frame, and the camera of the +; player who took it looking as much further; st0 popped. +.ahead: fld dword [edx + SEL_OBJZ] + fsub st0, st1 + fstp dword [edx + SEL_OBJZ] + xor ecx, ecx +.tgt: cmp dword [BS_SELCUR + ecx], SEL_ZOBJ + jne .tnext + fld dword [BS_SELCUR + ecx + SEL_TGTZ] + fsub st0, st1 + fstp dword [BS_SELCUR + ecx + SEL_TGTZ] +.tnext: add ecx, 0x54 + cmp ecx, 2 * 0x54 + jb .tgt + fstp st0 + ret + +; The launch shows the hangar's outside - the dock, the sea - and hides its +; inside, whose grey hides the sky, by its floor's timetable, from the +; frames a machine gets there; Z-Gradt, flying, gets there sooner. Outside +; from just before the camera cuts there, inside gone as it comes to the +; tunnel's mouth. In place of `mov eax, [ticks]` after the timetable; +; [ebp-4] the launch's frame. +SEL_ZSKY equ 224 +selsky_a: + cmp dword [BS_G1PA], ZGRADT + jne .out + cmp dword [ebp - 4], SEL_ZSKY + jl .out + mov dword [BS_SELSKY], 1 + fld dword [sel_zexit] + fsub dword [sel_zclear] + fcomp dword [BS_SELOBJ + SEL_ZOBJ * SEL_OBJ + SEL_OBJZ] + fnstsw ax + test ah, 1 ; Z-Gradt short of it: still inside + jnz .out + mov dword [BS_SELIN], 0 +.out: mov eax, [BS_SELTICKS] + ret + +; Out over the sea a launch throws up spray under the machine, every fourth +; frame from a frame that has the eight past the camera; Z-Gradt is far out +; by then. Its spray starts by its place instead - well past the tunnel's +; mouth - while it skims, below the deck. In place of +; `cmp [the spray's frame], [the machine's frame]`, the next `jge` skipping +; it; ecx the machine's scene object times 0x15. +selspray_a: + cmp ecx, SEL_ZOBJ * 0x15 + je .z + cmp eax, [ecx * 4 + BS_SELOBJ] + ret +.z: push eax + fld dword [sel_zexit] + fsub dword [sel_zclear2] + fcomp dword [ecx * 4 + BS_SELOBJ + SEL_OBJZ] + fnstsw ax + test ah, 1 ; short of it + jnz .skip + fldz + fcomp dword [ecx * 4 + BS_SELOBJ + SEL_OBJY] + fnstsw ax + test ah, 1 ; or climbing away + jnz .skip + xor eax, eax ; spray: less + cmp eax, 1 + pop eax + ret +.skip: xor eax, eax ; none: not less + cmp eax, eax + pop eax + ret + +; In place of the launch's `fstp [a scene object's height]` (its hop off +; the conveyor, its arc out of the hangar), two nops after; eax the object +; times 0x15. Z-Gradt's is selzlift's. +selzy_a: + cmp eax, SEL_ZOBJ * 0x15 + je .z + fstp dword [eax * 4 + BS_SELOBJ + SEL_OBJY] + ret +.z: fstp st0 + ret + +; Entering the select asks for the palettes about the cursor (event 0x18 +; and the cursor); the game's events stop at the eighth, so on a boss it +; would load none and Raiden show what the slots last held: on a boss, +; Raiden's. And it has just put the camera 20 along the row a machine; on +; a boss it is put where the moves there leave it - further along, and at +; Z-Gradt up, looking up and back (selstep_*). In place of +; `mov eax, [eax*4 + the cursor]`, two nops after; eax the player times +; 0x15. +SEL_LAST equ 7 ; Raiden's cursor, the last +selpalev_a: + push edx + lea edx, [eax * 4 + BS_SELCUR] + mov eax, [edx] + cmp eax, JAG + jb .out + fld dword [sel_bstep] ; Raiden to Jaguarandi, past 20 + fmul dword [sel_twenty] + fsub dword [sel_twenty] + cmp eax, ZGRADT + jne .along + fld dword [sel_zstep] ; and on to Z-Gradt, past 20 again + fmul dword [sel_twenty] + fsub dword [sel_twenty] + faddp st1, st0 +%macro SELUP 2 ; the field, its step a frame + fld dword [%2] + fmul dword [sel_twenty] + fadd dword [edx + %1] + fstp dword [edx + %1] +%endmacro + SELUP SEL_EYEY, sel_zrise + SELUP SEL_TGTY, sel_zlook + SELUP SEL_DIST, sel_zback +.along: fld st0 + fadd dword [edx + SEL_CAM] + fstp dword [edx + SEL_CAM] + fadd dword [edx + SEL_TGTZ] + fstp dword [edx + SEL_TGTZ] + mov eax, SEL_LAST +.out: pop edx + ret + +; The launch shows the hangar's floor a section at a time, as the machine +; goes by, by a timetable a machine; one past the eight's shows none. A +; boss goes by Raiden's, whose launch Jaguarandi's is. In place of +; `mov eax, [the player's machine]`. +selfloor_a: + mov eax, [BS_G1PA] + cmp eax, JAG + jb .out + mov eax, SEL_RAIDEN +.out: ret + +; The bosses' meshes read palette rows 1 and 3 (5 and 7 as the CPU's), +; which the select fills with the eight's (1 to 11, about the cursor). So +; on the select each boss has two rows of its own, sel_bslots, of those +; the game sets once and the select does not use (its thrust is 17 and +; 19), their own kept while it shows and put back after (selpalback); its +; palettes kept in them; and while it is drawn the rows its polygons name +; are turned to those (selremap, selcol). It is lit, then, wherever +; it is, and the widescreen hangar fades it at the right edge as it does +; the eight. From the tick, on the select in one player, pushad'd. +SEL_PALRAM equ 0x200 ; a row, in each of its three planes +SEL_PLANE equ 0x4000 +SEL_OBJ equ 0x54 ; a scene object, and its place +SEL_OBJZ equ 0x38 ; along the row +SEL_CAM equ 0x34 - 0x44 ; a player's camera, from its cursor +seljagpal: + cmp byte [selbuilt], 0 + je .out + call selstate + jne .out + mov ebx, [sel_launch] ; one of the eight launching: the + cmp ebx, SEL_LREG ; rows the game's (its water) + je .out + test ebx, ebx ; a boss: so too, it in rows 1 and 3, + jz .look ; the cursor's, which the game leaves + mov esi, sel_lpair ; on a boss + jmp selbosspal +.look: + cmp byte [sel_rowsin], 0 ; the rows' own, kept till it ends + jne .kept + mov byte [sel_rowsin], 1 + xor esi, esi + mov edi, sel_rowskept + call selrows_each +.kept: mov ebx, JAG + mov esi, sel_bslots +.boss: lea eax, [ebx - 7] + cmp eax, [unl_level] + ja .out + push ebx + push esi + call selbosspal + pop esi + pop ebx + add esi, 8 + inc ebx + cmp ebx, ZGRADT + jbe .boss +.out: ret + +SEL_LREG equ -1 +SEL_GOES equ 2 ; a scene object's state: launching +; ZF set on the select or a launch from it (A's state). +SEL_STLAUNCH equ 5 +selstate: + cmp dword [BS_STATEA], ST_SELECT + je .out + cmp dword [BS_STATEA], SEL_STLAUNCH +.out: ret + +; Off them, from the tick: the rows as they were (pushad'd). +selpalguard: + call selstate + jne .off + mov eax, [sel_launch] + test eax, eax + jnz .have + xor eax, eax ; set off: a machine's object (two +.obj: imul ecx, eax, SEL_OBJ ; on) to 2, the rest 1 as the row + cmp dword [ecx + BS_SELOBJ + 2 * SEL_OBJ + SEL_OBJST], SEL_GOES + je .moving ; moves aside; kept from then till + inc eax ; the select is left (as it opens + cmp eax, ZGRADT ; one is 2 too; the cursor is its + jbe .obj ; object as it goes) + mov dword [sel_objst], 0 + ret +.moving: + mov edx, [sel_objst] + mov dword [sel_objst], 1 + test edx, edx + jnz .out + cmp eax, JAG + jae .set + mov eax, SEL_LREG +.set: mov [sel_launch], eax +.have: jmp selpalback ; all the game's (its water's) +.out: ret +.off: mov dword [sel_launch], 0 + mov dword [sel_objst], -1 + jmp selpalback + +; eax the boss: its two rows (esi); 1 and 3 while it launches. +selpair: + cmp eax, [sel_launch] + je .launch + lea esi, [sel_bslots + (eax - JAG) * 8] + ret +.launch: + mov esi, sel_lpair + ret + +; The rows as they were. +selpalback: + cmp byte [sel_rowsin], 0 + je .out + mov byte [sel_rowsin], 0 + mov esi, sel_rowskept + call selrows_each +.out: ret + +; Each of the bosses' rows, each plane: copied to edi, or from esi. +selrows_each: + cld + mov ebx, sel_bslots +.row: mov edx, [ebx] + shl edx, 9 ; a row + add edx, BS_PALRAMA + xor eax, eax +.plane: push esi + push edi + mov ecx, SEL_PALRAM / 4 + test esi, esi + jz .out + mov edi, edx ; back + jmp .copy +.out: mov esi, edx ; out +.copy: rep movsd + pop edi + pop esi + test esi, esi + jz .on + add esi, SEL_PALRAM + jmp .next +.on: add edi, SEL_PALRAM +.next: add edx, SEL_PLANE + inc eax + cmp eax, 3 + jb .plane + add ebx, 4 + cmp ebx, sel_bslots + 4 * 4 + jb .row + ret + +; A palette load fills a row's entries 0 to 63 and 128 to 191; the rest, +; read as a machine is shaded dark (the widescreen hangar's fade), the +; select's rows hold the game's own, which the bosses' rows are given too +; (row 1's). +SEL_PALHALF equ 0x80 ; bytes, 64 entries: a quarter row +selrest: + cld + xor eax, eax +.plane: mov ecx, eax + shl ecx, 14 ; a plane + lea edx, [ecx + BS_PALRAMA + SEL_PALRAM + SEL_PALHALF] ; row 1's + lea esi, [ecx + BS_PALRAMA] + mov ecx, [ebx] + shl ecx, 9 + lea edi, [esi + ecx + SEL_PALHALF] + mov esi, edx + mov ecx, SEL_PALHALF / 4 + rep movsd ; entries 64 to 127 + add esi, SEL_PALHALF + add edi, SEL_PALHALF + mov ecx, SEL_PALHALF / 4 + rep movsd ; and 192 to 255 + inc eax + cmp eax, 3 + jb .plane + ret + +; The game sets row 21 for a frame as the cursor arrives at a machine, +; after the tick and before the draws, and the frame is rastered after +; them; so a boss's palettes go in again as it is drawn. eax the boss. +seldrawpal: + cmp dword [sel_launch], 0 ; launching (in rows 1 and 3) + jg .go + cmp byte [sel_rowsin], 0 + je .out +.go: pushad + mov ebx, eax + call selpair + call selbosspal + popad +.out: ret + +; ebx the boss, esi its two rows: its palettes into them, in the colours +; it was given here. +selbosspal: + push ebx + mov ebx, esi + call selrest + add ebx, 4 + call selrest + sub ebx, 4 + mov esi, ebx + pop ebx + mov edi, [esi] + mov esi, [esi + 4] + mov eax, ebx + call selbcol + test edx, edx + jnz .worn + shl ebx, 2 ; its own + push ebx + push edi + call BS_PALLOADA + add esp, 8 + inc ebx + push ebx + push esi + call BS_PALLOADA + add esp, 8 + ret +.worn: push esi ; or one of the eight's: its pair, from + xor ecx, ecx ; the side this select's player is on + cmp dword [BS_MODEA], 0 + je .side + mov ecx, 2 +.side: lea esi, [ecx + eax * 4] + lea esi, [BS_PALA + esi * 4] + lea ebx, [edx * 2 - 2] ; its pair + mov eax, [esi] + push dword [eax + ebx * 4] + push edi + call BS_PALSETA + add esp, 8 + mov eax, [esi + 4] + pop edi ; the second row + push dword [eax + ebx * 4 + 4] + push edi + call BS_PALSETA + add esp, 8 + ret + +; The widescreen hangar shades a machine by how far right of the camera +; it is, black past 28.43, a machine and a half at the eight's 20 apart. +; A boss is further on - Jaguarandi 30 past Raiden, Z-Gradt 98 past it, +; and the camera stops 30 short of Z-Gradt - so it is shaded again here by +; that distance in the eight's measure: each gap to the camera counted as +; 20 (sel_fjag, sel_fz; past the list as it is). From selmdl_a, eax the +; boss, ebp the hangar's frame: [ebp+8] the camera's object, [ebp+0xc] +; the machine's; only when called from the widescreen hangar_draw (the +; return in its blob). +SEL_HDIM equ 0x1e64 ; ui.asm's D_DIM, from its blob's start +SEL_UISIZE equ 0x1c00 ; its code +selfade: + pushad + mov ecx, [BS_HSITE + 1] ; the hangar's call: the widescreen's? + lea ecx, [ecx + BS_HSITE + 5] + cmp ecx, BS_SELMDLA + je .out + sub ecx, BS_HDOFF + mov edx, [esp + 32 + 4] ; and it the caller + sub edx, ecx + cmp edx, SEL_UISIZE + jae .out + mov esi, sel_fjag + cmp eax, ZGRADT + jne .go + mov esi, sel_fz +.go: mov eax, [ebp + 8] + imul eax, eax, SEL_OBJ + fld dword [eax + BS_SELCAM] + mov eax, [ebp + 0xc] + imul eax, eax, SEL_OBJ + fsubr dword [eax + BS_SELOBJ + SEL_OBJZ] ; how far right + fldz ; the eight's measure of it +.gap: mov edx, [esi] + test edx, edx + jz .rest + fld dword [edx] ; the gap, the measure, the distance + fcomi st0, st2 + jae .part + fsub st2, st0 ; past it: a whole one + fstp st0 + fadd dword [sel_twenty] + add esi, 4 + jmp .gap +.part: fdivp st2, st0 ; into it: its share of one + fxch + fmul dword [sel_twenty] +.rest: faddp st1, st0 + fsubr dword [sel_fedge] ; short of the edge, over the fade + fmul dword [sel_fslope] + fld1 + fcomip st0, st1 + jbe .full ; 1 or more: left alone + fld dword [sel_ffloor] ; at least the floor (0 would be none) + fcomi st0, st1 + jb .over + fstp st1 + jmp .set +.over: fstp st0 +.set: fmul dword [sel_f65536] + fistp dword [ecx + SEL_HDIM] + jmp .out +.full: fstp st0 + mov dword [ecx + SEL_HDIM], 0 +.out: popad + ret + +; eax the boss being drawn: its slots for the ones its polygons name. +selremap: + pushad + call selpair + mov ebx, [esi] + mov edi, sel_remapto + call .find + mov ebx, [esi + 4] + add edi, 4 + call .find + mov byte [sel_remap], 1 + popad + ret +.find: imul eax, ebx, SEL_GREY ; row ebx's grey, its first entry + mov ecx, SEL_FIXED ; of those the game leaves as they are +.look: cmp [BS_COLTAB + ecx * 4], eax + je .found + inc ecx + cmp ecx, SEL_COLS + jb .look + pop eax ; none: not turned + popad + ret +.found: mov [edi], ecx + ret + +; A polygon's palette rows are its colour word's top ten bits (at +6 in +; its mesh) through a table of colours (BS_COLTAB), a byte a plane whose +; top five bits are the row; the raster reads the word from the mesh as +; it draws, later in the frame. The bosses' name the greys of rows 1 and 3 +; (5 and 7). So while a boss is drawn on the select, each of its polygons +; queued that names one of those is turned, in its mesh, to the table's +; grey of its own row (selremap finds them). Its meshes there are copies +; of its own (sel_loadrb), drawn only here and on the unlock screen, +; which puts its palettes in both. In place of `mov esi, [polygon's +; light]` where the renderers queue a polygon, edx the record, its mesh +; polygon at +4; the flags kept. +SEL_PCOL equ 6 ; a mesh polygon's colour word +SEL_GREY equ 0x080808 ; row 1 in each plane, a step a row +SEL_COLS equ 1024 ; the table's entries, the game +SEL_FIXED equ 32 ; rewriting those below +selcol: + mov esi, [BS_POLYCOL] + cmp byte [sel_remap], 0 + jne .map + ret +.map: pushfd + push eax + push ecx + mov ecx, [edx + 4] + movzx eax, word [ecx + SEL_PCOL] + shr eax, 6 + mov eax, [BS_COLTAB + eax * 4] + cmp eax, SEL_GREY + je .first + cmp eax, SEL_GREY * 5 + je .first + cmp eax, SEL_GREY * 3 + je .second + cmp eax, SEL_GREY * 7 + je .second + push edx ; or a boss's rows, turned before: + xor ecx, ecx ; first or second as in its pair +.pair: imul edx, [sel_bslots + ecx * 4], SEL_GREY + cmp eax, edx + je .found + inc ecx + cmp ecx, 4 + jb .pair + pop edx + jmp .out +.found: pop edx + test ecx, 1 + mov ecx, [edx + 4] ; the polygon again + jz .first +.second: + mov eax, [sel_remapto + 4] + jmp .set +.first: mov eax, [sel_remapto] +.set: shl eax, 6 + and word [ecx + SEL_PCOL], 0x3f + or [ecx + SEL_PCOL], ax +.out: pop ecx + pop eax + popfd + ret + +; eax a boss: the colours it was given on the select, eax the machine +; they are and edx which of its, one on (0: its own, eax 0). +selbcol: + mov eax, [sel_bcol + (eax - JAG) * 4] + xor edx, edx + test eax, eax + jz .own + dec eax + mov ecx, 8 + div ecx + inc edx + ret +.own: ret + +; The camera slides 20 between machines, a unit a frame; to Jaguarandi +; and back, 30 - it is larger - 1.5 a frame; to Z-Gradt and back, +; sel_zgap, and up onto the hangar's lip and back to take in Z-Gradt's +; size. In place of `fsub` and `fadd qword [1.0]`, a nop after the call, +; at the camera's place along the row and at what it looks at (the same +; with an e: the place, which carries both their heights); [ebp+8] the +; player. +SEL_EYEY equ 0x30 - 0x44 ; a player's camera's height, and what +SEL_TGTY equ 0x1c - 0x44 ; it looks at's, and its distance, +SEL_DIST equ 0x40 - 0x44 ; from its cursor +selstep_sube: + push eax + call selcur + cmp eax, JAG ; arrived at Jaguarandi from Z-Gradt: + jne .row ; down + push eax + mov eax, [ebp + 8] + imul eax, eax, 0x54 + fld dword [eax + BS_SELCUR + SEL_EYEY] + fsub dword [sel_zrise] + fstp dword [eax + BS_SELCUR + SEL_EYEY] + fld dword [eax + BS_SELCUR + SEL_TGTY] + fsub dword [sel_zlook] + fstp dword [eax + BS_SELCUR + SEL_TGTY] + fld dword [eax + BS_SELCUR + SEL_DIST] + fsub dword [sel_zback] + fstp dword [eax + BS_SELCUR + SEL_DIST] + pop eax +.row: pop eax +selstep_sub: + push eax + call selcur + cmp eax, JAG ; arrived at Jaguarandi from Z-Gradt + je .z + cmp eax, 7 ; at Raiden from Jaguarandi + je .b + fsub dword [sel_one] + pop eax + ret +.z: fsub dword [sel_zstep] + pop eax + ret +.b: fsub dword [sel_bstep] + pop eax + ret +selstep_adde: + push eax + call selcur + cmp eax, ZGRADT ; arrived at Z-Gradt: up + jne .row + push eax + mov eax, [ebp + 8] + imul eax, eax, 0x54 + fld dword [eax + BS_SELCUR + SEL_EYEY] + fadd dword [sel_zrise] + fstp dword [eax + BS_SELCUR + SEL_EYEY] + fld dword [eax + BS_SELCUR + SEL_TGTY] + fadd dword [sel_zlook] + fstp dword [eax + BS_SELCUR + SEL_TGTY] + fld dword [eax + BS_SELCUR + SEL_DIST] + fadd dword [sel_zback] + fstp dword [eax + BS_SELCUR + SEL_DIST] + pop eax +.row: pop eax +selstep_add: + push eax + call selcur + cmp eax, ZGRADT ; arrived at Z-Gradt + je .z + cmp eax, JAG ; at Jaguarandi + je .b + fadd dword [sel_one] + pop eax + ret +.z: fadd dword [sel_zstep] + pop eax + ret +.b: fadd dword [sel_bstep] + pop eax + ret +selcur: + mov eax, [ebp + 8] + imul eax, eax, 0x54 + mov eax, [eax + BS_SELCUR] + ret + +; A boss's fight model, for drawing it outside a fight. Its meshes are +; found through the file slot its name has (SEL_JAGFILE, SEL_ZFILE), the +; game's loader putting files one after another in an 8 MB pool. The file +; is read once into a block of its own (sel_loadrb), and the slot points +; there only while a boss is drawn (sel_slotsin, sel_slotsout), the +; game's own pointer kept and put back: appended to the pool, it could +; run past its end into what follows - the C library's heap list, at the +; select after a game's end. The game's own copy, when it has one (a +; continue's select, after a fight as the boss), is never drawn here: +; selcol turns the colour words of the meshes it draws to the select's +; rows and never back, and the game fights on with the copy it has. +; eax the file slot, which is also its name's place. +sel_loadrb: + pushad + mov ebp, eax + cmp byte [sel_rbtry + ebp], 0 + jne .out ; or ours, read already (or tried) + mov byte [sel_rbtry + ebp], 1 + push dword [BS_RBNAMES + ebp * 8 + 4] + call BS_MALLOC + add esp, 4 + test eax, eax + jz .out + mov esi, eax + push dword [BS_RBNAMES + ebp * 8] + push BS_RBDIR + push BS_PATHFMT + push selpath + call BS_SPRINTF + add esp, 16 + push BS_RBMODE + push selpath + call BS_FOPEN + add esp, 8 + test eax, eax + jz .out + mov ebx, eax + push ebx + push 1 + push dword [BS_RBNAMES + ebp * 8 + 4] + push esi + call BS_FREAD + add esp, 16 + push ebx + call BS_FCLOSE + add esp, 4 + mov [sel_rbbuf + ebp * 4], esi +.out: popad + ret + +; Both bosses' slots to their blocks, the game's pointers kept, and back. +sel_slotsin: + pushad +%assign k 0 +%rep 2 + %if k + %define SLOT SEL_ZFILE + %else + %define SLOT SEL_JAGFILE + %endif + cmp byte [sel_rbin + k], 0 + jne .k%[k] + mov eax, [sel_rbbuf + SLOT * 4] + test eax, eax + jz .k%[k] + push dword [BS_SLOTS + SLOT * 4] + pop dword [sel_rbsave + k * 4] + mov [BS_SLOTS + SLOT * 4], eax + mov byte [sel_rbin + k], 1 +.k%[k]: + %undef SLOT +%assign k k + 1 +%endrep + popad + ret + +sel_slotsout: + cmp byte [sel_rbin], 0 + je .z + mov byte [sel_rbin], 0 + push dword [sel_rbsave] + pop dword [BS_SLOTS + SEL_JAGFILE * 4] +.z: cmp byte [sel_rbin + 1], 0 + je .out + mov byte [sel_rbin + 1], 0 + push dword [sel_rbsave + 4] + pop dword [BS_SLOTS + SEL_ZFILE * 4] +.out: ret + +; In place of the calls to the select's text for the cursor (cdecl, the +; cursor): for a boss, its weapons, its name and its model, as the game +; writes the eight's - the weapons on the plane its frame's parity picks, +; the name a block of tiles. +; Z-Gradt has a fourth, a line under the others', and the bosses' lines +; are longer than the eight's: on one of the eight, all four are blanked +; first on the plane it writes. +SEL_TXT equ 0x68 ; per boss: four weapons of 0x14, its +SEL_CODE equ 0x50 ; model, and its name: tiles, width, +SEL_LOGO equ 0x5c ; height +SEL_LINES equ 4 +selinfo_a: + mov eax, [esp + 4] + cmp eax, JAG + jge .boss + test eax, eax + jl BS_SELINFOA + push esi + call selplane + mov edx, selblank + call sellines + pop esi + jmp BS_SELINFOA +.boss: push ebx + push esi + lea ebx, [eax - JAG] + imul ebx, ebx, SEL_TXT + add ebx, seltxt + call selplane + mov edx, ebx + call sellines + push 0x10 + push 7 + call BS_TXTPOSA + add esp, 8 + push 3 + push 0x26 + call BS_TCLEARA + add esp, 8 + push dword [ebx + SEL_LOGO + 8] + push dword [ebx + SEL_LOGO + 4] + push dword [ebx + SEL_LOGO] + call BS_TBLOCKA + add esp, 12 + push 0xe + push 8 + call BS_TXTPOSA + add esp, 8 + lea eax, [ebx + SEL_CODE] + push eax + call BS_PRINT2A + add esp, 4 + pop esi + pop ebx + ret + +; The Quick VR Select, the game's option, writes the cursor's texts by a +; routine of its own (BS_SELQINFOA): PLAYER 1 or 2, then for the machine +; - the cursor is the machine there - three weapon lines at (BS_QTXTX, +; BS_QTXTY on, two rows apart) and the name block with its code two rows +; above at (7, BS_QTXTY + 2), from tables the bosses have no rows in, on +; one plane. For a boss: the game's for no machine (-1: PLAYER n and the +; blanks it prints for none), then the boss's four weapons, its name +; block and its code over them. For one of the eight, the four lines +; blanked first, as the hangar's are: the game writes its shorter lines +; over a boss's longer ones. In place of the call to it; [esp+4] the +; cursor. +selqinfo_a: + mov eax, [esp + 4] + cmp eax, JAG + jae .boss + test eax, eax + jl BS_SELQINFOA ; none: the game's blanks + push ebx + mov ebx, selblank + call .lines + pop ebx + jmp BS_SELQINFOA +.boss: push ebx + lea ebx, [eax - JAG] + imul ebx, ebx, SEL_TXT + add ebx, seltxt + push -1 + call BS_SELQINFOA + add esp, 4 + call .lines + mov eax, [BS_QTXTY] + add eax, 2 + push eax + push 7 + call BS_TXTPOSA + add esp, 8 + push 3 + push 0x26 + call BS_TCLEARA + add esp, 8 + push dword [ebx + SEL_LOGO + 8] + push dword [ebx + SEL_LOGO + 4] + push dword [ebx + SEL_LOGO] + call BS_TBLOCKA + add esp, 12 + push dword [BS_QTXTY] + push 8 + call BS_TXTPOSA + add esp, 8 + lea eax, [ebx + SEL_CODE] + push eax + call BS_PRINT2A + add esp, 4 + pop ebx + ret +.lines: push esi ; the four lines from ebx, 0x14 apart + push edi ; (or selblank's again) + mov esi, ebx + xor edi, edi +.line: mov eax, [BS_QTXTY] + add eax, edi + push eax + push dword [BS_QTXTX] + call BS_TXTPOSA + add esp, 8 + push esi + call BS_PRINT2A + add esp, 4 + cmp esi, selblank + je .same + add esi, 0x14 +.same: add edi, 2 + cmp edi, 2 * SEL_LINES + jb .line + pop edi + pop esi + ret + +; esi the print for the plane this frame writes, as the game picks it. +selplane: + mov eax, [BS_FRAMEA] + cmp dword [BS_SELMODE], 2 + jne .p + shr eax, 1 +.p: mov esi, BS_PRINT2A + test eax, 1 + jz .out + mov esi, BS_PRINT1A +.out: ret + +; The weapon lines, from edx, 0x14 apart (or one line again, selblank's), +; through esi. +sellines: + push ebx + mov ebx, edx +%assign i 0 +%rep SEL_LINES + push 0x14 + 2 * i + push 8 + call BS_TXTPOSA + add esp, 8 + push ebx + call esi + add esp, 4 + cmp ebx, selblank + je .same%[i] + add ebx, 0x14 +.same%[i]: +%assign i i + 1 +%endrep + pop ebx + ret + +; The portraits along the bottom are one block of tiles, eight of 6 by 8 +; a column apart; the marker over the cursor's goes a portrait further for +; each, so the bosses' are two more after Raiden's. Theirs are portraits +; drawn for the patch (assets/portrait_*.png), framed and backed as the +; eight's and written by the patcher into spare tiles of the artwork +; (boss_icon_tiles), 48 each in reading order, 0x80 apart as the select +; loads them. Made on entering the select: a boss's is blank in two +; players and while it is locked. Where the row is drawn is selshift's. +SEL_ROW equ 0x37 ; the eight's, wide +SEL_ROWW equ SEL_ROW + 2 * 7 ; and with the bosses' +SEL_ICON equ 6 +SEL_ICONW equ 0x137a ; the first tile's map entry +selrow_make: + cld + xor ebx, ebx +.row: imul esi, ebx, SEL_ROW * 2 + add esi, BS_ROW + mov dx, [esi + SEL_ICON * 2] ; the column between two + imul edi, ebx, SEL_ROWW * 2 + add edi, selrow + mov ecx, SEL_ROW + db 0xf3 ; rep, by hand: nasm 3.x writes the + movsw ; 66 before the f3, 2.x after, and + ; the blob must not depend on which + imul esi, ebx, SEL_ICON + add esi, SEL_ICONW + xor ebp, ebp ; the boss, 0 Jaguarandi + call .icon + add esi, 0x80 + inc ebp + call .icon + inc ebx + cmp ebx, 8 + jb .row + ret +.icon: mov ax, dx ; esi the row's first tile + stosw + mov ecx, SEL_ICON + cmp dword [GAMEMODE], 0 + jne .blank + cmp ebp, [unl_level] ; or a boss still locked + jae .blank + mov eax, esi +.tile: stosw + inc eax + loop .tile + ret +.blank: mov ax, dx + db 0xf3 ; rep, pinned; see above + stosw + ret + +; The row of ten portraits fits a standard-definition screen only once +; it is moved left; as the game has it, Z-Gradt's runs off the right. So +; in one player, with both bosses unlocked, it goes SEL_SHIFT2 columns +; left, and with Jaguarandi alone SEL_SHIFT1, which centres its nine; with +; it the 1P/2P marks over a portrait and the frame around it. With neither +; unlocked all of it is where the game puts it. In place of the column +; steps either side of the row, `add [column], 2` before it and `add +; [column], 0xc` after (the title back where it was), and of the four +; `lea eax, [eax*2 + place]` that put a mark or the frame; two nops after +; each call. +SEL_SHIFT1 equ 4 +SEL_SHIFT2 equ 7 +selshift: ; eax the shift, in columns + xor eax, eax + cmp dword [GAMEMODE], 0 + jne .out + cmp dword [unl_level], 1 + jb .out + mov eax, SEL_SHIFT1 + je .out + mov eax, SEL_SHIFT2 +.out: ret + +selrowx: + push eax + call selshift + neg eax + add eax, 2 + add [BS_TXTX], eax + pop eax + ret + +seltitlex: + push eax + call selshift + add eax, 0xc + add [BS_TXTX], eax + pop eax + ret + +%macro SELMARK 2 ; label, its place on the plane +%1: + push ecx + lea ecx, [eax * 2 + %2] + call selshift + add eax, eax + sub ecx, eax + mov eax, ecx + pop ecx + ret +%endmacro + + SELMARK selmark1, BS_PLANE + 0x17bc + SELMARK selmark2, BS_PLANE + 0x17c4 + SELMARK selframe1, BS_PLANE + 0x8 + SELMARK selframe2, BS_PLANE + 0x10 + +; The marks' row is cleared before they are drawn each frame, 62 tiles +; from the row's start (0x1f dwords), in the hangar and in the quick +; select. The shift puts the first portrait's mark before the start, so +; once drawn it stayed: a 1P on Temjin after the select started there. The +; clear starts the shift earlier and goes twice that further, past the +; tenth portrait's marks. In place of `mov dword [ebp-8], 0x1f` in each, +; two nops after; [ebp-4] the start. +selclr_a: + push eax + call selshift ; in tiles + add eax, eax + sub [ebp - 4], eax ; two bytes each, back + shr eax, 1 ; and as many dwords on: the tenth + add eax, 0x1f ; portrait's 2P mark is the furthest + mov [ebp - 8], eax + pop eax + ret + +; The select's countdown, seconds left = (SEL_TIME - frames) / 60 - 1: +; SEL_MORE seconds longer with a boss unlocked, in one player, for the +; walk to it and its colours. In place of `mov eax, SEL_TIME`. +SEL_TIME equ 0x4eb +SEL_MORE equ 20 +seltime: + mov eax, SEL_TIME + cmp dword [GAMEMODE], 0 + jne .out + cmp dword [unl_level], 0 + je .out + add eax, SEL_MORE * 60 +.out: ret + +; The frame round the portrait under a cursor is a sprite, at the +; portrait's place in pixels plus two doubles in .rdata (BS_FRX), which the +; patcher makes writable; from the tick, set for the shift each frame, +; from their own values kept in sel_frx. +selframex: + call selshift + shl eax, 3 ; 8 pixels a column + push eax + fild dword [esp] + add esp, 4 + fld qword [sel_frx] + fsub st1 + fstp qword [BS_FRX] + fld qword [sel_frx + 8] + fsubrp st1 + fstp qword [BS_FRX + 8] + ret + +; --- colour ---------------------------------------------------------------- + +; The loader's `jg` for an id above 7 comes here. [ebp+8] is the slot, +; [ebp+0xc] the palette id: machine * 4 + side * 2 + which of the pair. +pal_a: + mov edx, BS_PALA + call bosspal + test eax, eax + jz BS_PALFIXA + push eax + push dword [ebp + 8] + call BS_PALSETA + add esp, 8 + jmp BS_PALRETA + +; edx the palette table. eax the palette the player's boss wears +; for this id, or 0 to load its own. +bosspal: + xor eax, eax + mov ecx, [ebp + 0xc] + mov ebx, ecx + shr ebx, 2 + cmp ebx, [boss] + jne .out ; not the player's boss, or none + mov ebx, BS_COL0 + test cl, 2 + jz .side + mov ebx, BS_COL1 +.side: cmp ebx, [bside] + jne .out ; the other side: a CPU of the same id + mov ebx, [bcolor] + test ebx, ebx + jz .out ; its own colour, so the boss keeps its + dec ebx ; the pair + and ecx, 3 + mov eax, [bsrc] + lea eax, [ecx + eax * 4] + mov eax, [edx + eax * 4] + and ecx, 1 + lea ecx, [ecx + ebx * 2] + mov eax, [eax + ecx * 4] +.out: ret + +; Jaguarandi's win and lose poses (its model's routines at +0x43c and +; +0x440) take the frame as the round's count past the pose's start modulo +; the pose's length, so through the win's camera it plays its pose over +; and over; the eight's hold its last frame, and so does it now. In place +; of `cdq; idiv ecx; mov [frame], dx`, five nops after; eax the count, ecx +; the pose's frames. +%macro POSE 2 ; label, the frame +%1: + cmp eax, ecx + jl %%in + lea eax, [ecx - 1] +%%in: mov [%2], ax + ret +%endmacro + + POSE pose_a, BS_MFRAMEA + +; --- PLAYER DATA ----------------------------------------------------------- + +; The report after stage 5 turns a model of the player's machine, drawn +; from per-machine tables only the eight have rows in (0x5fb9f8, 0x5fbab8): +; a boss read past them and crashed. A boss is drawn by its own fight +; object instead, the way the win screen draws it: its per-frame routine +; at [object+4], which ticks and draws it. The object is the one taken +; standing at the start of its last round (STAND, above), put at the +; turntable's middle; afterwards the real one, its AI state and what else +; the routine writes are put back, so nothing moves on. Sound effects are +; off while it runs, and the effects it spawns - Jaguarandi's exhaust, +; placed by the turntable's matrix - are undone before they are drawn. +; Z-Gradt's moves would carry it round its arena, off the turntable, so it +; gets its draw alone. +; +; A machine draws its lower body on the matrix it finds - in a fight the +; identity, the camera being applied later, at the submit - and then loads +; the identity to place the upper body in the world. While the report +; draws a boss, the identity it loads is the turntable's matrix instead. +; +; In place of the call to the parts draw, (machine), at the end of the +; report's model routine. + +%macro BOSSMODEL 17 ; label, the parts draw, the object, +%1: ; push, pop, scale, AI state, its + mov eax, [esp + 4] ; save area, the current matrix, the + cmp eax, JAG ; standing object and its AI state, + jae %%boss ; Z-Gradt's draw, the effects tables + jmp %2 +%%boss: pushad + COPYN objsave, %3, OBJECT + COPYAI %8, %7 + COPYN fxsave, %13, FX + COPYN fx2save, %14, FX2 + cmp dword [%10 + 0x64], eax + jne %%now ; no standing copy of this machine + COPYN %3, %10, OBJECT + COPYAI %7, %11 +%%now: push dword [BS_RFLAG] + push dword [SEMUTE] + push dword [BS_ZMODA] + mov dword [SEMUTE], 1 + call %4 + mov esi, %15 ; Jaguarandi's size, or Z-Gradt's + cmp dword [%3 + 0x64], ZGRADT + jne %%size + mov esi, %16 +%%size: push dword [esi] + push dword [esi] + push dword [esi] + call %6 + add esp, 12 + mov eax, [%9] ; moved across the screen, before the + fld dword [eax + 0x24] ; turntable turns it + fadd dword [esi + 8] + fstp dword [eax + 0x24] + push esi + COPYN rmbase, [%9], 0x30 + pop esi + mov byte [rmbase_on], 1 + mov ebx, %3 + xor eax, eax + mov [ebx + 8], eax ; at the origin, at the height that + mov [ebx + 0x10], eax ; puts it in the turntable's middle + mov eax, [esi + 4] + mov [ebx + 0xc], eax + push ebx + cmp dword [ebx + 0x64], ZGRADT + jne %%tick + mov word [ebx + 0x34], 0 ; level: its draw pitches it by this + mov eax, [ebx + 0x6c] ; its own model header, as the game's + test eax, eax ; per-frame routines set it before + jz %%draw ; they draw (kept and put back above) + mov [BS_ZMODA], eax +%%draw: call %12 ; Z-Gradt's moves would carry it off + jmp %%drawn ; round its arena: the draw alone +%%tick: call %17 ; its per-frame routine, or its draw +%%drawn: + add esp, 4 + mov byte [rmbase_on], 0 + call %5 + pop dword [BS_ZMODA] + pop dword [SEMUTE] + pop dword [BS_RFLAG] + COPYN %14, fx2save, FX2 ; what the draw spawned - exhaust, + COPYN %13, fxsave, FX ; placed by the turntable - is undone + COPYAI %7, %8 + COPYN %3, objsave, OBJECT + popad + ret +%endmacro + +; While an unlock shows, the model is the boss unlocked, the CPU's: its +; standing copy (unl_tick) at the CPU's object, drawn alone - its +; per-frame routine runs the CPU's moves, which twitched it now and then. +; The player's Jaguarandi stands as on the unlock: its select pose, at +; the unlock's size and place. +model_ra: + cmp dword [unl_on], 0 + jne model_ua + cmp dword [esp + 4], JAG + je model_raj + jmp model_rap + BOSSMODEL model_ua, BS_RPARTA, BS_CPUA, BS_MPUSHA, BS_MPOPA, BS_MSCALEA, BS_BSSA, aisave_a, BS_MATA, stand_ca, standai_ca, unl_zdraw, BS_FXA, BS_FX2A, urm_jag, urm_z, unl_jdraw + BOSSMODEL model_rap, BS_RPARTA, BS_OBJA, BS_MPUSHA, BS_MPOPA, BS_MSCALEA, BS_BSSA, aisave_a, BS_MATA, stand_a, standai_a, BS_ZDRAWA, BS_FXA, BS_FX2A, rm_jag, rm_z, [ebx + 4] + BOSSMODEL model_raj, BS_RPARTA, BS_OBJA, BS_MPUSHA, BS_MPOPA, BS_MSCALEA, BS_BSSA, aisave_a, BS_MATA, stand_a, standai_a, BS_ZDRAWA, BS_FXA, BS_FX2A, rrm_jag, rm_z, unl_jdraw + +; The unlock's model, as the select stands it: Z-Gradt still in its +; stance's first frame, Jaguarandi posed by Raiden's select motions (the +; select's motions stay loaded). cdecl, the object, placed: its place is +; all they take from it. +unl_zdraw: + push ebx + mov ebx, [esp + 8] + mov eax, SEL_ZFILE + call sel_loadrb + call sel_slotsin + call BS_MPUSHA + push dword [ebx + 0x10] + push dword [ebx + 0xc] + push dword [ebx + 8] + call BS_VIEWA + add esp, 12 + call selzdraw + call BS_MPOPA + call sel_slotsout + pop ebx + ret + +unl_jdraw: + cmp dword [unl_on], ZGRADT + je unl_zdraw + push ebx + mov ebx, [esp + 8] + mov eax, SEL_JAGFILE + call sel_loadrb + call sel_slotsin + call BS_MPUSHA + push dword [ebx + 0x10] + push dword [ebx + 0xc] + push dword [ebx + 8] + call BS_VIEWA + add esp, 12 + mov byte [seljagdraw], 1 ; with its head (selpart_a) + push 0 + push 0 + push 0 + push JAG + call selmdl_a.draw + add esp, 16 + mov byte [seljagdraw], 0 + call BS_MPOPA + call sel_slotsout + pop ebx + ret + +; In place of load identity's prologue, five bytes and a nop. +%macro IDENT 3 ; label, past the prologue, the matrix +%1: + cmp byte [rmbase_on], 0 + jne %%base + push ebp + mov ebp, esp + push ebx + push esi + push edi + jmp %2 +%%base: push esi + push edi + push ecx + COPYN [%3], rmbase, 0x30 + pop ecx + pop edi + pop esi + ret +%endmacro + + IDENT ident_a, BS_IDENTA, BS_MATA + +; A machine's shadow is the machine again, flattened onto the ground below +; it; on the report the ground is wherever the turntable puts it. While the +; report draws a boss, the shadow is skipped. +; +; In place of the shadow's first instruction, mov eax, [light]. +%macro NOSHADE 4 ; label, the light, past it, the skip +%1: + cmp byte [rmbase_on], 0 + jne %%skip + mov eax, [%2] + jmp %3 +%%skip: jmp %4 +%endmacro + + NOSHADE noshade_a, BS_LIGHTA, BS_SHADEA, BS_NOSHADEA + +; Z-Gradt's shadow, the same: in place of its first test, cmp [timer], 0x9a. +%macro NOZSHADE 4 ; label, the timer, past it, the skip +%1: + cmp byte [rmbase_on], 0 + jne %%skip + cmp dword [%2], 0x9a + jmp %3 +%%skip: jmp %4 +%endmacro + + NOZSHADE nozshade_a, BS_ZTIMA, BS_ZSHADEA, BS_ZNOSHADEA + + +; Its machine name comes from a table of the eight as well. In place of +; `mov eax, [id]` and the three that index the table: eax the name. +%macro NAME 3 ; label, the player's id, the table +%1: + mov eax, [%2] + cmp eax, JAG + je %%jag + cmp eax, ZGRADT + je %%z + lea eax, [eax + eax * 2] + lea eax, [eax + eax * 4] + add eax, %3 + ret +%%jag: mov eax, name_jag + ret +%%z: mov eax, name_z + ret +%endmacro + + NAME name_a, BS_G1PA, BS_NAMEA + +; --- unlocking ------------------------------------------------------------- + +; The bosses start locked. Jaguarandi is unlocked by beating it, and +; Z-Gradt, with Jaguarandi unlocked, by finishing the game - each in one +; player on Very Hard without a match lost since the game began. What is +; unlocked is kept in bosses.bin beside the game: a dword, 0 neither, 1 +; Jaguarandi, 2 both; the select offers the machines up to it. +; +; The unlock shows on PLAYER DATA's black screen, the game's own report +; run in place: its state 0x1e (the report proper; 0x1c and 0x1d before it +; set the screen up) does the unlock's frames instead while unl_on names +; the boss, and the report's text is not drawn. The model is the report's +; turning one, the boss's standing copy from its last round drawn at the +; CPU's object (model_ua); the text is YOU UNLOCKED and the boss's name as +; the select shows it. SDB_title plays under it. A press is answered with +; the select's cursor sound and the model gone; once it is let go, +; Jaguarandi's goes on to the report, and Z-Gradt's to the initials. +; +UNL_TITLE equ 0x101a ; SDB_title +UNL_PRESSED equ 0x12 ; SDE_type_05, the select's cursor + ; sound: a press taken +UNL_TXT1 equ 30 ; frames: YOU UNLOCKED, the name, +UNL_TXT2 equ 60 +UNL_PROMPT equ 300 ; near SDB_title's end: PRESS BUTTON TO +UNL_FLASH equ 32 ; CONTINUE, on and off for this many +UNL_PROMPTW equ 0x34 ; frames, a button ending it; what it +UNL_PROMPTH equ 2 ; covers, cleared +UNL_NJ equ 0x22 * 2 ; the names' tiles, Jaguarandi's +UNL_NZ equ 0x1a * 3 ; and Z-Gradt's +UNL_TILE equ 0x80 ; a tile's bytes +ST_SELECT equ 4 ; A's state on the select +UNL_BUTTONS equ 0x10110 ; the buttons that end the report, as + ; held (BS_PADEDGE is held, not pressed) +ST_REPORT equ 0x1c ; A's states: the report's start, +ST_INITIALS equ 0x16 ; the initials, the last fight won, +ST_ZWON equ 0x1f ; and the rounds +ST_ROUND equ 0x0a +ST_ROUNDZ equ 0x0b +ST_NEWGAME equ 2 ; a new game's states, 1 and 2 +ST_TITLE equ 4 ; the title's states go no higher +VERY_HARD equ 2 +UNL_TEXB equ 4 ; the fights' texture bank, half 1 + +; The unlocks, read the first time the tick runs. +unl_load: + cmp byte [unl_read], 0 + jne .out + pushad + mov byte [unl_read], 1 + push BS_RBMODE + push unl_file + call BS_FOPEN + add esp, 8 + test eax, eax + jz .done + mov ebx, eax + push ebx + push 1 + push 4 + push unl_level + call BS_FREAD + add esp, 16 + push ebx + call BS_FCLOSE + add esp, 4 + cmp dword [unl_level], 2 + jbe .done + mov dword [unl_level], 0 +.done: popad +.out: ret + +unl_save: + pushad + push BS_WBMODE + push unl_file + call BS_FOPEN + add esp, 8 + test eax, eax + jz .done + mov ebx, eax + push ebx + push 1 + push 4 + push unl_level + call BS_FWRITE + add esp, 16 + push ebx + call BS_FCLOSE + add esp, 4 +.done: popad + ret + +; The chase camera turns by its yaw at +0x1a, which the eight's movement +; code sets from the machine's facing at +0x184 as it turns them (0x4ec6a2 +; and around it); Z-Gradt moves by its own code, which does not, so the +; camera stayed put as it turned on the spot. In a round, the player's +; Z-Gradt's facing goes to the camera each frame, as the eight's does. +ZL_FACING equ 0x184 +ZL_CAMYAW equ 0x1a + +; Z-Gradt has no jump, and turns only standing still. For the player's, +; the jump - both levers out, 0x0206 in the machine's lever word at +0x108 +; (the low byte the right lever's direction, the high the left's) - turns +; it to face the CPU instead, ZL_STEP a frame, as the eight face their +; target as they jump. The angle is the CPU's own way of aiming a machine +; (0x4450e4): atan2(own x - target x, target z - own z) in the facing's +; units. The facing turns, and the model and the camera follow it as they +; do Z-Gradt's own turn, so its turrets, its ring beams' heads and its +; laser all aim from the way it faces. Not while the super laser is out, +; which fires along the facing. Once GET READY is up and it has landed. +ZL_JUMP equ 0x0206 +ZL_STEP equ 0x200 ; a frame: a half turn in 64 +ZL_LEVERS equ 0x108 +ZL_X equ 8 +ZL_Z equ 0x10 + +zlock: + movzx eax, word [BS_OBJA + ZL_LEVERS] + xchg eax, [zl_prev] + cmp dword [BS_READYA], READY_GO + jl .off ; no GET READY yet + cmp dword [BS_STAGEA], LAST_STAGE ; there the timer is the + je .landed ; CPU's, the player's not flying in + cmp dword [BS_ZTIMA], 0 + jge .off ; still flying in +.landed: + mov ecx, BS_BSSA ; the player's laser state (BS_AILASER + cmp dword [banked_a], 0 ; in), banked on the last stage (as ZEND) + je .live + mov ecx, bank_a +.live: cmp dword [ecx + BS_AILASER], 0 + jl .free + mov dword [zl_on], 0 ; the laser out: no lock-on + ret +.free: cmp eax, ZL_JUMP ; held from before: no new press + je .turn + cmp word [BS_OBJA + ZL_LEVERS], ZL_JUMP + jne .turn + mov dword [zl_on], 1 +.turn: cmp dword [zl_on], 0 + je .done + fld dword [BS_OBJA + ZL_X] + fsub dword [BS_CPUA + ZL_X] + fld dword [BS_CPUA + ZL_Z] + fsub dword [BS_OBJA + ZL_Z] + fpatan + fdiv dword [sel_zturn] + fistp dword [zl_ang] + mov eax, [zl_ang] + sub ax, [BS_OBJA + ZL_FACING] + cwde ; movsx eax, ax, the way round that is + ; shorter; nasm 3.x makes it this and + ; 2.x does not, so it is written so + cmp eax, ZL_STEP + jle .lo + mov eax, ZL_STEP + jmp .step +.lo: cmp eax, -ZL_STEP + jge .last + mov eax, -ZL_STEP + jmp .step +.last: mov dword [zl_on], 0 ; facing it this frame +.step: add [BS_OBJA + ZL_FACING], ax +.done: ret +.off: mov dword [zl_on], 0 + ret + +; Each frame, from the tick. A game starts clean as A passes state 1 or 2, +; which only a new game does (0, 1 or 2, then the select); a continue goes +; from the lost match's states through 0 to the select, and between stages +; through 0 and 3. The game's own count of lost matches will not do: it is +; cleared whenever another machine is chosen. Anything but Very Hard, or +; two players, spoils it, as a lost match does (unl_lost). The last fight won +; is noted for the initials' hook. And in a round the CPU's boss is taken +; standing, as the player's is, for the unlock's model. +unl_tick: + pushad + mov eax, [BS_STATEA] + dec eax + cmp eax, ST_NEWGAME - 1 + ja .play + mov dword [unl_clean], 1 + mov dword [unl_zwon], 0 +.play: cmp byte [BS_DIFF], VERY_HARD + jne .dirty + cmp dword [GAMEMODE], 0 + je .won +.dirty: mov dword [unl_clean], 0 +.won: cmp dword [BS_STATEA], ST_ZWON + jne .round + cmp dword [BS_STAGEA], LAST_STAGE + jne .round + mov dword [unl_zwon], 1 +.round: + mov eax, [BS_STATEA] + cmp eax, ST_SELECT + jne .notsel + movzx ecx, word [BS_SCENEA] + sub ecx, SELECT_LO + cmp ecx, SELECT_HI - SELECT_LO + jae .out + call unl_grab + jmp .out +.notsel: + cmp eax, ST_ROUND + je .stand + cmp eax, ST_ROUNDZ + jne .out +.stand: STAND BS_CPUA, BS_READYA, BS_BSSA, stand_ca, standai_ca, stood_ca + cmp dword [boss], ZGRADT ; the player's Z-Gradt: the camera + jne .out ; turns with it (ZL_CAMYAW) + call zlock + mov ax, [BS_OBJA + ZL_FACING] + mov [BS_ECBLKA + ZL_CAMYAW], ax +.out: popad + ret + +; The names are the select's art, which other screens load other art in +; the place of; on the report, a name's tiles are past its art's end. So +; on the select they are taken (unl_grab), each as the plane's draw finds +; it, and for the unlock put where the report's art reaches, at a whole +; tile from its start (unl_place), the name drawn from a map of its own. +; k, 0 to UNL_NJ + UNL_NZ: Jaguarandi's map, then Z-Gradt's. + +; eax k -> ecx its map entry, esi its tile (0 none or out of reach). +unl_tileat: + lea esi, [BS_LOGOJ + eax * 2] + cmp eax, UNL_NJ + jb .j + lea esi, [BS_LOGOZ + (eax - UNL_NJ) * 2] +.j: movzx ecx, word [esi] + xor esi, esi + test ecx, 0x3fff + jz .out + mov esi, ecx + test ecx, 0x4000 + jz .one + and esi, 0x3fff + shl esi, 7 + add esi, [BS_ARTPOOL2] + jmp .in +.one: and esi, 0x7fff + shl esi, 7 + add esi, [BS_ARTPOOL] +.in: cmp esi, BS_ARTEND - UNL_TILE + ja .none + cmp esi, 0x401000 + jae .out +.none: xor esi, esi +.out: ret + +; From the tick, on the select. +unl_grab: + pushad + cld + xor ebx, ebx +.k: mov eax, ebx + call unl_tileat + test esi, esi + jz .next + mov edi, ebx + shl edi, 7 + add edi, unl_tiles + mov ecx, UNL_TILE / 4 + rep movsd +.next: inc ebx + cmp ebx, UNL_NJ + UNL_NZ + jb .k + mov byte [unl_got], 1 + popad + ret + +; The names' tiles in unl_area, at a whole tile from the start of the +; report's art and so numbered as its tiles are; the plane's draw takes no +; tile past the art's count, so the count is raised over them, and put +; back by unl_unplace. Nothing of the game's is written: the memory just +; past the art holds textures, which, the tiles written there, kept them +; (seen on the ground behind the initials). unl_map the boss's name's map +; there. CF set if they are out of the art's reach. +unl_place: + pushad + cld + cmp byte [unl_got], 0 + je .no + cmp byte [unl_placed], 0 + jne .map + mov edi, unl_area ; a whole tile on from the art's start + mov eax, [BS_ARTPOOL] + sub eax, edi + and eax, UNL_TILE - 1 + add edi, eax + mov ebp, edi + sub ebp, [BS_ARTPOOL] + jb .no + shr ebp, 7 ; its first tile's number + lea eax, [ebp + UNL_NJ + UNL_NZ] + cmp eax, 0x4000 + jae .no + mov esi, unl_tiles + mov ecx, (UNL_NJ + UNL_NZ) * UNL_TILE / 4 + rep movsd + mov [unl_first], ebp + mov ecx, [BS_ARTCOUNT] + mov [unl_count], ecx + cmp eax, ecx + jbe .in + mov [BS_ARTCOUNT], eax +.in: mov byte [unl_placed], 1 +.map: mov ebp, [unl_first] + xor ebx, ebx ; the map: the name's own entries, + mov edx, UNL_NJ ; renumbered + cmp dword [unl_on], JAG + je .m + mov ebx, UNL_NJ + mov edx, UNL_NJ + UNL_NZ +.m: mov edi, unl_map +.e: mov eax, ebx + call unl_tileat + xor eax, eax + test ecx, 0x3fff + jz .put + lea eax, [ebp + ebx] +.put: stosw + inc ebx + cmp ebx, edx + jb .e + popad + clc + ret +.no: popad + stc + ret + +unl_unplace: + cmp byte [unl_placed], 0 + je .out + push eax + mov eax, [unl_count] + mov [BS_ARTCOUNT], eax + mov byte [unl_placed], 0 + pop eax +.out: ret + +; The palettes, all of them (three planes of 0x4000), kept from before the +; unlock and put back after it: what follows reads them as they were - the +; initials' ground went the boss's colours, and its glowing orbs black. +UNL_PALS equ 3 * 0x4000 +unl_palsave: + cmp byte [unl_palin], 0 + jne .out + pushad + cld + mov esi, BS_PALRAMA + mov edi, unl_pals + mov ecx, UNL_PALS / 4 + rep movsd + mov byte [unl_palin], 1 + popad +.out: ret + +unl_palback: + cmp byte [unl_palin], 0 + je .out + pushad + cld + mov esi, unl_pals + mov edi, BS_PALRAMA + mov ecx, UNL_PALS / 4 + rep movsd + mov byte [unl_palin], 0 + popad +.out: ret + +; The scene the report replaces, kept for the initials after Z-Gradt's +; unlock: its floor texture and model as they are, not read again - the +; scene once loaded is worked on, its glowing orbs among it, which a fresh +; read leaves black - and its glow's state. +UNL_FC equ 0x40600 ; the largest floor texture, +UNL_FLD equ 0x86440 ; and model, and the select's motions +UNL_MTSEL equ 0x2cdc4 ; read in over whatever is there +unl_scnsave: + pushad + cld + cmp dword [unl_scnmem], 0 + jne .have + push UNL_FC + UNL_FLD + UNL_MTSEL + call BS_MALLOC + add esp, 4 + mov [unl_scnmem], eax + test eax, eax + jz .out +.have: mov edi, [unl_scnmem] + mov esi, BS_FCBUF + mov ecx, UNL_FC / 4 + rep movsd + mov esi, BS_FLDBUF + mov ecx, UNL_FLD / 4 + rep movsd + mov esi, BS_MTSELMEM + mov ecx, UNL_MTSEL / 4 + rep movsd + mov eax, [BS_SEGA] + mov [unl_sega], eax + mov eax, [BS_GLOW1] + mov [unl_glow], eax + mov eax, [BS_GLOW2] + mov [unl_glow + 4], eax + mov eax, [BS_GLOW3] + mov [unl_glow + 8], eax + mov byte [unl_scnin], 1 +.out: popad + ret + +unl_scnback: + cmp byte [unl_scnin], 0 + je .out + pushad + cld + mov esi, [unl_scnmem] + mov edi, BS_FCBUF + mov ecx, UNL_FC / 4 + rep movsd + mov edi, BS_FLDBUF + mov ecx, UNL_FLD / 4 + rep movsd + mov edi, BS_MTSELMEM + mov ecx, UNL_MTSEL / 4 + rep movsd + mov eax, [unl_sega] + mov [BS_SEGA], eax + mov eax, [unl_glow] + mov [BS_GLOW1], eax + mov eax, [unl_glow + 4] + mov [BS_GLOW2], eax + mov eax, [unl_glow + 8] + mov [BS_GLOW3], eax + mov eax, [unl_scn] ; and the scene in, as far as the + mov [BS_SCNNOW], eax ; loader knows + mov byte [unl_scnin], 0 + popad +.out: ret + +; In place of the calls that load a texture bank (bank, half): the bank in +; half 1 noted, for what the report's replaces to be loaded again. +unl_ldtex: + cmp dword [esp + 8], 1 + jne .load + push eax + mov eax, [esp + 8] + mov [unl_texnow], eax + pop eax +.load: jmp BS_LOADTEX + +; ZF set if this game can unlock: one player, Very Hard, nothing lost. +unl_ok: + cmp dword [GAMEMODE], 0 + jne .out + cmp byte [BS_DIFF], VERY_HARD + jne .out + cmp dword [unl_clean], 1 +.out: ret + +; In place of `inc [lost matches]`, a nop after the call. +unl_lost: + inc dword [BS_LOSSA] + mov dword [unl_clean], 0 + ret + +; In place of `mov [state], 0x1c` once stage 5, Jaguarandi's, is won; +; five nops after the call. +unl_jag: + mov dword [BS_STATEA], ST_REPORT + call unl_ok + jne .out + cmp dword [unl_level], 0 + jne .out + cmp dword [BS_CPUA + 0x64], JAG + jne .out + mov dword [unl_level], 1 + call unl_save + mov dword [unl_on], JAG + mov dword [unl_t], 0 +.out: ret + +; In place of `mov [state], 0x16` at the credits' end, five nops after the +; call: a game finished that unlocks Z-Gradt runs the report first. +unl_z: + cmp dword [unl_zwon], 0 + je .initials + mov dword [unl_zwon], 0 + call unl_ok + jne .initials + cmp dword [unl_level], 1 + jne .initials + mov dword [unl_level], 2 + call unl_save + mov eax, [BS_SCNNOW] ; the scene and textures in, for + mov [unl_scn], eax ; after + mov eax, [unl_texnow] + mov [unl_texb], eax + call unl_scnsave + mov dword [unl_on], ZGRADT + mov dword [unl_t], 0 + mov dword [BS_STATEA], ST_REPORT + ret +.initials: + mov dword [BS_STATEA], ST_INITIALS + ret + +; In place of the call of the report's text: none while an unlock shows. +unl_text: + cmp dword [unl_on], 0 + jne .out + jmp BS_REPTEXTA +.out: ret + +; A's state 0x1e, from its table. +unl_logic: + cmp dword [unl_on], 0 + jne .unlock + jmp BS_REPLOGICA +.unlock: + pushad + cmp dword [unl_t], 0 + jne .text + push UNL_TITLE + call BS_SFX + add esp, 4 + mov dword [unl_prev], UNL_BUTTONS ; one held from before: not + mov byte [unl_go], 0 ; a press + call unl_palsave ; what the palettes held, kept, and + mov ebx, [unl_on] ; the boss's in, both sides' + shl ebx, 2 +%assign i 0 +%rep 4 + lea eax, [ebx + i] + push eax + push 1 + 2 * i + call BS_PALLOADA + add esp, 8 +%assign i i + 1 +%endrep + mov eax, [unl_on] ; and in its rows on the select, which + lea edi, [sel_bslots + (eax - JAG) * 8] ; its meshes may name +%assign i 0 +%rep 2 + lea eax, [ebx + i] + push eax + push dword [edi + 4 * i] + call BS_PALLOADA + add esp, 8 +%assign i i + 1 +%endrep + push 0 + call BS_TCLRALL + add esp, 4 + call BS_TRESET +.text: cmp dword [unl_t], UNL_TXT1 + jne .name + push 0 + call BS_TCLRALL + add esp, 4 + call BS_TRESET + push dword [unl_y1] + push dword [unl_x1] + call BS_TXTPOSA + add esp, 8 + push unl_you + call BS_PRINTBIG + add esp, 4 +.name: cmp dword [unl_t], UNL_TXT2 + jne .model + call unl_place + jc .model ; out of the art's reach: no name + mov ebx, [unl_on] + sub ebx, JAG + push dword [unl_y2] + push dword [unl_x2 + ebx * 4] + call BS_TXTPOSA + add esp, 8 + imul ebx, ebx, SEL_TXT + add ebx, seltxt + push dword [ebx + SEL_LOGO + 8] + push dword [ebx + SEL_LOGO + 4] + push unl_map + call BS_TBLOCKA + add esp, 12 +.model: cmp byte [unl_go], 0 ; pressed: gone (as the screen ends + jne .drawn ; it would wear the player's colours) + fild dword [unl_t] ; growing to the report's size + fmul dword [unl_grow] + fld dword [unl_size] + fcomi st0, st1 + fcmovnb st0, st1 + fstp st1 + sub esp, 4 + fstp dword [esp] + push dword [BS_G1PA] ; the model is the player's machine's: + mov eax, [unl_on] ; the boss's for it + mov [BS_G1PA], eax + push dword [esp + 4] + call BS_REPMODELA + add esp, 4 + pop dword [BS_G1PA] + add esp, 4 +.drawn: mov eax, [unl_t] + sub eax, UNL_PROMPT + jb .next + test eax, UNL_FLASH - 1 + jnz .button + mov ebx, eax + push dword [unl_py] ; on, or off + push dword [unl_px] + call BS_TXTPOSA + add esp, 8 + test ebx, UNL_FLASH + jnz .off + push unl_press + call BS_PRINTBIG + add esp, 4 + jmp .button +.off: push UNL_PROMPTH + push UNL_PROMPTW + call BS_TCLEARA + add esp, 8 +.button: ; a press made since, then let go: + mov eax, [BS_PADEDGE] ; the buttons are held ones, and the + and eax, UNL_BUTTONS ; report after skips itself while one + cmp byte [unl_go], 0 ; is down + jne .release + mov ecx, [unl_prev] + mov [unl_prev], eax + not ecx + test eax, ecx + jz .next + mov byte [unl_go], 1 + push UNL_PRESSED ; heard + call BS_SFX + add esp, 4 + jmp .next +.release: + test eax, eax + jz .end +.next: inc dword [unl_t] + popad + ret +.end: push 0 ; as the report ends + call BS_TCLRALL + add esp, 4 + call BS_TRESET + call unl_unplace + call unl_palback + push 0 + call BS_FADE + add esp, 4 + mov dword [BS_REPCNT], -1 + push 1 + push -1 + push 0xa + call BS_SCNEND + add esp, 12 + mov dword [unl_t], 0 + mov eax, [unl_on] + mov dword [unl_on], 0 + mov dword [BS_STATEA], ST_REPORT ; Jaguarandi's: the report + cmp eax, JAG + je .out + call unl_scnback ; Z-Gradt's: the fight's scene and + push 1 ; textures back, which the report's + ; replaced and the initials draw their + ; ground from, + push dword [unl_texb] + call BS_LOADTEX + add esp, 8 + mov word [BS_SCENEA], 0x91 ; and the initials, as the + mov dword [BS_EVA], 0x81 ; credits go to them + mov dword [BS_STATEA], ST_INITIALS +.out: popad + ret + +; --- the round's animations ------------------------------------------------ + +; Mode 0x80 loads clips from tables the bosses have no rows in. Skip to +; the extras after them. +loads_a: + mov eax, [BS_IDA] + cmp eax, JAG + jae BS_LDXA + jmp BS_LDA + +; After those, a deref of the same tables and the looping stand overlay. +deref_a: + cmp dword [BS_IDA], JAG + jae BS_DRSA + cmp dword [ebp + DR_FLAG], 0 + je BS_DRJA + jmp BS_DRFA + +; Mode 0xa: the same extras as 0x80 rather than the deref. +case2_a: + mov eax, [BS_IDA] + cmp eax, JAG + jae BS_LDXA + jmp BS_C2A + +; --- the ending ------------------------------------------------------------ + +; The final win runs the player's machine through a script (mode 5, from +; its per-frame routine): Z-Gradt falls, the machine turns to the moon gate +; and its charge is set going. Phase 0 runs the charge and the shot by the +; machine number in the player's global, 0 to 7, then the gate's fall, and +; the dash back. Phase 1 is the text, VR-OPERATION SYSTEM to FREEZE; phase 2 +; the staff roll, which shows the machine battle-damaged, a model the +; bosses do not have, so a boss goes from phase 1 to the button wait. +; +; A boss plays it as Raiden, whose charge runs a set length rather than +; reading the machine's motions, which for a boss are not loaded. Jaguarandi +; fires its own right weapon; Z-Gradt's charge and laser are its own (ZEND, +; below). +; +; The flag and the player's global are both gone by the ending; the +; object's id and model are what is left, so they decide. + +%macro ENDING 11 ; label, id, model, jag, zgradt, phase, time, + ; resume, phase 1, epilogue (the button wait), global +%1: + mov eax, [%2] + sub eax, JAG + cmp eax, ZGRADT - JAG + jbe %%boss + cmp dword [%3], %4 + je %%boss + cmp dword [%3], %5 + je %%boss + cmp dword [%6], 0 + jne %9 + jmp %8 +%%boss: + mov eax, [%11] ; Raiden's for phase 0's animation, + cmp eax, JAG ; the boss's own again after it, for + jb %%lent ; the ranking and the name entry + mov [end_g1p], eax +%%lent: cmp dword [%6], 0 + jne %%own + mov dword [%11], SEL_RAIDEN + jmp %8 +%%own: mov eax, [end_g1p] + test eax, eax + jz %%phase + mov [%11], eax +%%phase: + cmp dword [%6], 2 + jb %9 + je %10 + jmp %10 +%endmacro + + ENDING end_a, BS_IDA, BS_MDLA, BS_JAGA, BS_ZGA, BS_PHASEA, \ + BS_TIMEA, BS_ENDA, BS_END1A, BS_ENDEA, BS_G1PA + +; Z-Gradt's part. Its per-frame routine runs the script as the others' do, +; and the script sets the charge going (the timer at 1). Z-Gradt's goes: +; +; 0 its super laser is started as its crouch button would (attack 6, +; its state from -1 to 0, the gold glow), and its cannon comes out +; over ZLASER_OUT frames, the charge held back meanwhile (phase 0 run +; with the timer at 0); +; 1 the charge: the particles and the camera turning about the machine, +; the cannon held out short of firing. The charge runs on the +; machine's own charge code, which for Z-Gradt is not there, so its +; counter is given as full, and what the charge writes into the +; machine's joint frames (which Z-Gradt's draw reads), and a flag of +; Raiden's, is put back; +; 2 after ZCHARGE frames the laser fires and the ending moves on as the +; charge code would. From here the ending runs Z-Gradt as Bal-Bas-Bow, +; whose shot code keeps to its own kind of weapon slot: Raiden's would +; take the beam, in the weapon slots, for Raiden's, Viper's turn it +; into homing beams. +; +; Through 0 and 1 Z-Gradt turns gold, its palette events posted from here: +; its own ramp to gold is not to be counted on, outside a fight. The laser +; puts it back as it goes in. +; +; The script's setup for the charge and its last step, the dash back, set +; moves that on Z-Gradt mean other things, so both steps are passed. The +; laser fires till ZFIRE_END - the shot's camera then on its way back - not +; for its usual 0x78 frames, and its beam's segments, which would end at the +; arena's edge, go on to the gate, as phase 0 has the eight's shots do; and in place of the dash, Z-Gradt leaves as it came, its +; fly-in run backwards over ZFLY_N frames from ZFLY_T0, with phase 0 - its +; camera with it - given Z-Gradt where it is drawn. +; +; On the last stage the player's Z-Gradt keeps its AI state in a bank of +; its own (AI, below); the live block is then the CPU's. +; +; In place of the call to phase 0. +ZCHARGE equ 240 +ZLASER_OUT equ 0x102 ; the laser's state, cannon out: it + ; fires on reaching 0x104 +ESTEP_SETUP equ 0x29e +ZFIRE_END equ 0xe0 ; before phase 0 clears the weapon slots +ZFIRE_HOLD equ 0x70 ; of the laser's 0x78 +ZFLY_N equ 252 +ZFLY_T0 equ 0x38b - ZFLY_N - 80 ; phase 0 ends at 0x38b +ZBEAM_SLOT equ 0xcb ; the laser's weapon slots +ZBEAM_END equ 0xe6 ; when phase 0 clears them +ZSLOW_N equ 3 +ESTEP_DASH equ 0x5b0 +ZPOSE equ 0xb0 ; the joint frames, to 0x100 +ZPOSE_N equ 0x50 +BALBAS equ 7 ; whose shot code takes only its own slots + +%macro ZEND 13 ; label, phase 0, the player, its id, +%1: ; the step, the timer, its AI state, its + cmp dword [%4], ZGRADT ; bank, banked, the laser's state, the + je %%z ; player's global, the palette event, + ; the beam's speed + jmp %2 +%%z: cmp dword [%5], ESTEP_SETUP ; its setup for the charge, + jne %%dash ; which sets moves on Z-Gradt, passed + inc dword [%5] + mov dword [%6], 1 +%%dash: cmp dword [%5], ESTEP_DASH + jne %%fly + inc dword [%5] +%%fly: + push eax + mov eax, %7 ; eax: the laser's state + cmp dword [%9], 0 + je %%live + mov eax, %8 +%%live: add eax, %10 + cmp dword [%6], 1 + je %%charge + cmp dword [%6], 2 + jb %%run + mov dword [%11], BALBAS + cmp dword [eax], 0x104 ; firing: held on till ZFIRE_END + jne %%away + cmp dword [%6], ZFIRE_END + jae %%away + cmp word [%3 + 0x178], ZFIRE_HOLD + jl %%away + mov word [%3 + 0x178], ZFIRE_HOLD +%%away: cmp dword [%6], ZBEAM_END ; the beam on through the arena's + jae %%stop ; edge to the gate (ZWALL, below) + cmp byte [zbeam_free], 0 + jne %%slow + mov byte [zbeam_free], 1 + mov dword [zspd_at], %13 + push dword [%13] + pop dword [zspd] + fld dword [%13] + fmul dword [zspd_k] + fstp dword [%13] +%%slow: inc dword [zslow] ; and, a frame in ZSLOW_N, its segments + cmp dword [zslow], ZSLOW_N ; held where they are: as far, but + jb %%flyc ; not so fast + mov dword [zslow], 0 + push ecx + push edx + lea ecx, [%3 + 0x200] + mov edx, 32 +%%seg: cmp byte [ecx], ZBEAM_SLOT + jne %%next + test byte [ecx + 3], 0x80 ; not once it has hit + jnz %%next + dec word [ecx + 4] +%%next: add ecx, 0x20 + dec edx + jnz %%seg + pop edx + pop ecx + jmp %%flyc +%%stop: call zbeam_off +%%flyc: mov ecx, [%6] ; the fly-in backwards (ZFLY, below) + sub ecx, ZFLY_T0 + jge %%up + pop eax + jmp %2 +%%up: + call zflyout + mov byte [zstage], 0 ; phase 0 - its camera with it - sees + mov dword [zcharge], 0 ; Z-Gradt where it is drawn + mov dword [zgold], 0 + pop eax + push dword [%3 + 0xc] + push dword [%3 + 0x10] + fld dword [%3 + 0xc] + fadd dword [zfly_y] + fstp dword [%3 + 0xc] + fld dword [%3 + 0x10] + fadd dword [zfly_z] + fstp dword [%3 + 0x10] + call %2 + pop dword [%3 + 0x10] + pop dword [%3 + 0xc] + ret +%%charge: + cmp dword [zgold], 0x1f ; the gold, a step a frame the handler + jae %%gold ; is free + cmp dword [%12], 0xff + jne %%gold + inc dword [zgold] + push eax + mov eax, [zgold] + add eax, 0x200 + mov [%12], eax + pop eax + mov byte [zmine], 1 +%%gold: cmp byte [zstage], 0 + jne %%held + cmp dword [zcharge], 0 ; 0: start the laser, run with the + jne %%out ; timer at 0 till the cannon is out + mov dword [zcharge], 1 + mov word [%3 + 0x170], 6 + mov word [%3 + 0x17c], 0 + mov word [%3 + 0x178], 0 + mov dword [eax], 0 +%%out: cmp dword [eax], ZLASER_OUT + jl %%quiet + mov byte [zstage], 1 + mov dword [zcharge], 0 +%%held: mov dword [eax], ZLASER_OUT ; 1: the charge, the cannon held + inc dword [zcharge] + pop eax + pushad + COPYN zpose, %3 + ZPOSE, ZPOSE_N + mov ax, [%3 + 0x178] + mov [zpose + ZPOSE_N], ax + mov ax, [%3 + 0x1a4] + mov [zpose + ZPOSE_N + 2], ax + mov word [%3 + 0x178], 0x7fff + call %2 + mov ax, [zpose + ZPOSE_N] + mov [%3 + 0x178], ax + mov ax, [zpose + ZPOSE_N + 2] + mov [%3 + 0x1a4], ax + COPYN %3 + ZPOSE, zpose, ZPOSE_N + popad + cmp dword [zcharge], ZCHARGE + jb %%ret + mov byte [zstage], 0 ; 2: fire, the ending on + mov dword [zcharge], 0 + inc dword [%5] + mov dword [%6], 2 +%%ret: ret +%%quiet: + pop eax + mov dword [%6], 0 + call %2 + mov dword [%6], 1 + ret +%%run: mov byte [zfly_on], 0 + call zbeam_off + mov byte [zstage], 0 + mov dword [zcharge], 0 + mov dword [zgold], 0 + pop eax + jmp %2 +%endmacro + + ZEND zend_a, BS_PH0A, BS_OBJA, BS_IDA, BS_ESTEPA, BS_TIMEA, \ + BS_BSSA, bank_a, banked_a, BS_AILASER, BS_G1PA, BS_EVA, BS_SPDA + +; Each segment of Z-Gradt's beam, a step at a time, asks the arena how high +; its floor is where it has got to, and stops there if under it: outside +; the arena the floor is its wall. During the ending's shot (ZEND) the +; answer is far below, so the beam reaches the gate. +; +; In place of that call, in the beam segment's routine; the answer in st0. +%macro ZWALL 2 ; label, the call +%1: + cmp byte [zbeam_free], 0 + je %2 + fld dword [zbeam_far] + ret +%endmacro + + ZWALL zwall_a, BS_WALLA + +; The beam's segments go out a step a frame for so many frames, their step +; the speed of their kind of weapon slot; ZEND makes it ZSPD_K times as +; long through the ending's shot, enough for the gate, and this puts it back. +zbeam_off: + cmp byte [zbeam_free], 0 + je .r + mov byte [zbeam_free], 0 + push eax + push ecx + mov eax, [zspd_at] + mov ecx, [zspd] + mov [eax], ecx + pop ecx + pop eax +.r: ret + +; From the shot on, the ending's camera follows the player's last live +; weapon slot - for the eight, its shot on the way to the gate - and, once +; it has hit, comes back from where it last was. Z-Gradt's beam stands at +; its cannon, so for Z-Gradt the camera is given a slot of its own instead: +; a point leaving the cannon for the gate at ZBEAM_V a frame. +; +; In place of `mov eax, [ebp-0x10]; add eax, 0x600`, the scan's start +; (BS_SCANBASE: 0x5e0 in the rerelease), the slot it found going to the +; frame's SCAN_SLOT. +%macro ZBEAM 6 ; label, the player, its id, the timer, +%1: ; the scan, the slot found + cmp dword [%3], ZGRADT + je %%z + mov eax, [ebp - 0x10] + add eax, BS_SCANBASE + jmp %5 +%%z: mov eax, [%4] + sub eax, 2 + mov [zbeam_n], eax + fild dword [zbeam_n] + fmul dword [zbeam_v] + fadd dword [%2 + 0x10] + fadd dword [zbeam_z] + fstp dword [zfake + 0x18] + fld dword [%2 + 0xc] + fadd dword [zbeam_y] + fstp dword [zfake + 0x14] + mov eax, [%2 + 8] + mov [zfake + 0x10], eax + mov dword [ebp + SCAN_SLOT], zfake + jmp %6 +%endmacro + + ZBEAM zbeam_a, BS_OBJA, BS_IDA, BS_TIMEA, BS_SCANA, BS_FOUNDA + +; The ending's camera puts the eye a set way from what it looks at, sized +; for the eight, and builds the view from the two: turned to look from the +; eye at the target, then moved by minus the eye. For a boss that last move +; puts the eye further back along the same line, eye' = target + s (eye - +; target); as moved by, -eye' = s (-eye + target) - target, with s = k. +; While the other machine falls the camera eases in from the fight's, which +; for Z-Gradt is far out already, so s is held to k ECAP_D over the +; distance; and the eye goes off to one side as well, so the boss is not in +; front of it. The camera's own state is left alone, so its easing goes +; on as it was. +; +; In place of the call to the move, the three floats on the stack. +%macro ETRANS 6 ; label, the move, the camera's block, +%1: ; the player's id, the ending's step, + cmp dword [%4], JAG ; its timer + jae %%boss + jmp %2 +%%boss: push esi + mov esi, ecam_jag + cmp dword [%4], ZGRADT + jne %%k + cmp dword [%6], ZFLY_T0 ; Z-Gradt flying out, further back + jge %%flyk + cmp dword [%6], 2 ; from its shot on as the other, + jge %%k ; following a shot + mov esi, ecam_z + jmp %%k +%%flyk: mov esi, ecam_zfly +%%k: fld dword [esi] ; s, the scale; until the turn, no + cmp dword [%5], ESTEP_TURN ; more than k ECAP_D from the target + jge %%s +%assign i 0 +%rep 3 + fld dword [esp + 8 + 4 * i] + fadd dword [%3 + 0x24 + 4 * i] + fmul st0, st0 + %if i + faddp st1, st0 + %endif +%assign i i + 1 +%endrep + fsqrt ; d, then k ECAP_D / d + fdivr dword [ecap_d] + fmul st0, st1 + fcomi st0, st1 + jae %%big + fxch st1 +%%big: fstp st0 ; the smaller +%%s: +%assign i 0 +%rep 3 + fld dword [esp + 8 + 4 * i] ; -t + s (a + t) + fadd dword [%3 + 0x24 + 4 * i] + fmul st0, st1 + fsub dword [%3 + 0x24 + 4 * i] + fstp dword [esp + 8 + 4 * i] +%assign i i + 1 +%endrep + fstp st0 + mov eax, ESTEP_TURN ; until the turn, the eye off to the + sub eax, [%5] ; right as well, by ESIDE of the way + jle %%done ; to the target, fading out over the + cmp eax, ESTEP_FADE ; last ESTEP_FADE steps + jbe %%fade + mov eax, ESTEP_FADE +%%fade: mov [eside_n], eax + fild dword [eside_n] + fmul dword [eside] ; c + fld dword [%3 + 0x2c] + fadd dword [esp + 0x10] ; fz, target less eye + fmul st0, st1 + fld dword [%3 + 0x24] + fadd dword [esp + 8] ; fx + fmul st0, st2 + fadd dword [esp + 0x10] ; -eye.z + c fx + fstp dword [esp + 0x10] + fsubr dword [esp + 8] ; -eye.x - c fz + fstp dword [esp + 8] + fstp st0 +%%done: pop esi + jmp %2 +%endmacro + +ESTEP_TURN equ 0x23a ; the ending's step the turn starts at +ESTEP_FADE equ 64 + + ETRANS etrans_a, BS_VIEWA, BS_ECBLKA, BS_IDA, BS_ESTEPA, BS_TIMEA + +; --- Z-Gradt's chase camera ------------------------------------------------ + +; Z-Gradt is several times the size of the eight, and the chase camera +; puts the eye inside it. Is the player one? ZF set if so. +is_zgradt: + cmp dword [boss], ZGRADT + ret + +; The round's opening shots (0x4db173) stand the eye a set distance from +; their subject along the yaw at BS_YAW4. In place of their call to the +; view translate, [esp+4..0xc] the eye's negated X, Y and Z: for the +; player's Z-Gradt, the eye `pull` further along that yaw. +%macro PULL 5 ; label, view, sin, cos, yaw +%1: + call is_zgradt + jne %2 + movsx ecx, word [%5] + push ecx + call %3 + add esp, 4 + fmul dword [pull] + fadd dword [esp + 4] + fstp dword [esp + 4] + movsx ecx, word [%5] + push ecx + call %4 + add esp, 4 + fmul dword [pull] + fsubr dword [esp + 0xc] + fstp dword [esp + 0xc] + jmp %2 +%endmacro + +; The replay's call is not this site: REPLAY below aims it itself. + PULL cam_4, BS_VIEWA, BS_SINA, BS_COSA, BS_YAW4 + +; The chase camera keeps a distance its mode sets at +0x3c - 56 in the +; command poses, 78 turning on the spot, 75 or 30 with the CPU close, 30 +; the nearer side - and eases the live one at +0x40 towards it; and a +; pitch to aim for at +0x1e - 0xc00 in the poses, 0x600 turning, up to +; 0x3000 as the other jumps - which +0x18 steps towards by 0x600 a frame +; at most. A boss's camera is the game's, its modes and their glide and +; its pan after a jump, but for two things: the distance never closes +; below cam_min, the poses' 56, so the camera does not zoom in on a boss +; as the CPU comes near; and for Z-Gradt the pitch never aims below +; ZCAM_PITCH, so turning on the spot does not level it out. The distance +; itself is scaled where the eye is placed (zeye_a). In place of `mov +; eax, [ebp+CAM_PTR]; movsx eax, word [eax+0x1e]`, the pitch's read, once +; the game's easing of the distance is done with. +ZCAM_PITCH equ 0xc00 +%macro LIVE 2 ; label, resume +%1: + cmp dword [boss], JAG ; a boss's: 8 or 9, else 0 + jb %%stock + mov ecx, [ebp + CAM_PTR] + fld dword [ecx + 0x3c] + fcomp dword [cam_min] + fnstsw ax + test ah, 1 ; C0: under the least + jz %%pitch + mov eax, [cam_min] + mov [ecx + 0x3c], eax +%%pitch: + call is_zgradt + jne %%stock + cmp word [ecx + 0x1e], ZCAM_PITCH + jge %%stock + mov word [ecx + 0x1e], ZCAM_PITCH +%%stock: + mov eax, [ebp + CAM_PTR] + movsx eax, word [eax + 0x1e] + jmp %2 +%endmacro + + LIVE live_a, BS_LIVEA + +; The bosses are bigger than the eight, and the chase camera framed for +; them crowds Jaguarandi and stands inside Z-Gradt. A boss's camera +; stands jcam_k or zcam_k times as far, taken where the eye is placed +; from the live distance - the radius, for x and again for z, and the +; height - so the game's modes and its glide between them are as they +; are; Z-Gradt's never +; nearer than zcam_near, which its modes with the CPU close would go +; under. In place of `mov eax, [ebp+CAM_PTR]; fmul dword [eax+0x40]`, a +; nop after; st0 the sine or cosine the distance scales. +zeye_a: + mov eax, [ebp + CAM_PTR] + fld dword [eax + 0x40] + cmp dword [boss], JAG + jne .z + fmul dword [jcam_k] + jmp .mul +.z: cmp dword [boss], ZGRADT + jne .mul + fmul dword [zcam_k] + fcom dword [zcam_near] + fnstsw ax + test ah, 1 ; C0: under the least + jz .mul + fstp st0 + fld dword [zcam_near] +.mul: fmulp st1, st0 + ret + +; --- the player's Z-Gradt, and Z-Gradt against Z-Gradt -------------------- + +; Falls through when the player's Z-Gradt (`boss`) is on the last stage, +; stage %2, else jumps to %1. +%macro LAST 2 + cmp dword [boss], ZGRADT + jne %1 + cmp dword [%2], LAST_STAGE + jne %1 +%endmacro + +; Jumps to %2 if %1 is the player's object. +%macro IF_PLAYER 2 + cmp %1, BS_OBJA + je %2 +%endmacro + +; Jumps to %1 once GET READY has been up READY_GO frames. +%macro IF_READY 1 + cmp dword [BS_READYA], READY_GO + jge %1 +%endmacro + +; Z-Gradt's init wipes the boss globals the CPU's has just set. The +; player's returns before it does. +%macro INIT 3 ; label, resume, the stage +%1: + LAST %%stock, %3 + IF_PLAYER dword [esp + 4], %%skip +%%stock: + push ebp + mov ebp, esp + push ebx + push esi + push edi + jmp %2 +%%skip: ret +%endmacro + + INIT init_a, BS_INITA, BS_STAGEA + +; The fly-in runs on a global timer and an absolute height, so a second +; Z-Gradt ticks the CPU's descent twice and drives it into the floor. The +; player's skips it: standing still until GET READY is done, then on from +; after the landing. +%macro FLY 6 ; label, resume, after landing, +%1: ; epilogue, Z-Gradt's model global, + ; the stage + LAST %%stock, %6 + IF_PLAYER dword [esp + 4], %%skip +%%stock: + push ebp + mov ebp, esp + sub esp, 0xc + push ebx + push esi + push edi + jmp %2 +%%skip: + push ebp + mov ebp, esp + sub esp, 0xc + push ebx + push esi + push edi + mov eax, [ebp + 8] + IF_READY %%live + mov byte [eax + 0x137], 0xff ; no pose 4 on the first tick + mov word [eax + 0x10e], 0 ; and no speed left from the + mov word [eax + 0x172], 0 ; fly-in + mov word [eax + 0x186], 0 + mov dword [eax + 0x1c4], 0 + mov eax, [eax + 0x6c] + mov [%5], eax + jmp %4 +%%live: + mov eax, [eax + 0x6c] + mov [%5], eax + jmp %3 +%endmacro + + FLY fly_a, BS_FLYA, BS_FLYPA, BS_FLYEA, BS_ZMODA, BS_STAGEA + +; The fly-in timer locks the machine until it runs out. The player's waits +; for GET READY instead, on every stage of a one-player game: indoors it is +; down before GET READY is done (zflyin_a), and its own movement code does +; not wait for the round as the eight's does - moved then, it shot across +; the arena. On the last stage its own fly-in is skipped besides. In place +; of `cmp dword [timer], 0; jge skip`. +%macro TIMER 4 ; label, timer, resume, skip +%1: + cmp dword [boss], ZGRADT + jne %%stock + IF_PLAYER dword [ebp + 8], %%player +%%stock: + cmp dword [%2], 0 + jge %4 + jmp %3 +%%player: + IF_READY %3 + jmp %4 +%endmacro + +; The player's Z-Gradt's fly-in runs on the timer: under 120 it comes in +; along the arena at height 70, to 200 it slows and pitches over, then it +; drops till it lands. From 0 it would come in from 2800 out, through +; the arena's backdrop, so it starts part of the way in (zf_start, by the +; arena loaded): indoors - Deathtrap, Spaceport, the Secret Base +; (FC_Fact, FC_Dock, FC_Core) - at 199, the one frame before the drop +; putting it in place, so it only drops; outdoors at 100, 784 out, short +; of the Flooded City's buildings and the Ruins (FC_Tro, FC_Inka) and +; inside the open arenas' skies; and at 60 for the Green Hills' mountains +; (FC_Fore). Its place is worked out from the timer each frame; its pitch +; is set as the frames skipped would have left it. In place of Z-Gradt's init's `mov dword [fly-in +; timer], 0`, five nops after the call; [ebp+8] the object. +ZF_SLOW equ 120 ; the timer: slowing, pitching over +ZF_LEVEL equ 0x4000 ; the pitch till then, and its easing +ZF_EASE equ 0x80 ; a frame after +ZF_OBJPITCH equ 0x34 +ZF_ARENAS equ 10 +zflyin_a: + mov dword [BS_ZTIMA], 0 + mov dword [zl_on], 0 ; a lock-on ends with the round + cmp dword [boss], ZGRADT + jne .out + push eax + push ecx + mov eax, [ebp + 8] + cmp eax, BS_OBJA ; the player's + jne .kept + mov ecx, [BS_ARENA] + cmp ecx, ZF_ARENAS + jae .kept + mov ecx, [zf_start + ecx * 4] + mov [BS_ZTIMA], ecx + sub ecx, ZF_SLOW ; pitched as the frames before leave it + jge .ease + xor ecx, ecx +.ease: imul ecx, ecx, ZF_EASE + neg ecx + add ecx, ZF_LEVEL + mov [eax + ZF_OBJPITCH], cx +.kept: pop ecx + pop eax +.out: ret + +; The round starts - its clock, its music - as GET READY's count runs +; out, which is long before Z-Gradt is down from its descent. In a +; one-player game with the player as Z-Gradt, the count is held at its end +; while the fly-in timer runs (it is -1 once landed), ZR_MAX frames at +; most. Not on the last stage: the player's does not fly in there, and the +; timer is the CPU's, whose descent the stock count does not wait for. In +; place of A's +; `cmp dword [count], 0` before the round starts, two nops after; the +; flags are the answer. +ZR_MAX equ 600 +zready_a: + cmp dword [BS_RCOUNTA], 0 + jne .out + cmp dword [boss], ZGRADT + jne .go + cmp dword [BS_STAGEA], LAST_STAGE ; there the player's does not + je .go ; fly in, the timer the CPU's: as stock + cmp dword [BS_ZTIMA], 0 + jl .go ; down + cmp dword [zr_wait], ZR_MAX + jae .go + inc dword [zr_wait] + mov dword [BS_RCOUNTA], 1 ; back to 0 next frame, asked again + cmp esp, 0 ; not yet +.out: ret +.go: mov dword [zr_wait], 0 + cmp dword [BS_RCOUNTA], 0 + ret + +; Z-Gradt's super laser goes on the guard gesture, both levers pulled in +; (0x602), which the lever decode counts into the byte at +0x13b, 0xff +; once the gesture has been held: the tick's trigger reads it, with no +; laser under way (its state -1), and starts the laser as weapon 6. On +; the pad that gesture is the Guard bind. The player's Z-Gradt fires it +; on Dash instead: Z-Gradt has no dash, so the bind is free, and a button +; is more of a trigger than a gesture. Dash sets both turbo bits (the +; game's slot 8, 0x02 in each lever), which the decode turns into the +; bytes at +0x142 and +0x143 - 0xff on the frame a turbo goes down, +; counting down while it is held, 0 up - so the laser fires on the press, +; not the hold; on the twin-stick profile either turbo button does. +; Guard then does nothing on the player's Z-Gradt. In place of the +; trigger's load of the guard byte into ecx; ecx comes back as the +; game's compare wants it, 0xff to fire. +ZF_GUARD equ 0x13b +ZF_TURBOA equ 0x142 +ZF_TURBOB equ 0x143 + +zfire_a: + mov eax, [ebp + 8] + xor ecx, ecx + cmp eax, BS_OBJA + jne .stock + cmp dword [boss], ZGRADT + jne .stock + mov cl, [eax + ZF_TURBOB] + cmp cl, 0xff + je .done + mov cl, [eax + ZF_TURBOA] + ret +.stock: mov cl, [eax + ZF_GUARD] +.done: ret + +; Z-Gradt's moves ask its own floor query where the ground is at the place +; it moves to: a box 280 each way from the arena's middle, the moon gate's +; size, flat inside, a wall of 100000 outside with the wall's facing. On +; every other arena the player's Z-Gradt asks the arena's own floor +; instead, the query the eight walk by (BS_FLOORA): a wall where it says +; one is, its facing as it writes it; otherwise the floor there against +; the floor under it now, a rise over zfl_step a wall facing the way it +; moves, a smaller one taken, its height following the ground. In place +; of the three calls to its own query; cdecl, (the object, x, z, the +; facing's word), the height in st0. +zfloor_a: + cmp dword [BS_ARENA], ARENA_MOON + je BS_ZBOXA ; its own box there, the args as they are + push ebp + mov ebp, esp + sub esp, 12 ; the floor there, the floor here, a facing + push dword [ebp + 0x14] + push dword [ebp + 0x10] + push dword [ebp + 0xc] + push dword [ebp + 8] + call BS_FLOORA + add esp, 16 + fst dword [ebp - 4] + fcomp dword [zfl_wall] + fnstsw ax + test ah, 1 ; under a wall's height: floor + jz .wall + mov eax, [ebp + 8] + lea ecx, [ebp - 12] + push ecx + push dword [eax + 0x10] + push dword [eax + 8] + push eax + call BS_FLOORA + add esp, 16 + fst dword [ebp - 8] + fcomp dword [zfl_wall] + fnstsw ax + test ah, 1 + jz .inside ; in a wall now: out of it as it likes + fld dword [ebp - 4] + fsub dword [ebp - 8] ; the rise + fcom dword [zfl_step] + fnstsw ax + test ah, 0x41 + jnz .rise ; a step it takes + mov eax, [ebp + 8] ; too high: a wall facing the way it moves + mov ecx, [eax + 0x1c8] ; along x + mov edx, [eax + 0x1cc] ; along z + mov eax, ecx + and eax, 0x7fffffff + push edx + and edx, 0x7fffffff + cmp eax, edx + pop edx + mov eax, 0x4000 ; the wall past +x, as the box has it + jb .alongz + test ecx, ecx + jns .facing + mov eax, 0xc000 ; past -x + jmp .facing +.alongz: + xor eax, eax ; past -z + test edx, edx + js .facing + mov eax, 0x8000 ; past +z +.facing: + mov ecx, [ebp + 0x14] + mov [ecx], ax +.rise: mov eax, [ebp + 8] + fadd dword [eax + 0xc] ; its height now, the rise on it + jmp .out +.inside: + mov eax, [ebp + 8] + fld dword [eax + 0xc] + jmp .out +.wall: fld dword [ebp - 4] +.out: leave + ret + + TIMER tm_2, BS_ZTIMA, BS_TM2, BS_TM2S + TIMER tm_4, BS_ZTIMA, BS_TM4, BS_TM4S + +; Which clip bank an object animates from: the pad's for the player, the +; AI's for a Z-Gradt that is not. eax is the object. +%macro CLIP 4 ; label, bank 0, bank 3, the copy's + ; stage +%1: + LAST %%stock, %4 + IF_PLAYER eax, %2 + cmp dword [eax + 0x64], ZGRADT + je %3 +%%stock: + movsx eax, word [eax + 0x30] + test eax, eax + jne %3 + jmp %2 +%endmacro + + CLIP clip_a, BS_CLIP0A, BS_CLIP3A, BS_STAGEA + +; The player's Z-Gradt gets its own copy of the model header, made once, +; so the CPU's writes to it do not move both. +%macro CLONE 5 ; label, resume, copy, copied flag, + ; the stage +%1: + push ebp + mov ebp, esp + sub esp, BS_CLONEFRAME ; 0x44, 0xc in the rerelease + push ebx + push esi + push edi + LAST %2, %5 + mov eax, [ebp + 8] + IF_PLAYER eax, %%player + jmp %2 +%%player: + mov ecx, [eax + 0x6c] + test ecx, ecx + jz %2 + cmp ecx, %3 + je %2 + cmp ecx, BS_ZGA + jne %2 + cmp dword [%4], 0 + jne %%point + mov esi, ecx + mov edi, %3 + mov ecx, MODEL_COPY / 4 + cld + rep movsd + mov dword [%4], 1 +%%point: ; esi and edi are the function's to + mov esi, [eax + 0x6c] ; set, after the pushes above + mov edi, [eax + 0x70] + sub edi, esi + mov dword [eax + 0x6c], %3 + lea edi, [edi + %3] + mov [eax + 0x70], edi + jmp %2 +%endmacro + + CLONE clone_a, BS_CLONEA, copy_a, copied_a, BS_STAGEA + +; Z-Gradt's setup points four words of the AI state at its side's tables: +; the meshes of its upper parts, and with them the palette slots they draw +; in. ZTAB0 for side 0 ([object+0x68]), ZTAB1 otherwise, each at ZTAB_2..4 +; on. The copy below is the CPU's, so the player's are put back in it. +ZTAB_2 equ 0x58 +ZTAB_3 equ 0x248 +ZTAB_4 equ 0x260 + +; The player's Z-Gradt ticks against its own copy of the AI state, swapped +; in around the call. The copy starts as the CPU's, just initialised - a +; zero one sends 0x1ad01c4 through a NULL - with the three timers the init +; sets to -1 set again. +%macro AI 14 ; label, resume, live state, bank, scratch, flag, + ; three offsets set to -1, the offsets of the + ; four words the side's tables go in, and the + ; copy's stage +%1: + LAST %%stock, %14 + IF_PLAYER dword [esp + 4], %%wrap +%%stock: + push ebp + mov ebp, esp + sub esp, 4 + push ebx + push esi + push edi + jmp %2 +%%wrap: + cmp dword [%6], 0 + jne %%have + COPYAI %4, %3 + mov edx, %4 + mov dword [edx + %7], -1 + mov dword [edx + %8], -1 + mov dword [edx + %9], -1 + mov dword [%6], 1 + push eax ; the player's side's tables (ZTAB_2..4) + mov eax, [esp + 8] + cmp dword [eax + 0x68], 0 + mov eax, BS_ZTAB0 + je %%side + mov eax, BS_ZTAB1 +%%side: mov [edx + %10], eax + add eax, ZTAB_2 + mov [edx + %11], eax + add eax, ZTAB_3 - ZTAB_2 + mov [edx + %12], eax + add eax, ZTAB_4 - ZTAB_3 + mov [edx + %13], eax + pop eax +%%have: + COPYAI %5, %3 + COPYAI %3, %4 + push dword [esp + 4] + call %%stock + add esp, 4 + COPYAI %4, %3 + COPYAI %3, %5 + ret +%endmacro + + AI ai_a, BS_TICKA, BS_BSSA, bank_a, scratch_a, banked_a, \ + BS_AI1C, BS_AITIMER, BS_AILASER, BS_AITAB, BS_AITAB2, BS_AITAB3, BS_AITAB4, BS_STAGEA + +; Every machine's object is set up with attack 1, a weapon's at rest; for +; Z-Gradt, attack 1 fires its ring lasers. The CPU's has its AI to take +; over; a player's Z-Gradt, ticked by its stick, opened every fight with +; them. After Z-Gradt's own setup, a player's is put at no attack. +; +; Each round sets both objects up again, so the player's bank of the AI +; state (AI, banked_a) is dropped here and taken afresh from the CPU's, +; just initialised, on its first tick of the round. +; +; In place of the call to Z-Gradt's setup, both sites. +%macro ZINIT 2 ; label, the setup +%1: + mov dword [banked_a], 0 + push dword [esp + 4] + call %2 + add esp, 4 + mov eax, [esp + 4] + IF_PLAYER eax, %%player + ret +%%player: + mov word [eax + 0x170], 0 + ret +%endmacro + + ZINIT zinit_a, BS_ZINITA + +; Z-Gradt's fly-in (0x407dd1, its counter f in the AI state), backwards, +; as offsets from where it stands: f from 0 it comes 20 a frame from far +; off, at 70 up, pitched 0x4000; from 0x78, 4.8 a frame, the pitch easing by +; 0x80 a frame; from 0xc8 it drops the 70 under 0.05 a frame. Backwards, r +; frames in, ecx: +; r < 53 up from the ground, y 70 - 0.025 (53 - r)^2, pitching up +; once 0x1800 - 0x80 (53 - r) is over 0 +; r < 133 back at 4.8 a frame, the pitch from 0x1800 by 0x80 a frame +; r < 252 back at 20 a frame, pitched 0x4000 +; Its movement sets its place each frame, so these go in around its draw +; only (ZFLY): up and back by so much, pitched so, drawn, and put back. +zflyout: + cmp ecx, ZFLY_N - 1 + jle .r + mov ecx, ZFLY_N - 1 +.r: mov byte [zfly_on], 1 + cmp ecx, 53 + jge .back + mov eax, 53 ; y = 70 - 0.025 d^2, d = 53 - r + sub eax, ecx + mov [zfly_n], eax + fild dword [zfly_n] + fmul st0, st0 + fmul dword [zfly_g] + fsubr dword [zfly_h] + fstp dword [zfly_y] + mov dword [zfly_z], 0 + imul eax, 0x80 + neg eax + add eax, 0x1800 + jge .p + xor eax, eax +.p: mov [zfly_p], ax + ret +.back: mov eax, [zfly_h] + mov [zfly_y], eax + sub ecx, 53 + cmp ecx, 80 + jge .away + mov [zfly_n], ecx ; z = -4.8 (r - 53) + fild dword [zfly_n] + fmul dword [zfly_v1] + fchs + fstp dword [zfly_z] + shl ecx, 7 + add ecx, 0x1800 + mov [zfly_p], cx + ret +.away: sub ecx, 80 ; z = -(384 + 20 (r - 133)) + mov [zfly_n], ecx + fild dword [zfly_n] + fmul dword [zfly_v2] + fadd dword [zfly_z1] + fchs + fstp dword [zfly_z] + mov word [zfly_p], 0x4000 + ret + +; Phase 0 draws the machines itself, after the charge has written its +; joint frames: through the charge Z-Gradt is drawn with the ones it had +; before (ZEND's copy of them), and they are put back for the charge. +; +; In place of the call to Z-Gradt's draw, in its per-frame routine. +%macro ZFLY 2 ; label, the draw +%1: + mov eax, [esp + 4] + cmp byte [zstage], 1 + jne %%fly + IF_PLAYER eax, %%charge +%%fly: cmp byte [zfly_on], 0 + je %%stock + IF_PLAYER eax, %%player +%%stock: + jmp %2 +%%charge: + call zswap + push eax + call %2 + pop eax + jmp zswap +%%player: + push dword [eax + 0xc] + push dword [eax + 0x10] + push dword [eax + 0x34] + fld dword [eax + 0xc] + fadd dword [zfly_y] + fstp dword [eax + 0xc] + fld dword [eax + 0x10] + fadd dword [zfly_z] + fstp dword [eax + 0x10] + mov cx, [zfly_p] ; nose the other way: thrusters + neg cx ; behind it, as it leaves + mov [eax + 0x34], cx + push eax + call %2 + pop eax + pop dword [eax + 0x34] + pop dword [eax + 0x10] + pop dword [eax + 0xc] + ret +%endmacro + + ZFLY zfly_draw_a, BS_ZDRAWA + +; Swaps Z-Gradt's joint frames, its laser's count and Raiden's flag, eax's, +; with ZEND's copy. eax kept. +zswap: + push ecx + push edx + xor ecx, ecx +.j: mov edx, [eax + ZPOSE + ecx] + xchg edx, [zpose + ecx] + mov [eax + ZPOSE + ecx], edx + add ecx, 4 + cmp ecx, ZPOSE_N + jb .j + mov dx, [eax + 0x178] + xchg dx, [zpose + ZPOSE_N] + mov [eax + 0x178], dx + mov dx, [eax + 0x1a4] + xchg dx, [zpose + ZPOSE_N + 2] + mov [eax + 0x1a4], dx + pop edx + pop ecx + ret + +; Jaguarandi's ending runs on Raiden's, which writes the frame of a part of +; Raiden's, at object + 0xc2, that is another part of Jaguarandi's: the +; player's Jaguarandi is drawn in the ending (the player's mode 5) with it +; at 0, as before the charge, and it is put back after. +; +; In place of the call to a machine's draw, in the eight's per-frame +; routine. +%macro JPOSE 2 ; label, the draw +%1: + mov eax, [esp + 4] + cmp dword [eax + 0x64], JAG + jne %%stock + cmp byte [eax + 0x30], 5 + jne %%stock + IF_PLAYER eax, %%player +%%stock: + jmp %2 +%%player: + push dword [eax + 0xc0] + mov word [eax + 0xc2], 0 + push eax + call %2 + pop eax + pop dword [eax + 0xc0] + ret +%endmacro + + JPOSE jpose_a, BS_MDRAWA + +; --- Z-Gradt's gold -------------------------------------------------------- + +; The laser turns Z-Gradt gold through a palette event, 0x21f, and 0x200 +; puts its own palette back. The handler (0x4f3889) takes a boss +; to be the CPU and write the CPU's slots, so a player's Z-Gradt turned its +; opponent gold, then Z-Gradt-coloured. Where Z-Gradt's tick posts the +; event, note whether the player's object posted it; the handlers then use +; the player's slots for it, the side its colour came from. +%macro POST 3 ; label, the request, the event +%1: + mov eax, [%2] + mov [%3], eax + mov byte [zmine], 0 + IF_PLAYER dword [ebp + 8], %%mine + ret +%%mine: mov byte [zmine], 1 + ret +%endmacro + + POST zpost_a, BS_ZEVA, BS_EVA + +; In place of `cmp dword [ebp+PAL_CPU], 0; je slots 1/3`, for gold. +%macro GOLD 3 ; label, slots 5/7, slots 1/3 +%1: + cmp byte [zmine], 0 + je %%stock + cmp dword [bside], BS_COL1 + je %2 + jmp %3 +%%stock: + cmp dword [ebp + PAL_CPU], 0 + je %3 + jmp %2 +%endmacro + + GOLD zgold_a, BS_ZGA5, BS_ZGA1 + +; And for 0x200: the player's own pair goes back through the loader, so a +; colour it was confirmed in comes back with it. +%macro RESTORE 5 ; label, slots 5/7, slots 1/3, the +%1: ; handler's end, the loader + cmp byte [zmine], 0 + je %%stock + mov ebx, [boss] + test ebx, ebx + jnz %%id + mov ebx, ZGRADT +%%id: shl ebx, 2 ; palette id: machine * 4 + side * 2 + mov esi, 1 + cmp dword [bside], BS_COL1 + jne %%load + or ebx, 2 + mov esi, 5 +%%load: push ebx + push esi + call %5 + add esp, 8 + inc ebx + add esi, 2 + push ebx + push esi + call %5 + add esp, 8 + jmp %4 +%%stock: + cmp dword [ebp + PAL_CPU], 0 + je %3 + jmp %2 +%endmacro + + RESTORE zrest_a, BS_ZRA5, BS_ZRA1, BS_ZRAX, BS_PALLOADA + +; As a Z-Gradt dies its palettes darken, events 0x401 to 0x43f, each range +; with the same test of the side. A player's Z-Gradt keeps the colours it +; was given as it collapses: what it posts there is passed over. In place +; of `cmp dword [ebp+PAL_CPU], 0; je slots 1/3`, both ranges. +%macro DARK 4 ; label, slots 5/7, slots 1/3, the end +%1: + cmp byte [zmine], 0 + jne %4 + cmp dword [ebp + PAL_CPU], 0 + je %3 + jmp %2 +%endmacro + + DARK zdark_a, BS_ZDA5, BS_ZDA1, BS_ZRAX + DARK zfade_a, BS_ZFA5, BS_ZFA1, BS_ZRAX + +; --- the KO replay's ring ------------------------------------------------ + +; The KO replay rewinds the fight: every fourth frame the game copies both +; objects (0x600 bytes each) into a ring of 30 slots, and the replay puts +; the slot from two seconds back over the objects and runs the recorded +; levers on from there. Z-Gradt's super laser keeps its state outside the +; object, in the AI globals from BS_BSSA (the laser's state, the gold +; ramp, the draw's count), which the ring does not hold: rewound, the +; object was two seconds behind its laser, so the replay's laser ran out +; of step with its beams and particles, and a laser KO left the two out of +; step through the screens after it. The patch keeps a ring of its own +; beside the game's - the live block, the player's bank (AI, banked on the +; last stage) and the lock-on's two words - filled and read in the same +; slot at the same moment. In place of the `mov ecx, 0x180` before each +; copy of object A to or from the game's ring, twelve sites: the ten +; restores, the ring's fill at a round's start and the recorder. eax is +; the slot's offset (the slot << 9); edi is the object on a restore and +; the slot on a record. +RING_N equ 30 +RING_BANK equ AI_STATE ; the live block, then the bank, then +RING_FLAGS equ 2 * AI_STATE ; banked_a, zl_on and zl_prev +RING_SLOT equ 2 * AI_STATE + 16 + +zring_a: + mov ecx, 0x180 ; the displaced instruction + pushad + mov edx, eax + shr edx, 9 + imul edx, edx, RING_SLOT + add edx, zring + cld + cmp edi, BS_OBJA + jne .record + mov esi, edx ; a restore: the slot over the globals + mov edi, BS_BSSA + mov ecx, BS_AIDW + rep movsd + lea esi, [edx + RING_BANK] + mov edi, bank_a + mov ecx, AI_STATE / 4 + rep movsd + mov eax, [edx + RING_FLAGS] + mov [banked_a], eax + mov eax, [edx + RING_FLAGS + 4] + mov [zl_on], eax + mov eax, [edx + RING_FLAGS + 8] + mov [zl_prev], eax + popad + ret +.record: + mov edi, edx ; a record: the globals into the slot + mov esi, BS_BSSA + mov ecx, BS_AIDW + rep movsd + lea edi, [edx + RING_BANK] + mov esi, bank_a + mov ecx, AI_STATE / 4 + rep movsd + mov eax, [banked_a] + mov [edx + RING_FLAGS], eax + mov eax, [zl_on] + mov [edx + RING_FLAGS + 4], eax + mov eax, [zl_prev] + mov [edx + RING_FLAGS + 8], eax + popad + ret + +; --- Jaguarandi's red segments --------------------------------------------- + +; The renderer draws a frame's polygons nearest first, each keeping the +; pixels it covers, in the order of a key a polygon: the depth of its +; nearest vertex, in buckets 1/256th of the depth wide; in a bucket the +; polygon queued later is drawn first. Jaguarandi's red segments, on its +; legs and back, are the polygons of its luminous light group (bits 18 to +; 22 of a polygon's flags, 0), each in the plane of a face of a +; neighbouring part. The two land in one bucket or the other's as the +; legs move, so the segment shows and goes a frame at a time, and stays +; gone as a turn holds the face nearer; the CPU's, far off, stays in the +; one bucket. Sorted to the far end, the segments vanish behind the +; body, and nothing else changes (seen). The eight use the group too, so +; only Jaguarandi's are moved: a polygon within its file, in the slot +; the loader gives it (BS_SLOTS, its size in BS_RBNAMES), where the +; select puts its own copy as it draws (sel_slotsin). In place of the +; key's store in the mesh draw's four-sided path, wherever a mesh is +; drawn: a luminous polygon of Jaguarandi's has its key one bucket +; nearer. [ebp+0x10] is the polygon in its mesh, past its flags; a key +; is a float's bits, a bucket 0x8000 of them. +LUMINOUS equ 0 ; the light group +KEY_BUCKET equ 0x8000 +jlum_a: + push edx + mov edx, [ebp + 0x10] + sub edx, [BS_SLOTS + SEL_JAGFILE * 4] ; its place in the file, + cmp edx, [BS_RBNAMES + SEL_JAGFILE * 8 + 4] ; if in it (no file: + jae .store ; nothing is) + mov edx, [ebp + 0x10] + mov edx, [edx - 4] ; the polygon's flags + shr edx, 18 + and edx, 0x1f + cmp edx, LUMINOUS + jne .store + sub eax, KEY_BUCKET +.store: pop edx + mov [BS_KEYA], eax ; the displaced instruction + ret + +; --- Z-Gradt's laser gauge ------------------------------------------------- + +; The HUD's three weapon strips (0x55d221, from the HUD pass) each stand a +; bar on the matrix: the identity, a translate to the strip's place at +; z 1 under the HUD's projection of 600, a scale of (1/1200, 1/500, 1) +; (1/166 for the thirty frames after the weapon's button goes down on it +; while it is not ready, the bar swelling), a scale of (fill * 40, 5, 1) +; into that, a translate of 1 along x so the quad (BS_BARMESHA, 2 by 2 +; about the origin) grows rightwards, and the draw, in the weapon's colour +; or red while it is not ready. The name is tiles at a column and row; +; while the button is down on a weapon not ready the strips' CHARGING +; block stands over it (BS_CHARGEA: the word two rows high four rows +; above the name, a box over the bar; the rows cleared and the name +; printed again when the button is up), and the refusal sound plays once +; per press. The strips sit on one row at y -0.1217, x -0.2933, -0.0667 +; and 0.16, each 80 wide, so the group is centred and the middle one is +; the centre. The player's Z-Gradt gets a fourth under them, at the +; middle one's x and seven tile rows down, clear of the block: its super +; laser, CANNON (the strips fit ten letters), filled as a strip fills +; from its weapon's heat: a weapon's shot adds its cost to the heat on +; the frame its motion launches the shot (Temjin's rifle at its motion's +; frame 0x12), not on the press; the heat runs down one a frame, and +; the bar is the heat's shortfall from the weapon's maximum in whole +; percent, ready while a shot's cost still fits. The laser launches its +; beam at state ZL_FIRING, after the cannon's deploy and charge, and its +; cost is the rest of its cycle, to idle (-1 at ZL_IDLE): the bar empties +; as the beam fires, red, and climbs back a percent at a time to full as +; the cannon finishes folding away. Through the deploy and the charge it +; is drawn as the strips draw a close-combat weapon's bar with the +; opponent in its reach (the ready byte's bit 2): full, in a third +; material, its height 6 + 3 sin (frame << 12) in place of 5, and ready, +; so the button shows nothing; its button is Dash, both turbos down +; (the turbo bytes, 0xff as one goes down and counting down to 1 while +; held). The laser's state is read as zlock reads it, from the live block +; or the player's bank. In place of the strips' epilogue (pop edi, esi, +; ebx; leave; ret), which the hook ends with; [ebp+8] is the object, +; [ebp-4] whether the HUD shows. +ZG_X equ 0xbd888889 ; -0.0667, the middle strip's +ZG_Y equ 0xbe5c28f6 ; -0.215: the strips' row and seven tile + ; rows of 8 down, the name's +ZG_COL equ 0x1a ; the name, as the middle strip's +ZG_ROW equ 0x27 ; seven under the names' +ZG_BLOCK equ 4 ; the CHARGING block starts this far up +ZG_SWELL equ 0x1e ; the bar's, after a press on it +ZG_REFUSED equ 0x8e ; the sound +ZL_FIRING equ 0x104 ; the beam's first frame, and +ZL_IDLE equ 0x209 ; -1 again at this +zgauge_a: + cmp dword [ebp - 4], 0 + je .out + cmp dword [boss], ZGRADT + jne .out + cmp dword [ebp + 8], BS_OBJA + jne .out + call zg_fill ; the fill and the colour + fmul dword [zg_full] + fstp dword [zg_width] + call zg_press ; the button: the swell, the sound + call BS_MPUSHA + call BS_MIDENTA + push 0x3f800000 ; 1.0 + push ZG_Y + push ZG_X + call BS_VIEWA + add esp, 12 + mov eax, 0x3b03126f ; the strips' unit: 1/1200 along x, + cmp dword [zg_timer], 0 ; 1/500 along y, 1/166 swollen + je .thin + mov eax, 0x3bc49ba6 +.thin: push 0x3f800000 + push eax + push 0x3ada740e + call BS_MSCALEA + add esp, 12 + push 0x3f800000 + push dword [zg_h] ; 5.0, the bar's half height, or the pulse + push dword [zg_width] + call BS_MSCALEA + add esp, 12 + push 0 + push 0 + push 0x3f800000 + call BS_VIEWA + add esp, 12 + call BS_MSETA + push 1 + push BS_BARMESHA + push dword [zg_mat] ; the colour zg_fill chose + push 0 + call BS_MESHA + add esp, 16 + call BS_MPOPA + push ZG_ROW - ZG_BLOCK + push ZG_COL + call BS_TXTPOSA + add esp, 8 + cmp dword [zg_held], 0 + je .name + push 1 ; pressed on it out: the block + call BS_CHARGEA + add esp, 4 + jmp .out +.name: push 0 ; else the block's rows cleared, + call BS_CHARGEA + add esp, 4 + push ZG_ROW ; the name + push ZG_COL + call BS_TXTPOSA + add esp, 8 + push zg_name + call BS_PRINT2A + add esp, 4 +.out: pop edi + pop esi + pop ebx + leave + ret + +; st0 the fill, 0 to 1; zg_mat the bar's material, zg_h its half height +; and zg_ready whether the button is answered. +zg_fill: + mov ecx, BS_BSSA + cmp dword [banked_a], 0 + je .live + mov ecx, bank_a +.live: mov ecx, [ecx + BS_AILASER] + mov dword [zg_mat], BS_BARREDA + mov dword [zg_h], 0x40a00000 + mov dword [zg_ready], 0 + cmp ecx, 0 + jl .full ; idle + cmp ecx, ZL_FIRING + jl .prep ; deploying or charging: live + cmp ecx, ZL_IDLE + jge .full + sub ecx, ZL_FIRING - 1 ; firing or folding: (frames since the + imul ecx, 100 ; beam + 1) * 100 / the rest of the + xor edx, edx ; cycle, whole percent, as the gauge + mov eax, ecx ; word + mov ecx, ZL_IDLE - ZL_FIRING + div ecx + mov [zg_tmp], eax + fild dword [zg_tmp] + fdiv dword [zg_cent] + ret +.prep: mov dword [zg_mat], BS_BARLIVEA + mov eax, [BS_FRAMEA] + shl eax, 12 + push eax + call BS_SINA + add esp, 4 + fmul dword [zg_pamp] + fadd dword [zg_pbase] + fstp dword [zg_h] + mov dword [zg_ready], 1 + fld1 + ret +.full: mov dword [zg_ready], 1 + mov dword [zg_mat], BS_BARONA + fld1 + ret + +; The button, as a strip reads its weapon's (0x55d221): ready, the swell's +; timer is cleared at once; else it runs down a frame, and Dash down on +; it sets zg_held and the timer again, with the sound as it goes down +; (the strips play it once while any timer is at ZG_SWELL, armed again +; when none is). The press that fires the laser is read here too: held +; on, it gets the block from the beam on, as a weapon's button held past +; its shot's launch does. +zg_press: + mov dword [zg_held], 0 + cmp dword [zg_ready], 0 + jne .ready + cmp dword [zg_timer], 0 + je .button + dec dword [zg_timer] +.button: + mov eax, [ebp + 8] + cmp byte [eax + ZF_TURBOA], 0 + je .up + cmp byte [eax + ZF_TURBOB], 0 + je .up + mov dword [zg_held], 1 + mov dword [zg_timer], ZG_SWELL + cmp dword [zg_sounded], 0 + jne .done + mov dword [zg_sounded], 1 + push ZG_REFUSED + call BS_SFX + add esp, 4 + ret +.ready: mov dword [zg_timer], 0 +.up: mov dword [zg_sounded], 0 +.done: ret + +zg_full: dd 0x42200000 ; 40.0, a full bar +zg_cent: dd 0x42c80000 ; 100.0 +zg_pamp: dd 0x40400000 ; 3.0, the pulse's swing, as the strips' +zg_pbase: dd 0x40c00000 ; 6.0, about this +zg_name: db 'CANNON', 0 + +; --- Z-Gradt's weapons on the strips -------------------------------------- + +; Z-Gradt's three shots are made outside the strips' heat counting, so +; its bars stay full and a press on them shows nothing. While a weapon's +; button is down on the player's Z-Gradt its strip is drawn in the live +; bar's material (BS_BARLIVEA, a close-combat weapon's with the opponent +; in reach) in place of the ready colour, at its usual height. The +; button bytes (+0x138 right, +0x139 left, +0x13a both) are nonzero +; while the button is down: 0xff as it goes down, counting down after, +; 0 up. In place of each strip's push of the ready material before its +; draw; ebp the strips' frame, [ebp+8] the object; eax and ecx free. +%macro ZBAR 2 ; label, the button's byte +%1: + pop ecx ; the return + push BS_BARONA ; the push in place of + cmp dword [boss], ZGRADT + jne %%out + mov eax, [ebp + 8] + cmp eax, BS_OBJA + jne %%out + cmp byte [eax + %2], 0 + je %%out + mov dword [esp], BS_BARLIVEA +%%out: jmp ecx +%endmacro + + ZBAR zbar_ra, 0x138 + ZBAR zbar_la, 0x139 + ZBAR zbar_ba, 0x13a + +; --- the replay and the win and lose screens ----------------------------- + +; Both are framed for the eight, so a boss fills the screen. In a +; one-player game they are 0x502d21 (sub-state 0x14, the KO replay) and +; 0x4b4456 (0x0c, YOU WIN, PERFECT, YOU LOSE), and their twins. + +; The win camera (0x50ed51, 0x599fd1) runs one of eight shots, each of +; which sets a distance to its subject, places the eye that far out, and +; aims from the eye and that distance. Scaling the distance where it is +; stored moves the eye back with the aim kept. A boss's is the game's +; times its factor (win_jag, win_z), and at least its minimum (win_jmin, +; win_zmin): Jaguarandi grows through its win pose (its model's routine +; for the pose, 0x50e230, adds 0.02 to its scale a frame), and the shots +; that close in end at 15. The floor search's later turns keep +; a share of the factor's extra and of the minimum ([win_share], 1 +; otherwise). [ebp+8] is the subject; st0 the distance, in and out. +winfactor: + push eax + mov eax, [ebp + 8] + mov eax, [eax + 0x64] + cmp eax, ZGRADT + je .z + cmp eax, JAG + jne .out + fld dword [win_jag] + fld dword [win_jmin] + jmp .go +.z: fld dword [win_z] + fld dword [win_zmin] +.go: fmul dword [win_share] ; the least this turn + fxch st1 + fld1 + fsubp st1, st0 ; the factor's extra over one, + fmul dword [win_share] ; this turn's share of it + fld1 + faddp st1, st0 + fmulp st2, st0 ; the distance by it + fcomi st0, st1 ; the least, or the distance + jbe .drop + fxch st1 +.drop: fstp st0 +.out: pop eax + ret + +%macro WINSCALE 0 + mov dword [win_share], 0x3f800000 ; 1.0 + call winfactor +%endmacro + +; In place of `fstp dword [distance]`, a nop after the call. +%macro WIN 2 ; label, the distance +%1: + WINSCALE + fstp dword [%2] + ret +%endmacro + +; In place of `mov dword [distance], value`, five nops after the call. +%macro WINSET 3 ; label, the distance, the value +%1: + fld dword [%3] + WINSCALE + fstp dword [%2] + ret +%endmacro + +; Three of the shots look for a spot at the distance round the subject +; with floor under it, turning till they find one; at a boss's distance a +; small arena has none, and they would turn for ever. So the distance is +; the boss's for a turn round (WIN_TRIES, the angle 0x80 back a try), then +; each turn round after it a step nearer the game's own, WIN_STEPS steps +; in all, and the game's after those. win_tries is the tries this frame. +WIN_TRIES equ 0x10000 / 0x80 +WIN_SHIFT equ 9 ; the tries to the turns round +%if WIN_TRIES != (1 << WIN_SHIFT) +%error WIN_SHIFT is not WIN_TRIES's +%endif +WIN_STEPS equ 4 +%macro WINTRY 2 ; label, the distance +%1: + inc dword [win_tries] + push eax + mov eax, [win_tries] + shr eax, WIN_SHIFT ; the turns round so far + cmp eax, WIN_STEPS + jae %%plain + mov [win_turn], eax + fild dword [win_turn] + fsubr dword [win_steps] ; the turns left + fdiv dword [win_steps] ; of WIN_STEPS + fstp dword [win_share] + call winfactor +%%plain: + pop eax + fstp dword [%2] + ret +%endmacro + + WIN win_1, BS_WIND1 + WINTRY win_1t, BS_WIND1 + WINSET win_1a, BS_WIND1, win_35 + WINSET win_1b, BS_WIND1, win_30 + +; The replay's shots aim in more ways than one, but all end in a pitch, +; a yaw and the eye, applied as rotate x by pitch, rotate y by -yaw, +; translate by the eye negated. In place of that translate: move the eye +; back along where it looks, (-sin yaw cos pitch, -sin pitch, cos yaw cos +; pitch) - the convention the win camera's shots place their eye by - +; but never down: a shot looking up from low would take the eye through +; the floor, so that one goes back across the ground alone. +%macro REPLAY 7 ; label, view translate, sin, cos, +%1: ; pitch, yaw, the player's id + mov eax, [%7] + cmp eax, ZGRADT + je %%z + cmp eax, JAG + jne %2 + mov eax, [rep_jag] + jmp %%go +%%z: mov eax, [rep_z] +%%go: mov [pullk], eax + movsx ecx, word [%5] + push ecx + call %4 ; cos pitch + add esp, 4 + fmul dword [pullk] + fstp dword [pullh] ; how far back, across the ground + movsx ecx, word [%6] + push ecx + call %3 ; sin yaw + add esp, 4 + fmul dword [pullh] + fsubr dword [esp + 4] + fstp dword [esp + 4] + movsx ecx, word [%6] + push ecx + call %4 ; cos yaw + add esp, 4 + fmul dword [pullh] + fadd dword [esp + 0xc] + fstp dword [esp + 0xc] + movsx ecx, word [%5] + push ecx + call %3 ; sin pitch + add esp, 4 + fmul dword [pullk] ; the rise + ftst + fnstsw ax + test ah, 1 ; C0: a drop + jz %%rise + fstp st0 + jmp %2 +%%rise: fsubr dword [esp + 8] + fstp dword [esp + 8] + jmp %2 +%endmacro + + REPLAY rep_1, BS_VIEWA, BS_SINA, BS_COSA, BS_RPITCH1, BS_RYAW1, BS_IDA + +; --- state ----------------------------------------------------------------- + +name_jag: db 'VR.JAGUARANDI', 0 +name_z: db 'VR.Z-GRADT', 0 +unl_file: db 'bosses.bin', 0 ; the unlocks +unl_you: db 'YOU UNLOCKED', 0 +unl_press: db 'PRESS BUTTON TO CONTINUE', 0 +unl_grow: dd 0.02 ; the model's growth a frame, to +unl_size: dd 0.9 ; the report's size +unl_level: dd 0 ; unlocked: 0, 1 Jaguarandi, 2 both +unl_read: dd 0 ; read yet +unl_clean: dd 0 ; this game can still unlock +unl_zwon: dd 0 ; and has won its last fight +unl_on: dd 0 ; the boss an unlock shows, or 0 +unl_t: dd 0 ; and its frame +unl_prev: dd 0 ; its buttons last frame, and a press +unl_go: dd 0 ; seen, waiting for them let go +unl_got: dd 0 ; the names' tiles taken +unl_placed: dd 0 ; and placed: their first tile, and +unl_first: dd 0 ; the art's count before +unl_count: dd 0 +unl_x1: dd 0x29 ; the unlock's layout: YOU UNLOCKED, + ; column and row, +unl_y1: dd 0x13 +unl_x2: dd 0x24, 0x28 ; the name, Jaguarandi's and Z-Gradt's +unl_y2: dd 0x16 ; columns, and its row, +urm_jag: dd 0.85, 10.0, 7.0 ; and the model, as rm_jag +urm_z: dd 0.35, 36.0, 7.0 +unl_px: dd 9 ; the prompt, column and row +unl_py: dd 0x2e +stood_ca: dd 0 ; the CPU's boss, standing + + align 4 +pull: dd 320.0 ; how far back the eye goes +zcam_k: dd 2.5 ; the chase camera's distance, times +jcam_k: dd 1.5 ; the game's, Z-Gradt's and Jaguarandi's +cam_min: dd 56.0 ; and the least a boss's closes to +zcam_near: dd 180.0 ; and the least its eye stands out +ecam_jag: dd 2.5 ; the ending's camera, how far out +ecam_z: dd 4.0 +ecam_zfly: dd 8.0 +ecap_d: dd 50.0 ; and the eight's distance it eases to +zcharge: dd 0 ; Z-Gradt's charge, frames +zfly_on: dd 0 ; its fly-out: on, up, back, pitch +zfly_y: dd 0 +zfly_z: dd 0 +zfly_p: dd 0 +zfly_n: dd 0 +zfly_g: dd 0.025 +zfly_h: dd 70.0 +zfly_v1: dd 4.8 +zfly_v2: dd 20.0 +zfly_z1: dd 384.0 +zgold: dd 0 ; its gold, to 0x1f +zbeam_v: dd 12.0 ; the camera's slot for its beam +zbeam_y: dd 30.0 +zbeam_z: dd 40.0 +zbeam_n: dd 0 +zbeam_free: dd 0 ; ZWALL: no walls +zbeam_far: dd -1.0e9 +zspd: dd 0 ; the beam's speed, put back after +zspd_at: dd 0 +zspd_k: dd 3.0 +zslow: dd 0 +end_g1p: dd 0 ; the boss's machine, lent out +zstage: dd 0 ; and which part of it (ZEND) +eside: dd 0.0046875 ; how far off to the side, of the way +eside_n: dd 0 ; to the target, over ESTEP_FADE: 0.3 +rm_jag: dd 0.6, 4.0, 0.0 ; the report's model: scale, the +rm_z: dd 0.45, 10.0, -5.0 ; height its origin sits at, and how + ; far right of the usual it turns +rrm_jag: dd 0.85, 7.0, 4.0 ; the player's Jaguarandi, as the + ; unlock poses it +win_tries: dd 0 +win_turn: dd 0 ; the turn round a try is in +win_steps: dd 4.0 ; WIN_STEPS +zr_wait: dd 0 ; frames GET READY has been held +zl_prev: dd 0 ; the player's levers last frame +zl_on: dd 0 ; turning to face the CPU +zl_ang: dd 0 ; the way to it +zf_start: dd 100, 199, 100, 60, 100, 199, 100, 100, 100, 199 ; the + ; player's Z-Gradt's fly-in, by arena: + ; Air, Fact, Water, Fore, Inka, Dock, + ; Moon, Tro, Fld, Core +zfl_wall: dd 1000.0 ; the arena's floor at a wall, and over +zfl_step: dd 4.0 ; the rise Z-Gradt's moves take, its own +win_z: dd 4.0 ; win and lose: the subject's distance +win_jag: dd 2.0 ; times this +win_jmin: dd 250.0 ; and at least this: Jaguarandi's, +win_zmin: dd 0.0 ; Z-Gradt's (none) +win_share: dd 1.0 ; the floor search's share of the extra +win_35: dd 35.0 ; the two a shot sets as constants +win_30: dd 30.0 +rep_z: dd 120.0 ; the replay: how far further back +rep_jag: dd 80.0 +pullk: dd 0 +pullh: dd 0 +was: dd 0 ; on the select last frame +boss: dd 0 ; the player's boss in one player, or 0 +bsrc: dd 0 ; the machine whose colours it wears +bcolor: dd 0 ; that machine's colour, one on, 0 its own +bside: dd 0 ; and the array it came from +sel_step: dd 30.0 ; to a boss in the lineup, and on +sel_bstep: dd 1.5 ; the camera's step a frame to one +sel_one: dd 1.0 +sel_twenty: dd 20.0 ; a move's frames +; Z-Gradt in the lineup: past Jaguarandi, lifted onto the hangar's lip, +; at a size; the camera's step a frame to it along the row and up, as the +; move takes 20 frames. +sel_zgap: dd 98.0 +sel_zy: dd 22.0 +sel_zscale: dd 1.0 ; its size in a fight +sel_zstep: dd 3.4 ; 68 / 20, short of it by 30, as + ; it is set off to the right, +sel_zrise: dd 2.4 ; the camera's height, 48 / 20, +sel_zlook: dd 1.73 ; what it looks at's, 34.6 / 20, +sel_zback: dd 3.1 ; and its distance, 62 / 20 +sel_bcol: dd 0, 0 ; the bosses' colours given here +sel_bslots: dd 21, 25, 29, 15 ; the bosses' palette rows, two each +sel_rowsin: dd 0 ; and theirs kept while it shows +sel_objst: dd -1 ; a machine's object moved last tick: + ; 1, 0 none, -1 not known yet +sel_lpair: dd 1, 3 ; a launching boss's rows +sel_launch: dd 0 ; launching: a boss, SEL_LREG one of + ; the eight, or 0 +sel_remap: dd 0 ; while a boss is drawn, +sel_remapto: dd 0, 0 ; the table's entries for its rows +sel_fjag: dd sel_step, 0 ; a boss's gaps to the camera, nearest +sel_fz: dd sel_zgap, sel_step, 0 ; first +sel_fedge: dd 28.43 ; the widescreen hangar's fade: its edge, +sel_fslope: dd 0.083333333 ; over 12, +sel_ffloor: dd 0.0000152587890625 ; at least 1/65536, +sel_f65536: dd 65536.0 ; in 16.16 +sel_zup: dd 0.2 ; Z-Gradt's lift off the deck a frame, +sel_zexit: dd -380.0 ; the tunnel's mouth, +sel_zthrust: dd 6.0 ; faster than the sled a frame, off, +sel_zclear2: dd 150.0 ; well past it, its spray +sel_zclear: dd -60.0 ; about at it, the hangar's inside gone +sel_zfast: dd 20.0 ; and again past it, +sel_zdive: dd 0.05 ; down to the water over the distance, +sel_zdivemax: dd 40.0 ; as far as just above it, +sel_zskim: dd 2000.0 ; so far, then +sel_zclimb: dd 0.00025 ; climbing (by the distance, squared), +sel_zeye: dd 0.7 ; the camera's look up with it, +sel_zrad: dd 10430.378 ; a radian, as an angle (0x8000 / pi) +sel_zease: dd 0.15 ; its lean, a frame towards its flight, +sel_zpivot: dd 20.0 ; about its middle +sel_zpivotn: dd -20.0 +sel_ztilt: dd 0.0 ; its lean and turn as it flies +sel_zspin: dd 0 +sel_zhead: dd 0 ; its head's bounce, frames left +sel_eight: dd 8.0 +sel_four: dd 4.0 +sel_zbob: dd 0.03 ; its head's bounce up and down +sel_zturn: dd 9.5873799e-5 ; an angle unit, in radians (pi / 0x8000) +sel_zprevz: dd 0.0 ; where it was last frame +sel_zflamey: dd -15.0 ; its thruster's flame, from its root, +sel_zflamerx: dd -10560 ; turned out of its underside (the + ; jets lie 32 degrees below the mesh's z), +sel_zflames: dd 4.0 ; and its size +sel_zjet: dd SEL_ZJET +; Z-Gradt's parts its draw places by hand, its idle's: the meshes, the +; place from the root bone, the turn about y. +%macro ZPART 5 + dd %1, %2, %3, %4, %5 +%endmacro +selzparts: + ZPART BS_ZPARTS, 0.0, -13.0, 27.0, 0 ; the four pods + ZPART BS_ZPARTS, -27.0, -13.0, 0.0, 0x4000 + ZPART BS_ZPARTS, 0.0, -13.0, -27.0, 0x8000 + ZPART BS_ZPARTS, 27.0, -13.0, 0.0, 0xc000 + ZPART BS_ZPARTS + 0xc, 0.0, -15.0, 7.5, 0 ; the core, its rings + ZPART BS_ZCROWN, 0.0, 12.0, 0.0, 0 ; and crown + ZPART BS_ZRINGS, 0.0, 12.0, 0.0, 0 + ZPART BS_ZPARTS + 0x18, 0.0, 12.0, 0.0, 0 + ZPART BS_ZSIDES, -39.6, 5.0, 0.0, 0 ; the side units + ZPART BS_ZSIDES, -32.4, 5.0, 0.0, 0 + ZPART BS_ZSIDES, 39.6, 5.0, 0.0, 0 + ZPART BS_ZSIDES, 32.4, 5.0, 0.0, 0 + ZPART BS_ZPARTS + 0x24, -11.0, 5.0, 0.0, 0 ; the arms + ZPART BS_ZPARTS + 0x3c, -21.6, 11.0, 0.0, 0 + ZPART BS_ZPARTS + 0x48, -21.6, 15.5, 0.0, 0 + ZPART BS_ZPARTS + 0x30, 11.0, 5.0, 0.0, 0 + ZPART BS_ZPARTS + 0x3c, 21.6, 11.0, 0.0, 0 + ZPART BS_ZPARTS + 0x48, 21.6, 15.5, 0.0, 0 + dd 0 +selzmotok: dd 0 ; its motions read, or tried +selzgot: dd 0 +selzmtname: db 'mt_zig.bin', 0 + align 4 +selzmots: ; in the file, how much, where to, + dd 0x1179e0, ZMOTSZ(SEL_ZFRAMES), selzmotion, selzmot, SEL_ZFRAMES + dd 0x104918, ZMOTSZ(SEL_ZJUMPF), selzdipf, selzdip, SEL_ZJUMPF + dd 0x10fff8, ZMOTSZ(SEL_ZJUMPF), selzrecf, selzrec, SEL_ZJUMPF + dd 0 ; the motion and its frames +selzmot: dd selzpose ; its motions: one frame till they are + dw 1, SEL_ZBONES ; read +selzdip: dd selzpose + dw 1, SEL_ZBONES +selzrec: dd selzpose + dw 1, SEL_ZBONES +; Z-Gradt's idle motion's first frame, as MT_zig.bin has it at 0xedb70: +; a bone's turn about x, y and z, and its place. +selzpose: + dw 7095, 8191, 6, 0 + dd -26.1074, 15.7797, 26.102 + dw 7108, -8191, 7, 0 + dd 26.1002, 15.7772, 26.1067 + dw 7105, 24576, -11, 0 + dd -26.0881, 15.7663, -26.0975 + dw 7099, -24575, -8, 0 + dd 26.1083, 15.7799, -26.1001 + dw -11, -24576, 0, 0 + dd -21.8601, 8.1956, 21.8608 + dw 3650, 8191, 3, 0 + dd -13.0069, 25.0, 13.007 + dw 3647, 8191, 0, 0 + dd -16.7896, 22.1323, 16.7885 + dw -6, 24575, -7, 0 + dd 21.8603, 8.192, 21.86 + dw 3646, -8192, 6, 0 + dd 13.0067, 25.0001, 13.0069 + dw 3649, -8192, 0, 0 + dd 16.7862, 22.1274, 16.7878 + dw -3, -8191, 0, 0 + dd -21.8436, 8.1846, -21.849 + dw 3643, 24576, -8, 0 + dd -13.0002, 25.0001, -12.9998 + dw 3646, 24576, 0, 0 + dd -16.778, 22.1243, -16.78 + dw -6, 8192, 0, 0 + dd 21.8625, 8.1938, -21.861 + dw 3636, -24575, -6, 0 + dd 13.0066, 25.0002, -13.0067 + dw 3650, -24575, 0, 0 + dd 16.7879, 22.128, -16.786 + dw 3, 0, -3, 0 + dd -0.0002, 28.0001, 0.0002 + dw -3, 32767, -3, 0 + dd 0.004, 15.995, -14.9957 + dw 3, 0, -3, 0 + dd 0.0041, 16.0052, 15.0043 + dw 16276, 16380, -16279, 0 + dd -14.996, 15.9948, 0.0043 + dw -16277, -16387, -16280, 0 + dd 15.004, 16.0054, 0.0042 + dw -3, 32767, -3, 0 + dd 0.0025, 20.2501, 0.0028 + dw 3, 0, -3, 0 + dd 0.0025, 20.2501, 0.0028 + dw 16276, 16380, -16279, 0 + dd 0.0025, 20.2501, 0.0028 + dw -16280, -16387, -16284, 0 + dd 0.0025, 20.2501, 0.0028 + dw 0, 0, 0, 0 + dd -0.0002, 28.0001, 0.0002 +seljagdraw: dd 0 ; Jaguarandi being drawn +sel_jagcam: dd 0.3, 0.03 ; Jaguarandi's, out further than any + dw -64, 0 +sel_neck: dd 0.0, 2.12, -0.02 ; its head from its chest, in its frame +selbuilt: dd 0 ; the lineup's script, made once +selt0: dd 0, 0x42040000 ; machine of an object, of a cursor at + dd 0, 4, 5, 2, 1, 7, 6, 3, JAG, ZGRADT ; +8 +%macro SELTXT 8 ; four weapons, model, name, w, h +%rep 4 ; the weapons as long as the longest + %strlen %%n %1 ; line, so each covers what was there + %if %%n + db %1 + %endif + times 16 - %%n db ' ' + times 4 db 0 + %rotate 1 +%endrep + %strlen %%n %1 + db %1 + times 10 - %%n db ' ' + times 2 db 0 + dd %2, %3, %4 +%endmacro +seltxt: SELTXT 'BAZOOKA', 'TRAP BOMB', '10 LASER', '', \ + 'VUV-98-V', BS_LOGOJ, 0x22, 2 + SELTXT 'RING BEAM', 'PHALANX', 'FLOATING MINE', \ + 'LASER CANNON', 'ZUV-99-Z', BS_LOGOZ, 0x1a, 3 +sel_frx: dq -87.0, -137.0 ; the frame's x as the game has it +sel_rbin: db 0, 0 ; the slots pointed at sel_rbbuf +sel_rbsave: dd 0, 0 ; and what they held +selblank: times 16 db ' ' + times 4 db 0 +zmine: dd 0 ; the player posted Z-Gradt's event +copied_a: dd 0 +banked_a: dd 0 +rmbase_on: dd 0 +stood_a: dd 0 +unl_palin: dd 0 ; the unlock's palettes kept (unl_pals) +unl_scn: dd 0 ; the scene before Z-Gradt's unlock, +unl_scnmem: dd 0 ; kept here, +unl_scnin: dd 0 +unl_glow: dd 0, 0, 0 +unl_sega: dd 0 +unl_texb: dd UNL_TEXB ; and the texture bank, +unl_texnow: dd UNL_TEXB ; the one in half 1 now + +; The zeroed buffers, last. The patcher writes the blob only as far as its +; last byte that is not zero, and its section, .vobs, carries them as +; virtual size, which the loader zeroes (OWN_SECTIONS) - so they cost the +; file nothing. + align 16, db 0 +bss: + align 4, db 0 +zfake: times 0x20 db 0 + align 4, db 0 +zpose: times ZPOSE_N + 4 db 0 ; and its joint frames meanwhile + align 4, db 0 +selzmotion: times ZMOTSZ(SEL_ZFRAMES) db 0 ; its stance's frames, its dip's, + align 4, db 0 +selzdipf: times ZMOTSZ(SEL_ZJUMPF) db 0 ; its spring's + align 4, db 0 +selzrecf: times ZMOTSZ(SEL_ZJUMPF) db 0 + align 4, db 0 +selzvar: times SEL_ZBONES dw 0 ; every part as undamaged + align 4, db 0 +selzout: times 0x400 db 0 ; the pose's draw's output + align 4, db 0 +selrow: times SEL_ROWW * 8 dw 0 +selhas: dd 0 ; the bosses stand in the lineup + align 4, db 0 +selrows: times 10 * SEL_ROWS db 0 + align 4, db 0 +seld68: times 10 dd 0 + align 4, db 0 +sellcam: times 10 * SEL_LCAM db 0 + align 4, db 0 +selda8: times 10 dd 0 + align 4, db 0 +selpath: times 0x104 db 0 + align 4, db 0 +sel_rbbuf: times 12 dd 0 ; the bosses' files read, per slot, + align 4, db 0 +sel_rbtry: times 12 db 0 ; and read, or tried + align 4, db 0 +selscript: times (SEL_EIGHT + 2 + SEL_REST) * SEL_REC db 0 + align 4, db 0 +copy_a: times MODEL_COPY db 0 + align 4, db 0 +bank_a: times AI_STATE db 0 + align 4, db 0 +scratch_a: times AI_STATE db 0 + +zring: times RING_N * RING_SLOT db 0 ; the KO replay's ring of the AI state +zg_tmp: dd 0 +zg_mat: dd 0 ; the gauge's material this frame +zg_width: dd 0 ; its width +zg_held: dd 0 ; Dash down on the laser out +zg_timer: dd 0 ; the swell's frames left +zg_sounded: dd 0 ; the refusal played for this press +zg_h: dd 0 ; the bar's half height this frame +zg_ready: dd 0 ; the button answered + align 4, db 0 +objsave: times OBJECT db 0 + align 4, db 0 +stand_a: times OBJECT db 0 + align 4, db 0 +standai_a: times AI_STATE db 0 + align 4, db 0 +rmbase: times 0x30 db 0 + align 4, db 0 +aisave_a: times AI_STATE db 0 + align 4, db 0 +stand_ca: times OBJECT db 0 + align 4, db 0 +standai_ca: times AI_STATE db 0 + align 4, db 0 +unl_tiles: times (UNL_NJ + UNL_NZ) * UNL_TILE db 0 + align 4, db 0 +unl_area: times (UNL_NJ + UNL_NZ + 1) * UNL_TILE db 0 + align 4, db 0 +sel_rowskept: times 4 * 3 * SEL_PALRAM db 0 ; the bosses' rows' own + align 4, db 0 +unl_pals: times UNL_PALS db 0 ; the palettes the unlock had in + align 4, db 0 +unl_map: times UNL_NZ dw 0 + align 4, db 0 +fxsave: times FX db 0 + align 4, db 0 +fx2save: times FX2 db 0 diff --git a/asm/build.py b/asm/build.py index 2d8f0bcf..864bd9af 100755 --- a/asm/build.py +++ b/asm/build.py @@ -233,9 +233,18 @@ def check_link(vp, blobs): """Every blob links for every build, and every pin the site table relies on is where the assembly put it. A blob whose cave only exists at apply time is linked there instead, so a KeyError on a missing cave - is expected; a missing symbol is not.""" + is expected; a missing symbol is not. A blob some builds carry, in the + annex or a section of its own, and this one does not belongs to a + patch not ported to it, and is not linked for it.""" + def carried(build): + return set(build.annex[2] if build.annex else ()) | set(build.own) + anywhere = set() + for build in vp.BUILDS.values(): + anywhere |= carried(build) for build in vp.BUILDS.values(): for name in blobs: + if name in anywhere and name not in carried(build): + continue try: vp.link(name, build, blobs=blobs) except ValueError: @@ -271,7 +280,7 @@ def check_link(vp, blobs): ('CREDITS', 'credits.asm'), ('NAMEENTRY', 'nameentry.asm'), ('CAMSKIP', 'camskip.asm'), ('OVERLAY', 'overlay.asm'), ('TITLEVER', 'titlever.asm'), ('ACTIVATE', 'activate.asm'), - ('LOCKLINE', 'lockline.asm'), + ('LOCKLINE', 'lockline.asm'), ('BOSSES', 'bosses.asm'), ] diff --git a/assets/portrait_jaguarandi.png b/assets/portrait_jaguarandi.png new file mode 100644 index 00000000..5cf6e4ec Binary files /dev/null and b/assets/portrait_jaguarandi.png differ diff --git a/assets/portrait_z-gradt.png b/assets/portrait_z-gradt.png new file mode 100644 index 00000000..b973b077 Binary files /dev/null and b/assets/portrait_z-gradt.png differ diff --git a/assets/readme/add-ons-section.png b/assets/readme/add-ons-section.png new file mode 100644 index 00000000..ea2fe85c Binary files /dev/null and b/assets/readme/add-ons-section.png differ diff --git a/assets/readme/cnc-ddraw-row.png b/assets/readme/cnc-ddraw-row.png new file mode 100644 index 00000000..bddfaadb Binary files /dev/null and b/assets/readme/cnc-ddraw-row.png differ diff --git a/assets/readme/f11-extras.png b/assets/readme/f11-extras.png new file mode 100644 index 00000000..c643ed37 Binary files /dev/null and b/assets/readme/f11-extras.png differ diff --git a/assets/readme/f7-bind-page.png b/assets/readme/f7-bind-page.png new file mode 100644 index 00000000..c3d1d5e4 Binary files /dev/null and b/assets/readme/f7-bind-page.png differ diff --git a/assets/readme/f7-device-list.png b/assets/readme/f7-device-list.png new file mode 100644 index 00000000..a339db30 Binary files /dev/null and b/assets/readme/f7-device-list.png differ diff --git a/assets/readme/install-section.png b/assets/readme/install-section.png new file mode 100644 index 00000000..a3c7c5b8 Binary files /dev/null and b/assets/readme/install-section.png differ diff --git a/assets/readme/internet-play.png b/assets/readme/internet-play.png new file mode 100644 index 00000000..f414925b Binary files /dev/null and b/assets/readme/internet-play.png differ diff --git a/assets/readme/laser-z-gradt.png b/assets/readme/laser-z-gradt.png new file mode 100644 index 00000000..5bf51bcc Binary files /dev/null and b/assets/readme/laser-z-gradt.png differ diff --git a/assets/readme/match-jaguarandi.png b/assets/readme/match-jaguarandi.png new file mode 100644 index 00000000..ed1f63bc Binary files /dev/null and b/assets/readme/match-jaguarandi.png differ diff --git a/assets/readme/patched-game.png b/assets/readme/patched-game.png new file mode 100644 index 00000000..3a6380c5 Binary files /dev/null and b/assets/readme/patched-game.png differ diff --git a/assets/readme/patcher-window.png b/assets/readme/patcher-window.png new file mode 100644 index 00000000..bc9f3b5d Binary files /dev/null and b/assets/readme/patcher-window.png differ diff --git a/assets/readme/pause-prompt.png b/assets/readme/pause-prompt.png new file mode 100644 index 00000000..64d81b77 Binary files /dev/null and b/assets/readme/pause-prompt.png differ diff --git a/assets/readme/select-jaguarandi.png b/assets/readme/select-jaguarandi.png new file mode 100644 index 00000000..5e771759 Binary files /dev/null and b/assets/readme/select-jaguarandi.png differ diff --git a/assets/readme/select-z-gradt.png b/assets/readme/select-z-gradt.png new file mode 100644 index 00000000..2f325b38 Binary files /dev/null and b/assets/readme/select-z-gradt.png differ diff --git a/assets/readme/title-prompt.png b/assets/readme/title-prompt.png new file mode 100644 index 00000000..743d22f6 Binary files /dev/null and b/assets/readme/title-prompt.png differ diff --git a/assets/readme/unlock-jaguarandi.png b/assets/readme/unlock-jaguarandi.png new file mode 100644 index 00000000..eb5a2232 Binary files /dev/null and b/assets/readme/unlock-jaguarandi.png differ diff --git a/assets/readme/unlock-z-gradt.png b/assets/readme/unlock-z-gradt.png new file mode 100644 index 00000000..2dbc77e9 Binary files /dev/null and b/assets/readme/unlock-z-gradt.png differ diff --git a/assets/readme/widescreen-2p-machine-select.png b/assets/readme/widescreen-2p-machine-select.png new file mode 100644 index 00000000..b8902721 Binary files /dev/null and b/assets/readme/widescreen-2p-machine-select.png differ diff --git a/assets/readme/widescreen-ending.png b/assets/readme/widescreen-ending.png new file mode 100644 index 00000000..85b86f8e Binary files /dev/null and b/assets/readme/widescreen-ending.png differ diff --git a/assets/readme/widescreen-machine-select.png b/assets/readme/widescreen-machine-select.png new file mode 100644 index 00000000..6cac0bdf Binary files /dev/null and b/assets/readme/widescreen-machine-select.png differ diff --git a/assets/readme/widescreen-match-1p.png b/assets/readme/widescreen-match-1p.png new file mode 100644 index 00000000..184009e4 Binary files /dev/null and b/assets/readme/widescreen-match-1p.png differ diff --git a/assets/readme/widescreen-match.png b/assets/readme/widescreen-match.png new file mode 100644 index 00000000..719da627 Binary files /dev/null and b/assets/readme/widescreen-match.png differ diff --git a/assets/readme/widescreen-menu.png b/assets/readme/widescreen-menu.png new file mode 100644 index 00000000..e2eb59db Binary files /dev/null and b/assets/readme/widescreen-menu.png differ diff --git a/assets/readme/widescreen-next-enemy.png b/assets/readme/widescreen-next-enemy.png new file mode 100644 index 00000000..8d8022db Binary files /dev/null and b/assets/readme/widescreen-next-enemy.png differ diff --git a/assets/readme/widescreen-split-screen.png b/assets/readme/widescreen-split-screen.png new file mode 100644 index 00000000..9441b340 Binary files /dev/null and b/assets/readme/widescreen-split-screen.png differ diff --git a/assets/readme/widescreen-title.png b/assets/readme/widescreen-title.png new file mode 100644 index 00000000..908e5fe9 Binary files /dev/null and b/assets/readme/widescreen-title.png differ diff --git a/docs/BOSSES.md b/docs/BOSSES.md new file mode 100644 index 00000000..d9f2ccb4 --- /dev/null +++ b/docs/BOSSES.md @@ -0,0 +1,372 @@ +# Playable bosses + +Jaguarandi and Z-Gradt as player machines in a one-player game. You earn +them by beating them, then pick them on the machine select like the +eight. The patch is **Playable bosses** in the patcher's extras, unticked +by default. **Pre-unlock the bosses** beside it skips the earning. The +source is [`asm/bosses.asm`](../asm/bosses.asm). This page says what the +patch does, then how. + +## For players + +### Unlocking + +- **Jaguarandi** - beat Jaguarandi on **Very Hard** without losing a match + earlier in the run. +- **Z-Gradt** - with Jaguarandi already unlocked, finish the game on Very + Hard with any machine, without losing a match. + +A continue counts as a lost match. Changing the difficulty spoils the run. +Only a new game from the title starts a clean one. + +Each unlock gets a screen of its own. The boss turns on the left of a +black screen. YOU UNLOCKED and its name stand on the right in the select's +lettering, and the title jingle plays. PRESS BUTTON TO CONTINUE flashes at +the bottom after five seconds. Only a fresh press moves on; a button held +from the fight does not skip it. The press is answered with the select's +cursor sound, and the boss leaves the screen with it. + +Jaguarandi's screen comes straight after it falls, before the Player Data +Report. Z-Gradt's comes after the credits, before the initials. The game +then carries on as it would have. + +Unlocks are kept in `bosses.bin` beside the game. They survive restarts and +re-patching. **Pre-unlock the bosses** writes the file with both unlocked. +It never takes progress away. **Restore original** leaves the file alone, +since the unpatched game never reads it. + +### The machine select + +- An unlocked boss stands in the row after Raiden: Jaguarandi first, then + Z-Gradt raised on the hangar's lip. A locked boss is not there at all. +- Each boss has a portrait of its own in the row along the bottom, after + Raiden's. The portraits are pixel art drawn after SEGA's renders of the + two machines, Z-Gradt's mirrored, in the eight's style: framed and + backed the same way, at the same 48 by 64. A locked boss's place stays + blank. +- The portraits, the 1P/2P marks and the red frame move left to make + room: four columns with Jaguarandi, seven with both. The row stays on a + 4:3 screen. With nothing unlocked the select is exactly the original. +- The Quick VR Select, the game's option, has the bosses too. It gets the + same row, cursor and colours, and a boss's name and weapons where it + writes the eight's. +- The countdown runs 20 seconds longer with a boss unlocked. The walk to + the end of the row and the extra colours need the time. +- The bosses are lit in their own colours like the eight. The widescreen + hangar fades them at the right edge as it does the others. +- **Machine Color Select**: up and down on a boss cycle it through its + own colours and the eight colours of each of the others. It can wear any + of them. +- Each boss launches from the hangar. Jaguarandi takes Raiden's launch + animation. Z-Gradt lifts off the lip and out through the tunnel. The + water, the splash and every machine's thrust keep their own colours + throughout. + +### In the game + +- Both bosses play as player machines on every stage, including Z-Gradt + against Z-Gradt on the last one. +- The KO replay and the win and lose shots pull back to fit a boss's + size. The replay's never pulls downwards. Jaguarandi grows through its + win pose, as the game has it, so its win shots stop 250 units out where + the game's stop at 15. On a small arena the win shots that need floor + under the camera try a turn at the boss's distance, then four turns + each a quarter nearer the usual, then the usual. +- The bosses' chase camera is the game's own, with its modes, its glide + between them and its pan as the opponent jumps. It stands further out: + two and a half times as far for Z-Gradt, half as far again for + Jaguarandi. Neither closes in as the opponent comes near. Z-Gradt's + never levels out below its high angle as it turns on the spot, and it + turns with Z-Gradt. +- Jaguarandi's red segments, on its legs and back, stay in view. The + game's own draw let the faces beside them cover them at some depths, so + they flickered as it walked and went out as it turned. +- Z-Gradt's fly-in starts part of the way in rather than beyond the + arena's backdrop. Indoors (Deathtrap, the Spaceport, the Secret Base) + it only drops into place. Outdoors it comes in from 784 units out, and + nearer still over the Green Hills. GET READY's count waits for it to + land before the round starts, 600 frames at the most. On the last + stage the CPU's Z-Gradt flies in instead, and the round starts as it + always did. +- Z-Gradt's super laser fires on Dash. On the twin-stick profile either + turbo button does. The game had it on Guard, both levers pulled in. + Z-Gradt has no dash, so the button was free, and Guard now does nothing + on it. It fires on the press, not while the button is held. +- The laser has a gauge of its own: a fourth strip under the three, named + CANNON (the hangar's LASER CANNON). While the cannon deploys and charges + the bar is drawn as the game draws a close-combat weapon's bar with the + opponent in reach: full, in its third colour, pulsing in height. The + beam empties it. It climbs back as the game's bars refill, and is blue + again as the cannon finishes folding away. Dash held on the empty bar + gets what a weapon's button gets on an empty bar: CHARGING over the + name, the refusal sound once, and the bar swollen until half a second + after the button is up. +- Z-Gradt's three strips stay full, since the game does not count its + shots. While a weapon's button is held its strip turns to the live + colour, so a press has a tell. +- A boss keeps its colours through a continue. +- The KO replay plays Z-Gradt's super laser as it was fired, its beams + and particles in step with the pose. A laser KO goes on to the win or + lose screen, pose and call included, as any other KO does. +- Z-Gradt has no jump. The jump, both levers out or the jump key, turns it + to face the opponent instead: a half turn in 64 frames, with the camera. + Not while its super laser is out. +- Z-Gradt moves on the arena it is on. It stops at the arena's edge and at + the walls and obstacles the eight stop at, and its height follows the + ground. On the moon gate it keeps the game's own bounds, a square 280 + units each way from the middle. +- Z-Gradt's laser turns the right Z-Gradt gold when both are on the field. + A Z-Gradt that falls darkens alone; the player's keeps the colours it + was given. +- The Player Data Report after stage 5 turns the boss itself: Jaguarandi + in its select pose, as on its unlock screen, and Z-Gradt standing. +- The scoreboard names them Z-GRADT and JAGUARANDI. The game's own table + has them as Z-GRAT and JAGARANDI, which no one saw while they could not + be played. The attract's TODAY'S TOP OF WINS list takes the name from + the machine's model header, which had Z-Gradt as ZIG-RAHT. It reads + Z-GRADT too. +- The ending plays for a boss. Jaguarandi fires its own weapon at the moon + gate, and Z-Gradt its own charge and laser. Then the text and the + button wait follow. The staff roll is skipped, since its battle-damaged + model is one the bosses do not have. + +### Limits + +- One player only, by design. The bosses are far stronger than the eight, + so two-player and internet play keep the select to the eight for a fair + fight. Nothing here runs there. The two-player hangar is the game's own + lineup. +- The bosses' weapons have no ammo to speak of, as the game's own code has + them. Z-Gradt's shots are made outside the charge counting, and + Jaguarandi's refill faster than it can fire. +- `bosses.bin` is written beside the game when a boss is unlocked. Where + the folder cannot be written, the unlock screen still shows but the + unlock is lost at exit. +- The bosses' model files, `RB_jag.bin` and `RB_zig.bin`, are read into + blocks of the patch's own when the select first draws each. If a read + fails, that boss is drawn from whatever the model pool holds in its + slot until a fight loads it. + +## How it works + +The game already knows the bosses as fight objects. The initials demo +fights 8 against 9, so the objects work as a player's. What does not work +is everything the game only ever did with the eight: tables eight rows +long, loaders that send ids above 7 elsewhere, screens framed for their +size. `asm/bosses.asm` is one hook per such place. + +The game keeps a copy of its fight machine per player. A, at +`0x1ae0xxxx`, is player 1's and B, at `0x1ef8xxxx`, player 2's; the +letters are the ones `docs/HIRES.md` gives their renderers. B's tick +(`0x40f528`) is only called from the frame loop's two-player branch, so a +one-player game never runs it. Every hook is A's. Whether the player is a +boss is one flag, `boss`, which confirm sets in one player only. The +sections below follow the file. + +The blob has a section of its own, `.vobs`. The patcher appends it only +when the box is ticked, so unticked it leaves the executable as the other +patches alone would. The blob's buffers are gathered at its end: the +bosses' motions, the model and AI copies, the replay's ring, the saved +palettes and the rest, 263,217 bytes. The file carries the blob only as +far as its last byte that is not zero, 16,583 bytes. The rest is the +section's virtual size, which Windows zeroes at load (`OWN_SECTIONS`). + +### The select's row + +The select is a scene script: the camera, the eight 20 apart, the hangar. +The patch builds a longer copy with two records after Raiden's and points +the game at it. It extends the tables that turn a cursor into a machine +and an object into a machine to ten, and raises the cursor's limit by the +unlock level (`selmax_a`). The camera's step is 30 to Jaguarandi and 98 on +to Z-Gradt, which also rises onto the lip (`selstep_*`). + +The bosses' models are their fight models posed by the select's motions. +Jaguarandi is posed through Raiden's, with its head put back on. Z-Gradt +stands in its stance's first frame. Each file is read once into a block +of its own (`sel_loadrb`). The game's model slot points there only while +the boss is drawn (`sel_slotsin`, `sel_slotsout`), and the game's own +pointer is kept and put back. The files are not appended to the game's +8 MB model pool, because after a full game that runs into the C runtime's +heap. The game's own copy of the file, present on a continue's select, is +never drawn here. `selcol` turns the colour words of the polygons it +draws to the select's rows and never back, and the game fights on with +its copy. + +The portraits are `assets/portrait_jaguarandi.png` and +`assets/portrait_z-gradt.png`, 48 by 64 and framed like the eight's. +`tools/portraits.py` bakes them into the patcher as the select's 16-bit +colour. Pure black, the tiles' transparent colour, becomes the eight's +near-black backing. The patcher writes them into `escrgame.bin`, backed +up first, in the 80 empty tiles after two of the eight's portraits +(`BOSS_ICON_TILES`). `selrow_make` builds the row with them on entering +the select, blank for a boss still locked. + +The row's portraits, the marks and the frame are shifted per unlock level +(`selshift`). The frame sprite reads its x from two doubles in the game's +read-only data (`BS_FRX`), so the patcher makes that section writable and +the select sets them. The countdown's start is `seltime`. + +### Colours on the select + +How the game picks a palette: + +- Palette RAM (`0x1cb5500`) is three planes of 32 rows of 256 entries. A + polygon names its row per plane through its colour word in the mesh + (`+6`). The word's top ten bits index a table of colours (`0x66c2c8`), + and each colour byte's top five bits are that plane's row. The raster + reads the word from the mesh later in the frame, not when the polygon + is queued. +- The bosses' meshes name the greys of rows 1 and 3 (5 and 7 as the + CPU's). Those are the rows the select fills with the machine under the + cursor and its neighbours, 1 to 11 as the cursor moves. A boss drawn + through them takes the colours of whatever the cursor is on, or none. +- The odd rows from 13 are set once at boot. 13, 17 and 19 are the launch + thrust. The select rewrites 21 for a frame on each move and 23 as it + opens. The launch water reads 21 and 25, and the fight re-animates 21 to + 29. + +So on the select each boss borrows two rows the select itself leaves +alone: Jaguarandi 21 and 25, Z-Gradt 29 and 15 (`sel_bslots`). Their own +contents are kept when the select opens. They are put back the moment a +launch starts and when the select ends (`selpalguard`, `selpalback`). The +boss's palettes go in each tick and again as it is drawn, after the +game's one-frame write to 21 (`seljagpal`, `seldrawpal`). The entries a +palette load leaves untouched are copied from row 1, since the widescreen +fade reads them as the boss goes dark (`selrest`). While a boss is drawn, +each of its polygons queued that names rows 1, 3, 5 or 7, or another boss +row, is turned in its copy of the mesh to the table's grey of its own row +(`selremap`, `selcol`). + +A launch shows on the scene objects. Every machine's goes to 1 as the row +moves aside, the launching one's to 2, and the cursor field turns into +the object's number. A launching boss is drawn through rows 1 and 3, +which the game leaves alone on a boss, so all four borrowed rows are the +game's again for the water. + +The widescreen hangar shades a machine by how far right of the camera it +is, black past 28.43, a machine and a half at the eight's spacing. +`selfade` recomputes that shade for a boss, counting each gap between it +and the camera as one of the eight's 20. `selcull_a` draws a boss out to +where that count reaches 28.43: 38.43 for Jaguarandi, 110.65 for Z-Gradt. +So each comes into view black, as the eight do. The camera's place is +read where the hangar reads it (`BS_SELCAM`): 0xac8 past the scene's +objects on three builds, 0xc58 on the Japanese rerelease. + +### Unlocking + +`unl_tick` follows the run. It is clean at the start of a game. A +difficulty other than Very Hard, two players or a lost match spoils it +(`unl_lost`, at the game's own count). Beating Jaguarandi clean replaces +the report's `mov [state], 0x1c` with the unlock (`unl_jag`). A clean +final win replaces the initials' `mov [state], 0x16` (`unl_z`). The +unlock screen is the report's own state, 0x1e, driven by `unl_logic` in +place of its handler. The turning model is the report's (`model_ra` with +the CPU's standing copy). The text is the report's big font. The name is +the select's logo tiles carried over (`unl_grab`, `unl_place`). The +palettes are saved and given back whole. + +Z-Gradt's screen comes after the credits, which load the dock's scene and +texture bank. The name entry's arena, glowing orbs included, is a snapshot +taken before and put back after (`unl_scnsave`, `unl_scnback`), and the +texture bank the fights had loaded is reloaded. + +### Elsewhere in the game + +- **Palettes** - the loader (`0x4f358b`; `0x4c2026` is the other copy's) + sends ids above 7 to a fixed table. For a player's boss it gives the + colour pair the boss was given on the select instead, from the side its + player's machine uses. +- **PLAYER DATA** - the report's turntable reads per-machine tables only + the eight have rows in. A boss is drawn by its fight object, or its + select pose for Jaguarandi, from a standing copy taken at the start of + its last round. Everything the draw touches is put back. +- **Round animations, the ending, Z-Gradt's camera, Z-Gradt against + Z-Gradt, Z-Gradt's gold, the replay and the win shots** - each is + rerouted for ids 8 and 9, as its section in the source explains. +- **The player's Z-Gradt** - its fly-in starts by the arena loaded + (`zflyin_a`, `zf_start`). GET READY's count is held at its end till it + lands (`zready_a`). Its facing goes to the chase camera each frame. The + jump turns the facing to the CPU at the CPU's own aim (`zlock`), and + Z-Gradt's own code turns its model with it. +- **Z-Gradt's floor** - its moves ask `zfloor_a` where the ground is at + the place they go. On the moon gate that is the game's own box + (`BS_ZBOXA`); elsewhere it is the arena's floor as the eight read it + (`BS_FLOORA`). A wall comes back as the query gives it. A rise over 4 + units above the floor under it comes back as a wall facing the way it + moves. A smaller rise comes back as its height now plus the rise, so + it never sticks on a floor it landed below. +- **Z-Gradt's super laser** - the trigger in its tick reads the guard + gesture's byte, 0xff once both levers have been held in. For the + player's it reads the two turbo bytes instead (`zfire_a`). They are + 0xff on the frame a turbo goes down, and the Dash bind sets both. +- **The KO replay** - the game copies both objects into a ring of 30 + slots every fourth frame. The replay rewinds them from it and runs the + recorded levers on. Z-Gradt's laser keeps its state in the AI globals, + outside the object, so a rewound object was behind its laser. `zring_a` + keeps those globals, the player's bank and the lock-on in a ring of its + own, filled and read in step with the game's, at the twelve places + object A is copied to or from the ring. +- **Z-Gradt's laser gauge** - the HUD's three weapon strips are drawn by + one routine from the HUD pass. Each is a bar quad on the matrix scaled + by its fill, with its name in tiles. `zgauge_a`, at that routine's end, + stands a fourth at the middle strip's column one row down. It is filled + from the laser's state as a strip fills from its weapon's heat word. +- **How a strip fills** - a weapon's shot adds its cost to the heat word + on the frame its motion launches the shot. The heat runs down one a + frame. The bar is the heat's shortfall from the weapon's maximum in + whole percent, and the weapon is ready while a shot's cost still fits. + The laser's shot launches at its beam, state 0x104. Its cost is the + rest of the cycle, 261 frames to idle, so the bar is the frames since + the beam as a percent, red until idle. Through the deploy and the + charge it is drawn as a strip whose ready byte has bit 2, a + close-combat weapon with the opponent in reach: full, in the third + material, its height 6 plus 3 sin (frame << 12) in place of 5, and + ready. +- **The laser's button** - while both turbo bytes are down with the bar + not ready, the gauge puts the strips' CHARGING block over the name + through the game's own routine for the three. It plays the refusal + sound once per hold and swells the bar for thirty frames, cleared the + moment the laser is ready. With the button up it clears the block and + prints the name. +- **Z-Gradt's strips** - `zbar_ra`, `zbar_la` and `zbar_ba` stand in + place of each strip's push of the ready material before its draw. They + push the live material instead while the weapon's button byte (+0x138, + +0x139, +0x13a; nonzero while the button is down) is set on the + player's Z-Gradt. +- **Jaguarandi's red segments** - the renderer draws a frame's polygons + nearest first, and each keeps the pixels it covers. The key is a + polygon's nearest vertex's depth, in buckets 1/256th of the depth wide; + within a bucket the polygon queued later is drawn first. The segments + are the model's luminous light group, each in the plane of a face of a + neighbouring part, and the two swap buckets as the legs move. `jlum_a`, + at the mesh draw's store of the key, moves a luminous polygon one + bucket nearer when the polygon lies in Jaguarandi's file. The file is + found through the loader's slot table wherever it is, the select's own + copy included. The eight use the group too and are left alone. +- **The Quick VR Select** - its own cursor limit, colour select and hiding + before a launch go to the hangar's hooks. Its texts for a boss go to + `selqinfo_a`, over the ones it writes for no machine. +- **The 1P and 2P marks** - the row they sit on is cleared before they + are drawn, 62 tiles from its start. With the row shifted, the clear + starts the shift earlier and goes that much further (`selclr_a`). + Without that, a mark on the first portrait stayed. +- **Z-Gradt's death** - it darkens through palette events 0x401 to 0x43f, + which the handler takes to be the CPU's. The player's are passed over + (`zdark_a`, `zfade_a`). +- **Z-Gradt's launch flames** - Raiden's booster meshes come from + Raiden's fight model, which the select loads only when the cursor + passes Raiden. After a continue the cursor starts on Z-Gradt, so the + launch loads the file as the select would (`BS_LOADFILE`). + +## Testing it + +- `bosses.bin` beside the game: delete it to start locked, or write the + dword 1 or 2 to start part or fully unlocked. +- `python3 tools/selftest.py v_on.exe` checks every site and 437 + combinations of patches, including the two boss boxes with and without + each other. `python3 tools/portraittest.py` on the game folder reads + the portraits back out of `escrgame.bin`. `tools/check.py` runs both. +- The per-frame tick runs from the loop's idle call. The loop's message + check (`0x5c6783`) skips the call on a frame with F10, F3 or Alt + queued. The unlock screen's state is cleared only by its own button + press. diff --git a/docs/DEVELOPING.md b/docs/DEVELOPING.md index a9543beb..806e566c 100644 --- a/docs/DEVELOPING.md +++ b/docs/DEVELOPING.md @@ -48,16 +48,19 @@ are committed as `net/dpctrl.dll` and `input/vontanita.dll`. regenerates `UI_REFS` in `tools/uibuild.py` and drives the build-mapping tools (`vomap`, `votrans`, `hiresport`); `python3-unicorn` runs the resolution blob in the `uiemu` check; the `ui` check compares a -fingerprint only where nasm is absent. +fingerprint only where nasm is absent. Pillow bakes the bosses' portraits +(`tools/portraits.py`) and is what the `portraits` check compares with; +without it that check passes with a note. xvfb is the display the `gui` check needs; without it that check skips itself and says so. Versions, as measured rather than promised: nasm 2.14.02, 2.15.05, 2.16.01 through 2.16.03 and 3.02 all assemble `asm/ui.asm` to the -committed bytes - the one construct where 3.x changed its output, the -prefix order on `rep stosw`, is pinned in the source - and the full -`asm` check is green under 2.16.01 and 3.02. Older nasm is untested. +committed bytes - the constructs where 3.x changed its output, the +prefix order on `rep stosw` and `rep movsw` and `movsx eax, ax` shortened +to `cwde`, are pinned in `asm/ui.asm` and `asm/bosses.asm` - and the +full `asm` check is green under 2.16.01 and 3.02. Older nasm is untested. capstone 4.0.2 and 5.0.7 regenerate identical `UI_REFS`. pyflakes and python carry no floor anyone has hit. @@ -80,6 +83,8 @@ python3 input/build.py # only if you touched input/ - rebuilds the he python3 tools/uibuild.py # only if you touched asm/ui.asm - the resolution blob; # then the other builds' tables and the pinned # MD5s: HIRES.md, Rebuilding +python3 tools/portraits.py # only if you touched assets/portrait_*.png - the + # bosses' select portraits (needs Pillow) python3 tools/check.py # the checks CI runs, in two seconds python3 v-on-patcher.py # does the window still open? @@ -126,6 +131,7 @@ record any unavailable OEM/Japanese-original game checks as untested. | `raphnet` | device identities, exhaustive DC/Saturn button decoding, axis thresholds, Start claims, Pause and emitted retail/JPRE integration | | `custom` | twelve-slot remapping, independent player layouts, INI persistence and editor behavior | | `package` | generated ZIP helper paths, exact DLL bytes, real packaged-script discovery, and missing/misplaced/stale helper rejection; does not execute Windows | +| `portraits` | `portraits.py --check`: the bosses' select portraits in `v-on-patcher.py` are what `assets/portrait_*.png` bake to. Without Pillow it says so and passes, having tested nothing; CI has Pillow | | `disc` | `disctest.py`: the disc reader, on ISO9660 images the test builds itself - one per sector layout, plus a cue that names the wrong one. Extraction is byte-exact, the `ssp.ini` rules give the retail and OEM file lists, and every refusal names what is wrong. Needs no game and no disc, so CI runs it | | `gui` | `guitest.py`: the window, opened under xvfb and driven without its loop - which button is offered for which source, that a copy holds both down until it finishes, and that the two columns end level whatever is open. None of these raise on their own, so each asserts the property. Needs a display; with none it skips and prints a note rather than passing quietly | | `lint` | pyflakes | @@ -133,6 +139,7 @@ record any unavailable OEM/Japanese-original game checks as untested. | `tree` | nothing regenerated was left uncommitted. Skipped outside CI, where it would fail on every edit in progress | | `offsets` | `selftest.py`: every `original` column against a real file, hundreds of patch combinations applied, and the fully patched MD5, on whichever build the file is | | `banner` | `bannertest.py`: the title prompt decodes back to the bitmap it was written from, and both files restore byte for byte, on whichever build the folder holds | +| `portrait` | `portraittest.py`: the bosses' select portraits read back out of `escrgame.bin` from the slots the blob's row builder names, both files restore byte for byte, the patch alone writes no `bosses.bin`, and unticked it appends no section, on whichever build the folder holds | | `credit` | `credittest.py`: the credit line recomposes out of the patched roll files, and both restore byte for byte. The line is spread over three files that have to agree - the block list in the executable, the cells in `scrstfmp.bin`, the tiles in `scrstfcg.bin` - so it patches a copy, walks the block list the way `0x448d39` does, expands the cells back through the tile sheet and compares the pixels against the bitmap the patcher started from | | `uiemu` | `uiemu.py`: the resolution blob run under Unicorn on the retail exe, patched in memory at 1080p. Checks the plane B walker with a photo block in the ring, the HUD spread's 2D and polygon positions, the pre-fill, and the layouts' insets and scales. Needs nasm and python3-unicorn, and says so when it has neither | @@ -192,11 +199,14 @@ python3 tools/assets.py ## Where the blobs live -Every blob but two is in the annex: a section, `.vojp`, appended before +Every blob but three is in the annex: a section, `.vojp`, appended before any patch is written, executable, and filled through the site table like any other site. Where it lands is fixed by the file's own headers, so its addresses are known at import and nothing is relinked at apply time. The -two exceptions are places the game itself reaches - the F7 device list's +bosses blob is too big for it and gets a section of its own, `.vobs`, +appended after the annex only when its box is ticked (`OWN_SECTIONS`); +its place follows from the annex's, so it links at import as well. The +other two exceptions are places the game itself reaches - the F7 device list's own run in `.data`, and the levers routine written straight after the XInput routine - and those are the `caves` table of each `Build`. @@ -393,7 +403,11 @@ feed each other. The README's *Virus warnings* section tells users how to allow it in Defender meanwhile. `--generate-notes` writes the release body from commit subjects, which for a -squashed history is close to useless. Replace it once CI is green: +squashed history is close to useless. Replace it once CI is green: the +logo, then sections named for what their bullets are (*Added* first, +*Changed* and *Fixed* when there is something for them), in plain words, +saying only what has been seen. Requirements and known issues stay in the +README. ```bash gh release edit v0.8.4 --notes-file notes.md @@ -414,6 +428,9 @@ well-formed and wrong on one build only: - a match to the win screen, and the replay after it - the F5, F7 and F11 dialogs, and a deadzone edit that survives a restart - the ending credits and the initials screen after them +- with **Playable bosses** on, a game as each boss: the select, a match + to the win screen and its replay, a continue, and the unlock screens + with `bosses.bin` deleted first - the pad's soft reset, from a match and from a two-player match, since it runs the game's own teardown from wherever you are - one matchcode match against a second machine, direct and forced through diff --git a/docs/MAP.md b/docs/MAP.md index 00e6a549..fd55139e 100644 --- a/docs/MAP.md +++ b/docs/MAP.md @@ -15,9 +15,10 @@ table (NOTES.md, *The builds*). | `asm/ui.asm` | the widescreen blob, built separately by `tools/uibuild.py` | | `input/` | native controller helper sources, mapping headers and committed `vontanita.dll` | | `net/` | `dpctrl.c` the netplay DLL, `rendezvous.py` the matchcode server | -| `tools/` | the checks (`check.py` runs them all), the generators (`uibuild`, `hiresport`, `assets`, `map`), the by-hand tools, `bundle.py`, which assembles the Windows release's `_internal/`, and `package.py`, which CI uses to zip a build into the two release zips | +| `tools/` | the checks (`check.py` runs them all), the generators (`uibuild`, `hiresport`, `assets`, `portraits`, `map`), the by-hand tools, `bundle.py`, which assembles the Windows release's `_internal/`, and `package.py`, which CI uses to zip a build into the two release zips | | `launcher/` | the Windows release's `v-on-patcher.exe`: `launcher.c` runs `_internal\pythonw.exe _internal\v-on-patcher.py` and reports a crash, `build.bat` compiles it with MSVC, and `v-on-patcher.exe`, when present, is the signed copy every release ships | | `maps/` | per-build function maps and port tables, from `tools/maps.sh` | +| `assets/` | art baked into the script: the logo and icon by `tools/assets.py`, the bosses' select portraits (`portrait_*.png`) by `tools/portraits.py`; `icon.ico` for the launcher; `readme/`, the README's pictures | | `docs/` | this and the other documents; `docs/README.md` is the index | | `.github/workflows/build.yml` | CI: the checks, the two zips, signing, the release | @@ -31,19 +32,19 @@ is stale, so the line numbers are current. | Lines | Region | Starts with | | --- | --- | --- | | 1–40 | header, imports, PE helpers | `#!/usr/bin/env python3` | -| 41–2830 | widescreen: the layouts, `UI_CODE`, the port tables, the site builder | `# The resolution patch: the` | -| 2831–2979 | widescreen apply: `hires_install`, section append, F4 table | `def hires_install(buf, width` | -| 2980–3058 | disc images table, `Build` class, annex order | `DISC_IMAGES = {` | -| 3059–3798 | the four builds: symbols, caves, site maps | `RETAIL = Build('English reta` | -| 3799–4700 | generated site maps for the other three builds (`tools/buildsites.py`) | `# SITES JPRE BEGIN` | -| 4701–6157 | the blobs, `BLOBS`, and `link()` | `BLOBS = {` | -| 6158–6567 | banner and credit bitmaps, tile expansion | `LEVERS_CODE = link('LEVERS',` | -| 6568–7346 | the patch table: `FEATURES`, `BY_KEY`, labels, tips, apply order | `FEATURES = [` | -| 7347–8250 | ripping (`RAW = 2352`) and installing (`LOGICAL = 2048`) | `# --- ripping --------------` | -| 8251–9077 | netplay setup, `SYNC_SITES`, cnc-ddraw, CD audio | `# --- netplay --------------` | -| 9078–9565 | `Patcher`: reading a file, applying, restoring | `class Patcher:` | -| 9566–10203 | the logo and icon (`tools/assets.py`), then the window strings | `# ASSETS BLOB BEGIN - tools/` | -| 10204–12235 | the window (`run_tk`), the CLI, `main` | `def run_tk():` | +| 41–2831 | widescreen: the layouts, `UI_CODE`, the port tables, the site builder | `# The resolution patch: the` | +| 2832–2983 | widescreen apply: `hires_install`, section append, F4 table | `def hires_install(buf, width` | +| 2984–3080 | disc images table, `Build` class, annex order | `DISC_IMAGES = {` | +| 3081–4675 | the four builds: symbols, caves, site maps | `RETAIL = Build('English reta` | +| 4676–6095 | generated site maps for the other three builds (`tools/buildsites.py`) | `# SITES JPRE BEGIN` | +| 6096–18113 | the blobs, `BLOBS`, and `link()` | `BLOBS = {` | +| 18114–18892 | banner and credit bitmaps, tile expansion | `LEVERS_CODE = link('LEVERS',` | +| 18893–19991 | the patch table: `FEATURES`, `BY_KEY`, labels, tips, apply order | `FEATURES = [` | +| 19992–20895 | ripping (`RAW = 2352`) and installing (`LOGICAL = 2048`) | `# --- ripping --------------` | +| 20896–21744 | netplay setup, `SYNC_SITES`, cnc-ddraw, CD audio | `# --- netplay --------------` | +| 21745–22273 | `Patcher`: reading a file, applying, restoring | `class Patcher:` | +| 22274–22911 | the logo and icon (`tools/assets.py`), then the window strings | `# ASSETS BLOB BEGIN - tools/` | +| 22912–24965 | the window (`run_tk`), the CLI, `main` | `def run_tk():` | ## 3. `v_on.exe` @@ -135,14 +136,15 @@ region around each site. Everything the patcher writes outside the sites above goes into sections appended after `.reloc`. Addresses are for every patch on at 1080p; the -first is there on every run, the other three only with their patch. +first is there on every run, the other four only with their patch. | Section | VA | Size | Appended by | Holds | | --- | --- | --- | --- | --- | -| `.vojp` | `0x36b5000` | `0x1400` | every run | the annex: every blob but the two below, in `ANNEX_BLOBS` order | -| `.voxt` | `0x36b7000` | `0x40c` | Disable menu bar | the F11 dialog template, then `voxt.asm` | -| `.vocd` | `0x36b8000` | `0xbac` | No disc required | `vocd.asm` and its track table | -| `.vohr` | `0x36b9000` | `0x4f0830` | Native widescreen | `UI_CODE`, the mask spans, the row table, the polygon pool, then the off-screen canvas (virtual, not on disk) | +| `.vojp` | `0x36b5000` | `0x1400` | every run | the annex: every blob but the three below, in `ANNEX_BLOBS` order | +| `.vobs` | `0x36b7000` | `0x444f8` | Playable bosses | `bosses.asm`, its code and tables, then its buffers (virtual, not on disk) | +| `.voxt` | `0x36fc000` | `0x40c` | Disable menu bar | the F11 dialog template, then `voxt.asm` | +| `.vocd` | `0x36fd000` | `0xbac` | No disc required | `vocd.asm` and its track table | +| `.vohr` | `0x36fe000` | `0x4f0830` | Native widescreen | `UI_CODE`, the mask spans, the row table, the polygon pool, then the off-screen canvas (virtual, not on disk) | The annex, blob by blob: @@ -188,3 +190,4 @@ within 16 KB of each other. | sound | 5 | `0x458d89`, `0x5719c9`, `0x58a146–0x58a152`, `0x6bcc60` | | movie | 10 | the PE header, `0x4d6cc8`, `0x54e842`, `0x590825`, `0x5c64e7`, `0x6c8878`, the annex | | credits | 5 | `0x5c6500`, `.rdata 0x5fdac8`, `0x6bcd54`, the annex | +| bosses | 173 | 19 runs from `0x404db7` to `0x5e0254`, `.rdata 0x5ff238` and `0x63c1d4–0x63e084` (the bosses' weapon names), `.data 0x6bc208` (the scoreboard's), plus its section | diff --git a/docs/NOTES.md b/docs/NOTES.md index f460a395..1c8e08fe 100644 --- a/docs/NOTES.md +++ b/docs/NOTES.md @@ -28,6 +28,7 @@ replacement rather than a patch, see [net/](../net/). | **Version and credit in the game** | `0x1fcec8`, `0x1fcecc`, `0x2bbb54`, `0x1c5900`, `scrstfcg.bin`, `scrstfmp.bin` | the roll is a list of blocks, 12 bytes each as (flag, width, height) in cells, read from `0x6bcd48` and placed on 51 cells by the flag - `0x448e86` centres, `0x448f54` pushes flush right, and the roll's own text uses the latter where these two use the title's centring; the five blank spacers after the title become five entries carrying the same twenty rows with the lines centred in them, so nothing below moves and the roll keeps its length, the cells go into `scrstfmp.bin` at the same point, and the tiles on the end of `scrstfcg.bin`, whose indices the loader rebases at `0x483d9d`; the loader reads both files to byte counts held at `0x5fdac8` and `0x5fdacc` rather than to their size, so the two constants grow with them; separately, the load before the surface flip is diverted through a stub that prints the version in the corner of the title screen, in the tile font | | **Intro, loading and ending screens** | `0x14dc42`, `0x23f`, `0x2c7678`, `0x18fc25`, `0x0d60c8`, `0x1c58e7` | placement routine calls a stub in the annex, which measures the window through cnc-ddraw's own bypass export and sends a destination rect; loading string's first byte → `NUL`; credits handler's opening write calls a stub that puts the sequence past its last phase once A has been held a second, read from the key buffer slot since the press edges are not maintained in that state; the initials screen's two trigger tests replaced by a stub that adds the same slot; the call before the surface flip diverted through a stub that draws HOLD TO SKIP while the button is down | | **Native widescreen** | about 260 sites across `.text`, `.data` and `.rsrc`, appended `.vohr` section | every 640x480 assumption rewritten for the new size - mode setting, the viewport globals and row maths, the rasterizers' row tables and coverage mask, the projection scale, the polygon pool, the GDI text bounds and fonts, the F5 split labels; the 2D layer redirected through a canvas in the new section and composited back at scale; F4 switches to 1280x720 and back through a site table the blob copies at runtime; the ending letterbox skipped, the roll's edge clipping wired up and the tile planes' row-table overruns bounded, the roll window shifted to enter at the bottom, the strip watermarks floored and the roll's cut moved so the last line leaves; the enemy marker's window and the hangar's widened to the view. Translated onto the other three builds by table | +| **Playable bosses** | `0x1c5b79`, `0x1c5bbb`, two confirm stores (`0x19f8c1`, `0x1a0e84`), the palette loader's `jg` at `0x0f29a5`, 168 more hooks (asm/bosses.asm), `.rdata` made writable for the portrait frame's x, appended `.vobs` section | the 1P select's row extended past Raiden to the unlocked bosses (row, marks, frame and portraits shifted left, the countdown 20 seconds longer), the bosses drawn there lit in palette rows of their own, borrowed and given back; confirm on a boss stores it; the palette loaders give the boss the colour pair it was given; unlocks earned on Very Hard without a lost match, shown on a screen of their own in the report's state and kept in `bosses.bin` (**Pre-unlock the bosses** writes it with both); PLAYER DATA's turning model drawn from the boss's own fight object, the round's animation loads, the ending, the win camera's distance, Z-Gradt's camera and Z-Gradt against Z-Gradt rerouted for ids 8 and 9. See *Playable bosses* below | Bold entries are not part of original VO_Patch. Offsets are the English retail build's, the ones the site table is keyed on; the other builds map @@ -676,10 +677,13 @@ phase machine on `0x1ad0964`: 0 and 1 are the ending cutscene and the mission complete screen, 2 is the roll, anything else falls through to a tail that stops the music and moves on. -The one a finished game reaches is state 32 of the main-game machine -`0x1ef9eb0`, whose draw table is `0x606fa0`; entry 32 is `0x44a523`, a -phase machine on `0xbf073c` that runs the roll through `0x4489d6` in its -phase 2. The title machine's logic table is `0x5ff1c0`. +The second player's machine `0x1ef9eb0` has the same sequence as its +state 32: its draw table is `0x606fa0`, entry 32 is `0x44a523`, a phase +machine on `0xbf073c` that runs the roll through `0x4489d6` in its phase +2. Its tick, `0x40f528`, is only called from the loop's two-player branch +(`0x5c61dd`), so a finished one-player game reaches the roll through the +title machine's `0x20`, as the Credits button does. The title machine's +logic table is `0x5ff1c0`. Both read the same block list and the same map, so the credit line lands in either; only the scenery behind them differs. Skipping is one write, @@ -755,3 +759,34 @@ the JPRE/OEM porting attempt - what broke, what it taught, and the per-build addresses recovered - are in docs/HIRES.md. The other three builds' tables are generated by tools/hiresport.py and spliced into v-on-patcher.py between the PORT TABLES markers. + +### Playable bosses + +Lives in asm/bosses.asm, one blob in a section of its own, `.vobs`. The +patcher appends the section only when the box is ticked. An unticked run +leaves the executable as the other patches alone would. + +The game already runs the bosses as fight objects: the initials demo +fights 8 against 9. The patch is one hook at each place the game only +ever did with the eight. Those are the select's row and its tables (eight +long, made ten), the palette loaders (ids above 7 sent to a fixed table), +the report's turntable, the round's animation loads, the ending, the win +and replay cameras, and Z-Gradt against Z-Gradt on the last stage. On +that stage both share one model header and one block of AI state, so the +player's gets a copy of each. The state is a run of globals from +`BS_BSSA`, `BS_AIDW` dwords long. The seven the patch sets are at the +build's own offsets, `BS_AI*`, because the rerelease lays them out apart +from the other three. + +A one-player game runs on player 1's copy of the fight machine only. The +other copy's tick, `0x40f528`, is called from the loop's two-player +branch alone. So every hook is player 1's. Whether the player is a boss +is one flag, `boss`, set at confirm in one player only. + +The unlocks are kept in `bosses.bin` beside the game, a dword: 0 none, 1 +Jaguarandi, 2 both. The select's portraits of the bosses are tiles in +`escrgame.bin`, written with the title banner's (`BOSS_ICON_TILES`). They +are drawn from assets/portrait_*.png by tools/portraits.py. The select +draws a boss in two palette rows it leaves alone otherwise, saved as it +opens and put back as a launch starts. How the game picks a palette row, +and the rest of the design, is in docs/BOSSES.md. diff --git a/docs/README.md b/docs/README.md index 694cb2b9..ff379236 100644 --- a/docs/README.md +++ b/docs/README.md @@ -15,6 +15,7 @@ other game features; this index covers development. | [DEVELOPING.md](DEVELOPING.md) | setup, the daily loop, the checks and what each catches, adding a blob, a site or a build, netplay development, releasing, signing and the Windows build, troubleshooting | | [NOTES.md](NOTES.md) | how each patch works inside the game: the patch table with every site, the builds and how their offsets map, and a section per patch on what the game does and why the change is what it is | | [TEXT.md](TEXT.md) | the three ways the game draws text, where each string the patcher touches lives, and how the title banner and the credit line are made | +| [BOSSES.md](BOSSES.md) | the playable bosses: what a player gets - unlocking, the select, the game - and how it works, the select's palette rows above all | | [HIRES.md](HIRES.md) | the resolution patch: what it rewrites, the blob, the game's scenes as read off it, the multi-build port and its record, what is queued | | [../asm/README.md](../asm/README.md) | the assembly sources, how they become bytes in the patcher, and a section per file | | [../net/README.md](../net/README.md) | the netplay DLL and the rendezvous server | diff --git a/docs/TEXT.md b/docs/TEXT.md index 8fb2001b..c4b6847c 100644 --- a/docs/TEXT.md +++ b/docs/TEXT.md @@ -32,6 +32,9 @@ nothing: the phrase is stored as 126 tile indices, and the letterforms are | `HOLD TO SKIP` | ending credits | in the patch | GDI. Not the game's - it is carried in `overlay.asm` and drawn at 320, 440 of the picture, computed from the mode size, halved with everything else in low resolution | | `Bindings - %dP side` | bind page title | `0x26c88c` | C string the page's `SetWindowTextA` formats; replaces the stock title so both sides are told apart | | `1P side` → `Actions` | bind page label | `0x60b34e` | UTF-16, inside the dialog template in `.rsrc`. Baked-in text the stock game showed on the 2P pass too; the replacement must stay seven characters | +| `R-WEAPON`, `L-WEAPON`, `RL-WEAPON` → `BAZOOKA`, `TRAP BOMB`, `10 LASER` (Jaguarandi, as the Sega Ages release names them) and `RING BEAM`, `PHALANX`, `F MINE` (Z-Gradt, after the eight's, shortened as the game shortens Bal-Bas-Bow's: a strip fits ten letters) | the HUD's weapon gauges | `0x23b5d4`, `0x23bca4`, `0x23cdb4`, `0x23d484` | tile font, three 16-byte slots in each boss's model header, one header per copy of the game. **Playable bosses** writes them; the select's weapon lines for the bosses are the patch's own strings in `bosses.asm` | +| `ZIG-RAHT` → `Z-GRADT` | the attract's TODAY'S TOP OF WINS list | `0x23cde4`, `0x23d4b4` | tile font, the 16-byte name slot after the weapon slots in each of Z-Gradt's two model headers. **Playable bosses** writes it | +| `Z-GRAT`, `JAGARANDI` → `Z-GRADT`, `JAGUARANDI` | the scoreboard | `0x2bb008` | C strings, 12-byte slots in the game's own name table, misspelt as shipped. **Playable bosses** writes them | The tile font table around `0x285df0` also holds `INSERT COIN(S)`, `TO BE CONTINUED ...`, `MOVE FORWARD`, `DASH BUTTON`, the mech names and @@ -103,6 +106,7 @@ Not text. 42x3 cells of 8x8 pixels, 16bpp RGB565. | Tile indices | `v_on.exe` `0x269b60`, 126 entries of 16 bits | | Artwork | the title artwork, `0x21c000`, 109 tiles of 128 bytes | | Spare tiles | the same file, tile 24845, a run of 115 empty ones - 116 in `escrgame.bin`, but the 116th is a logo tile in `jscrgame.bin` | +| Boss portraits | the same file, tiles `0x1730` and `0x17b0`, 48 each: the empty 80 after two of the eight's select portraits. **Playable bosses** writes them from `assets/portrait_*.png` (`tools/portraits.py`, `BOSS_ICON_TILES`) | The artwork is `escrgame.bin` in the English retail and OEM builds and `jscrgame.bin` in both Japanese builds; the tiles this touches are in diff --git a/docs/project/PLAYABLE-BOSSES.md b/docs/project/PLAYABLE-BOSSES.md new file mode 100644 index 00000000..61bff6ac --- /dev/null +++ b/docs/project/PLAYABLE-BOSSES.md @@ -0,0 +1,60 @@ +# Playable Bosses in Experience + +This isolated development branch integrates upstream single-player Playable +Bosses from `4ecae6237e1fc432c0be2f2b0aeab5303120e444`, based on Experience +`6b22b0dcd490eec8b6a3e953d881649e74ab26cb`. Pairomaniac maintains the original +V-On Patcher; Vortyne implemented Playable Bosses; hyp36rmax maintains the +VO PATCH EX integration and expansions. The [upstream technical record](../BOSSES.md) +retains the implementation details and portrait licensing boundaries. + +## Player behavior + +Playable bosses is optional and off by default. Pre-unlock the bosses is disabled +unless Playable bosses is selected. Jaguarandi and Z-Gradt retain upstream +single-player selection, weapons, movement, camera, progression, replay and ending +behavior; no balance changes or Local VS boss controls are added. Z-Gradt's laser +uses the game's existing Dash/turbo action, independent of the physical controller. + +Unlock progression is stored in `bosses.bin` beside the game. Restore Original +preserves it. Use Restore Original before repatching an existing installation. +A failed integrated Apply restores the previous progression file, including its +absence, together with the rest of the transaction. Successful pre-unlock retains +upstream behavior: write level 2 without reducing existing valid progress. + +## Integration decisions + +| Area | Adaptation / evidence | +|---|---| +| Boss code | Upstream assembly and portrait sources are byte-identical to the pinned commit. CE's larger annex relocates the boss section through the existing linker. | +| Hangar shading | Experience's UI hangar entry is eight bytes later than upstream. All edition symbols use `UI_HANGAR_DRAW`; hardcoded OEM/JPRE offsets would recover the wrong UI base. No boss assembly change is needed. | +| Catalog identity | Preserve bits 0–7: hires, padxinput, nodisc, debugbox, defaults, sound, movie, credits. Append bosses at bit 8 and bossunlock at bit 9. Existing masks 0–255 keep their meanings. | +| Recipe coverage | 1,024 masks per integrated edition, 2,048 total. Pre-unlock has no executable writes, so its recipes reuse the generated executable result with a distinct requested-mask field. The upstream dependency still rejects pre-unlock alone. | +| Source verification | Regenerated sparse recipes remain locked to source hashes, pristine/base/final executable hashes and exact runtime identities. The generator and catalog verifier are included in the source lock. No generated bytes are edited manually. | +| Offline generation | Reuse one private module instance within the generator to avoid recompiling embedded tables for each profile. Generators read these tables; output reconstruction and representative uncached comparisons check this optimization. | +| Apply / Restore | Add `bosses.bin` and its temporary/backup names to failed-Apply snapshots. Progression remains outside installed-runtime ownership, so successful Restore does not remove it. | +| Existing features | Controller, networking and display implementations are retained. Historical whole-image regression comparisons explicitly disable the new optional patches. | + +## Compatibility and acceptance + +VERIFIED identifies source inspection or an automated check, not Windows gameplay. + +| Coverage | Status | +|---|---| +| Four upstream executable identities, fixed boss sites and relocated boss blobs | VERIFIED by source/table tests | +| Retail and Japanese rerelease originals, patch combinations and portrait readback | VERIFIED by local executable tests | +| English alternate/OEM and Japanese original full Apply/gameplay | NEEDS VALIDATION: pristine files unavailable locally | +| Integrated Display catalog | Retail and Japanese rerelease only, as in the Experience baseline | +| Boss-disabled baseline output | VERIFIED by byte comparisons; existing controller and display regressions remain required | +| Boss gameplay, unlock/restart behavior, cameras, replay and endings on Windows | NEEDS VALIDATION | +| Boss camera/model/portrait presentation at 4:3, 16:9, 21:9 and 32:9, dual modes and mixed monitors | NEEDS VALIDATION | +| Local VS boss play | UNSUITABLE for this milestone; upstream selection retains eight machines | + +The private UAT package must be exercised on Windows before integration into +Experience. Check normal patcher launch, option dependency, Apply, game startup, +both boss selections and attacks, earned and pre-unlocked progression, restart, +all existing F5/F7 settings, clean exit and Restore. Retest the original eight +machines with bosses disabled. Boss-specific input tests should include each +lever's dash/turbo, press/hold/release and mixed controller ownership. + +Do not infer acceptance of later gameplay or every monitor combination from +successful patch generation. No public release or Experience merge is part of B01. diff --git a/tools/brandingtest.py b/tools/brandingtest.py index 00cd38d6..00ee5922 100644 --- a/tools/brandingtest.py +++ b/tools/brandingtest.py @@ -11,7 +11,7 @@ from PIL import Image ROOT = Path(__file__).resolve().parents[1] -BASE = '1ec5140c11a12dfe22e64e721bffae85a91b1b6c' +BASE = '6b22b0dcd490eec8b6a3e953d881649e74ab26cb' def original(name): return subprocess.check_output(['git', 'show', BASE + ':' + name], cwd=ROOT) source = (ROOT / 'v-on-patcher.py').read_text() @@ -19,11 +19,13 @@ def original(name): with tempfile.TemporaryDirectory() as td: p = Path(td) / 'v-on-patcher.py'; p.write_bytes(original('v-on-patcher.py')) before = runpy.run_path(str(p)) -for key in ('BLOBS', 'CREDITS', 'LABEL', 'REPO_URL', 'LOGO_CREDIT', 'ICON_PNG', - 'ESSENTIAL', 'EXTRA', 'ABOUT'): +for key in ('LABEL', 'REPO_URL', 'LOGO_CREDIT', 'ICON_PNG', 'ESSENTIAL', 'ABOUT'): assert now[key] == before[key], key +assert {k: v for k, v in now['BLOBS'].items() if k != 'BOSSES'} == before['BLOBS'] +assert now['EXTRA'] == before['EXTRA'] + ('bosses', 'bossunlock') +assert now['BOSSES_AUTHOR'] == 'Vortyne' assert now['BY_KEY']['padxinput'] == before['BY_KEY']['padxinput'] -assert now['BY_KEY']['hires'][1].startswith(before['BY_KEY']['hires'][1] + '\n\n') +assert now['BY_KEY']['hires'][1] == before['BY_KEY']['hires'][1] assert now['TITLE'] == 'V-On Patcher EX' assert now['EX_VERSION'] == '0.1-dev' assert now['PROJECT_URL'] == 'https://github.com/hyp36rmax/VO_PATCH_EX' @@ -32,7 +34,7 @@ def original(name): # Restrict function changes to About, the information popup and no installation code. def funcs(text): return {n.name: ast.dump(n, include_attributes=False) for n in ast.walk(ast.parse(text)) - if isinstance(n, ast.FunctionDef) and n.name in ('apply', 'restore', 'load', 'stamp_version')} + if isinstance(n, ast.FunctionDef) and n.name in ('restore', 'load', 'stamp_version')} assert funcs(source) == funcs(original('v-on-patcher.py').decode()) base = Image.open(ROOT / 'assets/VONPatcherLogo1.png').convert('RGBA') ex = Image.open(ROOT / 'assets/EX-approved.png').convert('RGBA') @@ -55,7 +57,7 @@ def funcs(text): assert 'self._patch_body(parent, ABOUT, None)' in about and 'LOGO_PNG' not in about assert 'wraplength=380' not in about assert 'height=min(height, limit)' in source and 'scrollregion=' in source -print('PASS exact source provenance, original artwork/icon, composition, alpha, embedded size, title/About, appended hires, unchanged XInput, blobs and installation functions') +print('PASS exact source provenance, original artwork/icon, composition, alpha, embedded size, title/About, appended hires, unchanged XInput, existing blobs and Restore/load/version functions') print('NEEDS VALIDATION: physical Windows layout, DPI, popup scrolling and clickable links') from fractions import Fraction diff --git a/tools/check.py b/tools/check.py index 9f2f613e..e7345ff5 100755 --- a/tools/check.py +++ b/tools/check.py @@ -76,6 +76,8 @@ def colours(force=None): [PY, 'net/build.py', '--check'], False, False), ('tanita', 'native Tanita helper and mapping', [PY, 'tools/tanitatest.py'], False, False), + ('portraits', 'assets/portrait_*.png match the committed blob', + [PY, 'tools/portraits.py', '--check'], False, False), ('disc', 'the disc reader, on images built for the test', [PY, 'tools/disctest.py'], False, False), ('controller', 'profile dispatch, ordering and controller input', @@ -110,7 +112,8 @@ def colours(force=None): 'tools/vomap.py', 'tools/votrans.py', 'tools/whereis.py', 'tools/uibuild.py', 'tools/d01test.py', 'tools/geometrytest.py', 'tools/layouttest.py', 'tools/presentationtest.py', 'tools/visualprobe.py', 'tools/visualprobetest.py', 'tools/visualprobe_uat.py', 'tools/clippingtest.py', 'tools/engineering3840.py', 'tools/hiresport.py', 'tools/vonpatcher_hires.py', 'tools/rvload.py', 'tools/uiemu.py', 'tools/portaudit.py', - 'tools/assets.py', 'tools/map.py', 'net/rendezvous.py'], False, + 'tools/assets.py', 'tools/map.py', 'tools/portraits.py', + 'tools/portraittest.py', 'net/rendezvous.py'], False, False), ('map', 'docs/MAP.md region table matches the script', [PY, 'tools/map.py', '--check'], False, False), @@ -128,6 +131,8 @@ def colours(force=None): [PY, 'tools/engineering3840.py', '--private-proof', '{exe}'], True, False, ('retail', 'jpre')), ('clipping', 'verified clip-code edge and mask boundary probes', [PY, 'tools/clippingtest.py', '{exe}'], True, False, ('retail',)), + ('portrait', 'the boss portraits read back as written', + [PY, 'tools/portraittest.py', '{game}'], True, False), ('uiemu', 'the resolution blob run under Unicorn', [PY, 'tools/uiemu.py', '{exe}'], True, False, ('retail',)), ] diff --git a/tools/d01test.py b/tools/d01test.py index 2e491fea..31769195 100644 --- a/tools/d01test.py +++ b/tools/d01test.py @@ -81,10 +81,10 @@ def main(path, width=2560, vp=vp): assert moved_hooks == 26, 'unexpected 1920 hook movement' for offset, value in old._ui_words(1920, 1080).items(): assert vp._ui_words(1920, 1080)[offset] == value - assert old.BLOBS == vp.BLOBS, 'controller/shared annex blobs changed' + assert old.BLOBS == {k:v for k,v in vp.BLOBS.items() if k != 'BOSSES'}, 'controller/shared annex blobs changed' assert old.TANITA_DLL_SHA == vp.TANITA_DLL_SHA assert old.TANITA_SRC_SHA == vp.TANITA_SRC_SHA - keys = set(vp.by_key(build)) - {'hires'} + keys = set(vp.by_key(build)) - {'hires', 'bosses', 'bossunlock'} assert selftest.apply(old, original, keys, old.BUILDS[build.md5]) == selftest.apply(vp, original, keys, build), 'non-display generated image changed' print(build.short, 'CE.2: 1920 values (26 UI hooks move +8), words, blobs, helper pins and non-display image identical') diff --git a/tools/experience/build_catalog.py b/tools/experience/build_catalog.py index 597990da..1e6708cf 100644 --- a/tools/experience/build_catalog.py +++ b/tools/experience/build_catalog.py @@ -1,5 +1,6 @@ """Offline option-complete patch data. No game binaries shipped, no player compiler.""" import argparse,hashlib,json,struct,sys,zipfile +from functools import cache from pathlib import Path sys.path.insert(0,str(Path(__file__).resolve().parents[1]/'dual_display')) import startup_image as si @@ -8,13 +9,30 @@ def sha(data):return hashlib.sha256(data).hexdigest() def main(): p=argparse.ArgumentParser();p.add_argument('output',type=Path);p.add_argument('retail',type=Path);p.add_argument('jpre',type=Path);a=p.parse_args() + # This offline process uses one private patcher instance; generators only + # read its tables. Avoid recompiling the embedded blobs for every profile. + si.mode_profiles.engineering3840.load_private=cache(si.mode_profiles.engineering3840.load_private) out=a.output;out.mkdir(exist_ok=True,parents=True);v=si.mode_profiles.engineering3840.load_private() - keys=list(v.EXTRA+v.ABOUT);index={'keys':keys,'entries':{}};rows=set();count=0 + # Edition-specific translated site tables are also read-only in this process. + v.by_key=cache(v.by_key) + keys=list(v.EXTRA[:7]+v.ABOUT)+['bosses','bossunlock'];index={'keys':keys,'entries':{}};rows=set();count=0 with zipfile.ZipFile(out/'recipes.zip','w',zipfile.ZIP_DEFLATED) as z: for folder in [a.retail,a.jpre]: raw=(folder/'v_on.exe').read_bytes();edition=v.BUILDS[hashlib.md5(raw).hexdigest()] + cached={} for mask in range(1< Display... selects Single, Dual Versus or Dual Mirror, @@ -66,6 +71,15 @@ def main(): diagnostic logs and unrelated files are retained. Modified runtime files are preserved and reported instead of deleted. +Boss acceptance: verify both optional boxes and their dependency. Test the +original eight machines with bosses disabled, then Jaguarandi and Z-Gradt with +bosses enabled. Test earned unlocks separately from pre-unlock; restart and +Restore/reapply must retain progression. Check each lever's Dash/turbo edge for +Z-Gradt's laser, movement, weapons, replay, victory/defeat and ending. Repeat +camera and portrait checks at each supported aspect ratio and in both dual +presentation modes, including mixed monitor sizes. Local VS/online retain eight +machines; this candidate does not add Local VS bosses. + Movie check: use the default enabled movie patch. In Single, confirm a centered 16:9 visible picture without distortion. In Dual Versus and Dual Mirror, confirm Display 1 shows the movie and Display 2 stays black. Let it finish once and skip diff --git a/tools/experience/test_boss_catalog.py b/tools/experience/test_boss_catalog.py new file mode 100644 index 00000000..648de38f --- /dev/null +++ b/tools/experience/test_boss_catalog.py @@ -0,0 +1,27 @@ +"""Preserve every pre-boss recipe identity and verify pre-unlock byte aliases.""" +import json +import lzma +from pathlib import Path +import subprocess +ROOT = Path(__file__).resolve().parents[2] +BASE = '6b22b0dcd490eec8b6a3e953d881649e74ab26cb' +PATH = 'tools/experience/ci/catalog.json.xz' +old = json.loads(lzma.decompress(subprocess.check_output(['git','show',BASE+':'+PATH],cwd=ROOT))) +new = json.loads(lzma.decompress((ROOT/PATH).read_bytes())) +assert new['index']['keys'] == old['index']['keys'] + ['bosses','bossunlock'] +def expanded(data, name): + row = dict(data['recipes'][name]) + row['writes'] = [[offset, data['pool'][i]] for offset,i in row['writes']] + return row +for name in old['recipes']: + assert expanded(old,name) == expanded(new,name), name + assert old['index']['entries'][name] == new['index']['entries'][name], name +old_rows = {line.rstrip(',') for line in old['profiles'].splitlines() if line.startswith('{0x')} +new_rows = {line.rstrip(',') for line in new['profiles'].splitlines() if line.startswith('{0x')} +assert old_rows <= new_rows +for edition in ('retail','jpre'): + for mask in range(512): + original = expanded(new,f'{edition}/{mask}.json') + alias = expanded(new,f'{edition}/{mask+512}.json') + assert dict(original,mask=mask+512) == alias, (edition,mask) +print('PASS all 512 existing recipes and wrapper identities preserved; 1024 pre-unlock aliases verified') diff --git a/tools/experience/test_bosses.py b/tools/experience/test_bosses.py new file mode 100644 index 00000000..68f6a847 --- /dev/null +++ b/tools/experience/test_bosses.py @@ -0,0 +1,48 @@ +"""Upstream fidelity and optional-feature boundaries; no gameplay acceptance claim.""" +from pathlib import Path +import subprocess +import sys +import types +sys.path.insert(0, str(Path(__file__).resolve().parents[1])) +import selftest +ROOT = Path(__file__).resolve().parents[2] +PIN = '4ecae6237e1fc432c0be2f2b0aeab5303120e444' +BASE = '6b22b0dcd490eec8b6a3e953d881649e74ab26cb' +def load(ref): + source = subprocess.check_output(['git', 'show', ref + ':v-on-patcher.py'], cwd=ROOT) + m = types.ModuleType('reference'); m.__file__ = str(ROOT/'v-on-patcher.py') + exec(compile(source, m.__file__, 'exec'), m.__dict__) + return m +v = selftest.load_patcher(); upstream = load(PIN); baseline = load(BASE) +assert v.BLOBS['BOSSES'] == upstream.BLOBS['BOSSES'] +assert v.CREDITS == upstream.CREDITS +assert v.BOSSES_AUTHOR == 'Vortyne' and v.REPO_URL == upstream.REPO_URL +for path in ('asm/bosses.asm', 'assets/portrait_jaguarandi.png', 'assets/portrait_z-gradt.png'): + assert (ROOT/path).read_bytes() == subprocess.check_output(['git','show',PIN+':'+path],cwd=ROOT) +assert v.NEEDS == {'bossunlock':'bosses'} +assert not v.default_state()['bosses'] and not v.default_state()['bossunlock'] +assert set(v.BUILDS) == set(upstream.BUILDS) == set(baseline.BUILDS) +for md5, build in v.BUILDS.items(): + ref = upstream.BUILDS[md5] + expected = upstream.by_key(ref)['bosses'][2] + # CE annex size relocates the entire boss section. The only changed + # game symbol is the verified Experience hangar entry displacement. + for key, value in ref.symbols.items(): + if key != 'BS_HDOFF':assert build.symbols[key] == value, (build.short,key) + assert build.symbols['BS_HDOFF'] == v.UI_HANGAR_DRAW + ref.symbols['BS_HDOFF'] = v.UI_HANGAR_DRAW + ref.annex = build.annex + assert v.link('BOSSES', build) == upstream.link('BOSSES', ref, blobs=v.BLOBS, base=v.cave_va('BOSSES',build)), build.short + actual = v.by_key(build)['bosses'][2] + assert [(int(o),str(b)) for o,b,_ in actual if len(b)<1000] == [(int(o),str(b)) for o,b,_ in expected if len(b)<1000] + print('PASS upstream boss mapping/blob:',build.short,md5) +for folder in sys.argv[1:]: + raw, _ = selftest.pristine(str(Path(folder)/'v_on.exe'), v) + import hashlib + md5 = hashlib.md5(raw).hexdigest() + for wanted in (baseline.default_state(), dict.fromkeys(baseline.BY_KEY, True)): + old, _, skip = baseline.apply_selected(bytearray(raw), wanted, baseline.BUILDS[md5]); assert not skip + new, _, skip = v.apply_selected(bytearray(raw), wanted, v.BUILDS[md5]); assert not skip + assert new == old, 'boss-disabled Experience bytes changed' + print('PASS boss-disabled byte-identical Experience:',folder) +print('PASS upstream assembly, portraits, all four relocated boss blobs/sites, optional defaults and dependency') diff --git a/tools/experience/test_catalog_generation.py b/tools/experience/test_catalog_generation.py new file mode 100644 index 00000000..65d5e4b5 --- /dev/null +++ b/tools/experience/test_catalog_generation.py @@ -0,0 +1,21 @@ +"""Prove module reuse leaves generated profile images unchanged.""" +from functools import cache +from pathlib import Path +import sys +sys.path.insert(0, str(Path(__file__).resolve().parents[1]/'dual_display')) +import startup_image as si +fresh = si.mode_profiles.engineering3840.load_private +for folder in map(Path, sys.argv[1:]): + raw = (folder/'v_on.exe').read_bytes() + v = fresh() + wanted = dict(v.default_state(), bosses=True) + si.mode_profiles.engineering3840.load_private = fresh + uncached, _ = si.build(raw, wanted) + si.mode_profiles.engineering3840.load_private = cache(fresh) + private = si.mode_profiles.engineering3840.load_private() + private.by_key = cache(private.by_key) + shared, _ = si.build(raw, wanted) + again, _ = si.build(raw, wanted) + assert uncached == shared == again, folder + print('PASS fresh/shared/repeated private generator identity:',folder,flush=True) +si.mode_profiles.engineering3840.load_private = fresh diff --git a/tools/experience/test_catalog_identity.py b/tools/experience/test_catalog_identity.py index 5264e01e..5c32f85f 100644 --- a/tools/experience/test_catalog_identity.py +++ b/tools/experience/test_catalog_identity.py @@ -3,7 +3,10 @@ from pathlib import Path sys.path.insert(0,str(Path(__file__).resolve().parents[1]/'dual_display')) import startup_image as s +from functools import cache +s.mode_profiles.engineering3840.load_private=cache(s.mode_profiles.engineering3840.load_private) catalog=Path(sys.argv[1]);v=s.mode_profiles.engineering3840.load_private() +v.by_key=cache(v.by_key) index=json.loads((catalog/'catalog.json').read_text()) rows=[ast.literal_eval(line.rstrip(',').replace('{','[').replace('}',']')) for line in (catalog/'game_profiles.h').read_text().splitlines() if line.startswith('{0x')] assert len({tuple(row[:3]) for row in rows})==len(rows),'ambiguous first-match identity' @@ -15,8 +18,9 @@ def accepted(image,base,stamp,size): with zipfile.ZipFile(catalog/'recipes.zip') as archive: for folder in map(Path,sys.argv[2:]): raw=(folder/'v_on.exe').read_bytes();edition=v.BUILDS[hashlib.md5(raw).hexdigest()] - for mask in range(256): + for mask in range(1 << len(index['keys'])): wanted=dict.fromkeys(v.ESSENTIAL,True);wanted.update({key:bool(mask&(1<> 3) << 11 | (g >> 2) << 5 | b >> 3 + out += (v or GROUND).to_bytes(2, 'little') + return bytes(out) + + +def bake(): + """The block the markers hold, from the PNGs. Returns (block, bytes).""" + from PIL import Image + data = b'' + for name in SOURCES: + image = Image.open(os.path.join(ASSETS, name)).convert('RGB') + if image.size != SIZE: + raise SystemExit('%s is %dx%d, not %dx%d' + % ((name,) + image.size + SIZE)) + data += rgb565(image) + text = data.hex() + lines = [text[i:i + WIDTH] for i in range(0, len(text), WIDTH)] + return (BEGIN + 'BOSS_PORTRAITS = bytes.fromhex(\n' + + '\n'.join(" '%s'" % l for l in lines) + ')\n' + END), data + + +def main(): + check = '--check' in sys.argv + try: + block, data = bake() + except ImportError: + if check: + print('Pillow is not installed, so the portraits were not ' + 'rebaked and nothing was compared: pip install pillow') + return 0 + raise SystemExit('baking needs Pillow: pip install pillow') + with open(PATCHER, encoding='utf-8') as fh: + source = fh.read() + pattern = re.compile(re.escape(BEGIN) + '.*?' + re.escape(END), re.S) + found = pattern.search(source) + if not found: + raise SystemExit('no BOSS PORTRAITS markers in v-on-patcher.py') + if check: + if found.group(0) == block: + print('the committed portraits match assets/portrait_*.png') + return 0 + print('the committed portraits differ from assets/portrait_*.png: ' + 'run python3 tools/portraits.py and commit') + return 1 + source = pattern.sub(lambda _m: block, source, count=1) + with open(PATCHER, 'w', encoding='utf-8', newline='\n') as fh: + fh.write(source) + print('%d portraits, %d bytes -> v-on-patcher.py' + % (len(SOURCES), len(data))) + return 0 + + +if __name__ == '__main__': + sys.exit(main()) diff --git a/tools/portraittest.py b/tools/portraittest.py new file mode 100644 index 00000000..bdb52614 --- /dev/null +++ b/tools/portraittest.py @@ -0,0 +1,144 @@ +#!/usr/bin/env python3 +"""Apply the bosses patch to real game files and read the portraits back. + + python3 tools/portraittest.py /path/to/VIRTUAL-ON + +CI cannot do this - neither v_on.exe nor escrgame.bin is in the repository - +so run it by hand before tagging, the same as bannertest.py. + +The select's portraits of the bosses are tiles the patcher writes into +escrgame.bin (BOSS_ICON_TILES), read by the game through the row the blob +builds. A wrong slot draws another part of the sheet in their place while +every other check passes. So this patches copies of both files, reads the +tiles back from the slots the row names and compares them with the +portraits the patcher started from, and checks the executable carries the +blob's section only when the patch is on. Both files have to restore byte +for byte, and the patch alone must leave bosses.bin unwritten. +""" + +import os +import shutil +import struct +import sys +import tempfile + +HERE = os.path.dirname(os.path.abspath(__file__)) +sys.path.insert(0, HERE) +from bannertest import build_of, load_patcher, pristine # noqa: E402 + + +def read_back(vp, art): + """The portraits as the game finds them: 48 tiles each, in reading + order, from the two slots the row builder uses.""" + tiles = [] + for base in vp.BOSS_ICON_TILES: + for i in range(48): + off = (base + i) * 128 + if off + 128 > len(art): + raise AssertionError('tile %d is past the end of the artwork' + % (base + i)) + tiles.append(bytes(art[off:off + 128])) + return tiles + + +def section_names(data): + """The names of the executable's sections, in header order.""" + pe = struct.unpack_from(' virtual address.""" - for raw, va in reversed(self.sections): + for raw, va in reversed(self.placed()): if off >= raw: return off - raw + va raise ValueError('0x%x is in the headers' % off) def off(self, va): """Virtual address -> file offset.""" - for raw, vaddr in reversed(self.sections): + for raw, vaddr in reversed(self.placed()): if va >= vaddr: return va - vaddr + raw raise ValueError('0x%x is below the image' % va) @@ -3056,6 +3071,13 @@ def annex_place(size, sections): 'TITLEVER', 'PAD_COND', 'PAD_BINDS', 'PAD_NAMES', 'PAD_PROFILES', 'PAD_SIMPLEDEF', 'PAD_INIKEYS', 'EXTRAS_DATA', 'ACTIVATE', 'LOCKLINE', 'CUSTOM', 'CUSTOM_DLG', 'RAPH') +# Blobs too big for the annex, each in a section of its own that +# apply_annex appends only when its patch is ticked: the section's name, +# and the patch. Written as far as the blob's last byte that is not zero; +# the buffers gathered at its end are the section's virtual size, which +# the loader zeroes. +OWN_SECTIONS = {'BOSSES': ('.vobs', 'bosses')} + RETAIL = Build('English retail', 'retail', ORIGINAL_MD5, EXE_SIZE, RETAIL_STAMP, sections=( (0x00000400, 0x00401000), # .text @@ -3103,6 +3125,10 @@ def annex_place(size, sections): 'SAVELINE': -0xcc, # and its line buffer 'F_X': -0xc, # the movie placer's X and Y 'F_Y': -0x10, + 'DR_FLAG': -0xc, # playable bosses: the round's anim deref + 'CAM_PTR': -0x4, # the live chase camera + 'SCAN_SLOT': -0x1c, # the ending camera's slot found + 'PAL_CPU': -0xc, # palette events: the CPU's on 5/7 # The game 'GAMEPADDEF': 0x0066d600, # the gamepad's shipped binds 'SPEEDSEL': 0x00be4308, # the F5 speed choice @@ -3224,8 +3250,218 @@ def annex_place(size, sections): 'GETCLIENT': 0x0365d5d4, # GetClientRect, the hooked one 'MOVEWINDOW': 0x0365d5e0, # MoveWindow 'MCISEND': 0x0365d648, # mciSendCommandA + # Playable bosses (asm/bosses.asm). A is player 1's copy of the fight + # machine, at 0x1ae0xxxx, the one a one-player game runs on. + 'BS_IDLE': 0x005c6531, # the loop's idle call + 'BS_SFX': 0x00597311, # sound effect, cdecl (id) + 'BS_SCENEA': 0x01ae2e24, + 'BS_G1PA': 0x01ae0c38, # the player's machine id + 'BS_MODEA': 0x01ae353c, # A's mode, as its select reads it + 'BS_COL0': 0x0069fff0, # colour per machine, slots 1/3 + 'BS_COL1': 0x006a0010, # and 5/7 + 'BS_OBJA': 0x01ae0c40, # the player's object + 'BS_CPUA': 0x01ae1240, # the CPU's + 'BS_IDA': 0x01ae0ca4, # player object + 0x64, its id + 'BS_MDLA': 0x01ae0cac, # + 0x6c, its model header + 'BS_JAGA': 0x0063bb48, # model headers: Jaguarandi, Z-Gradt + 'BS_ZGA': 0x0063d328, + 'BS_STAGEA': 0x01ae3590, # stage, 0 to 9 + 'BS_PALA': 0x006a0038, # palette id -> a machine's eight pairs + 'BS_PALSETA': 0x004f3491, # (slot, palette) + 'BS_PALFIXA': 0x004f362f, # the loaders' path for ids above 7 + 'BS_PALRETA': 0x004f3646, # and their epilogues + 'BS_RPARTA': 0x00460d9d, # PLAYER DATA: the model's parts draw + 'BS_MPUSHA': 0x00408630, # matrix stack: push, pop, scale + 'BS_MPOPA': 0x004086b0, + 'BS_MSCALEA': 0x00408790, + 'BS_MIDENTA': 0x004086e0, # the matrix made the identity + 'BS_BARMESHA': 0x00791db0, # the HUD's bar quad, its weapon and red materials + 'BS_BARONA': 0x00791a70, + 'BS_BARREDA': 0x00791ad0, + 'BS_BARLIVEA': 0x00791b50, # the live bar's, pulsing + 'BS_CHARGEA': 0x004cfe83, # the strips' CHARGING block (1), or its rows cleared (0) + 'BS_RFLAG': 0x006bf5a4, # the renderer flag a machine's draw sets + 'BS_MATA': 0x01ae61e0, # the current matrix + 'BS_IDENTA': 0x004086e6, # load identity, past its prologue + 'BS_LIGHTA': 0x0345d254, # a machine's shadow: the light, where + 'BS_SHADEA': 0x0046b56e, # it carries on, and past it + 'BS_NOSHADEA': 0x0046b8fb, + 'BS_ECBLKA': 0x01ae35e0, # the ending's camera's block + 'BS_ESTEPA': 0x01ad09f4, + 'BS_ZSHADEA': 0x00404dc1, # Z-Gradt's shadow: where it carries + 'BS_ZNOSHADEA': 0x0040511c, # on, and past it + 'BS_WALLA': 0x0048f830, # the floor's height, for a beam + 'BS_SPDA': 0x01aea590, # Z-Gradt's beam's speed (slot 0xcb) + 'BS_SCANA': 0x0058aa86, # the ending camera's slot scan, and + 'BS_FOUNDA': 0x0058aac7, # where it takes a slot found + 'BS_SCANBASE': 0x600, # what the scan adds to its start + 'BS_ZTAB0': 0x00651360, # Z-Gradt's tables, per side + 'BS_ZTAB1': 0x00651690, + 'BS_ZINITA': 0x00406375, # Z-Gradt's setup + 'BS_PH0A': 0x0058c1cc, # the ending's phase 0 + 'BS_ZDRAWA': 0x00404042, # Z-Gradt's draw, without its moves + 'BS_MDRAWA': 0x00468e56, # the eight's draw, from their routine + 'BS_SCRPTR': 0x0345b288, # the scene script being read + 'BS_SELSCRA': 0x006218b8, # the select's script + 'BS_SELCUR': 0x0345bd68, # a player's cursor, every 0x54 + 'BS_SELINVA': 0x00621898, # the cursor of a machine + 'BS_COLSEL': 0x006bea58, # Machine Color Select + 'BS_SELMDLA': 0x0059cb93, # the select's model of a machine + 'BS_SELINFOA': 0x0059c9b0, # and its text for a cursor + 'BS_FRAMEA': 0x01ae35a0, # the frame counter + 'BS_SELMODE': 0x006c84d0, + 'BS_SELQINFOA': 0x005a1376, # the quick select's texts for a cursor, + 'BS_QTXTX': 0x006bea74, # and where it puts them: the column, + 'BS_QTXTY': 0x006bea7c, # the row + 'BS_SELHIDEX': 0x005a05df, # the confirm's hiding of the machines, past it + 'BS_PRINT1A': 0x004ce53b, # text: print on each plane, place, + 'BS_PRINT2A': 0x004ce573, # clear a block, draw a block of tiles + 'BS_TXTPOSA': 0x004cd8c3, + 'BS_TCLEARA': 0x004cf4cc, + 'BS_TBLOCKA': 0x004cf30c, + 'BS_LOGOJ': 0x009337ba, # the bosses' names, as tiles + 'BS_LOGOZ': 0x009339b0, + 'BS_ROW': 0x009310ba, # the eight's portraits, 0x37 by 8 + 'BS_PLANE': 0x01cc18ea, # the 2D plane they are drawn on + 'BS_SELROWS': 0x00621708, # the select's models + 'BS_SELSWAP': 0x00621d68, # and per machine the bone given + 'BS_SELSPEC': 0x00621da8, # spare meshes, and one drawn apart + 'BS_SELLCAM': 0x00621e68, # the launch's camera, a machine's + 'BS_SELAHEAD': 0x00621ff8, # how far ahead a machine is drawn + 'BS_MFRAMEA': 0x0365142a, # the frame a machine's motion is drawn at + 'BS_SELPADS': 0x01ed5ec5, # the pads' presses this frame, two + 'BS_SELFLAME': 0x00621e28, # a machine's booster flames, per frame + 'BS_SELSKY': 0x006bea68, # the hangar's outside shown, + 'BS_SELIN': 0x006bea60, # and its inside + 'BS_SELTICKS': 0x01ad0a78, + 'BS_STATEA': 0x01ae3690, # A's state machine + 'BS_DIFF': 0x01caf4c1, # the difficulty, 2 Very Hard + 'BS_LOSSA': 0x01ae3530, # A's lost matches + 'BS_REPLOGICA': 0x004608ef, # PLAYER DATA's state 0x1e, + 'BS_REPTEXTA': 0x004617a0, # its text, its turning model + 'BS_REPMODELA': 0x00460cf3, + 'BS_REPCNT': 0x034155e4, # and its frame + 'BS_TCLRALL': 0x004cda9f, # text: clear, reset, the large font + 'BS_TRESET': 0x004cd542, + 'BS_PRINTBIG': 0x004cefb2, + 'BS_PADEDGE': 0x01ed5ebc, # buttons pressed this frame + 'BS_FADE': 0x004a38a0, # fade, and end a scene + 'BS_SCNEND': 0x00511a17, + 'BS_FWRITE': 0x005e7590, # and "wb" + 'BS_WBMODE': 0x006beac4, + 'BS_ARTPOOL': 0x0066c1a0, # the 2D art, tile n at + n * 0x80 + 'BS_ARTPOOL2': 0x0066c1a8, # the other bank, the count, .data's end + 'BS_ARTCOUNT': 0x00bf5f7c, + 'BS_ARTEND': 0x0365cb28, + 'BS_MALLOC': 0x005e70d0, # the C library's malloc + 'BS_POLYCOL': 0x006db504, # the polygon being queued's light + 'BS_KEYA': 0x007086f0, # the polygon's depth key, as the mesh draw keeps it + 'BS_COLTAB': 0x0066c2c8, # the polygons' colours, a row a plane + 'BS_SCNNOW': 0x006a5068, # and a texture bank + 'BS_LOADTEX': 0x00510ecb, + 'BS_FCBUF': 0x02c05e60, # a scene's floor texture and model + 'BS_FLDBUF': 0x03346560, + 'BS_GLOW1': 0x006817f4, # and its glow's state + 'BS_GLOW2': 0x00bf6e70, + 'BS_GLOW3': 0x00bf6e6c, + 'BS_MTSELMEM': 0x0122ac70, # MT_sel.bin read in, and its segment + 'BS_SEGA': 0x006a4f60, + 'BS_TXTX': 0x00bf7758, # the text cursor's column + 'BS_SLOTS': 0x006a0680, # loaded files: where, and how much + 'BS_LOADFILE': 0x005114e9, # load one into the pool, by slot + 'BS_RBNAMES': 0x006a05a0, # the fight models' files + 'BS_RBDIR': 0x02b05d50, + 'BS_PATHFMT': 0x00651b34, + 'BS_RBMODE': 0x006a50c8, + 'BS_SPRINTF': 0x005e5f40, + 'BS_FOPEN': 0x005e66b0, + 'BS_FREAD': 0x005e73c0, + 'BS_FCLOSE': 0x005e6400, + 'BS_PALLOADA': 0x004f358b, + 'BS_PALRAMA': 0x01cb5500, + 'BS_SELOBJ': 0x0345b290, + 'BS_SELCAM': 0x0345bd58, # the scene camera's place + 'BS_FRX': 0x006220d8, # the portrait frame's x, in .rdata + 'BS_HSITE': 0x0059e4ea, # the hangar's call of the model, and + 'BS_HDOFF': UI_HANGAR_DRAW, # the widescreen hangar_draw in its blob + 'BS_MESHA': 0x00514576, + 'BS_POSEA': 0x005127eb, # a fight model posed by a motion + 'BS_ROTYA': 0x004088a0, + 'BS_ROTZA': 0x00408940, + 'BS_CREATEF': 0x0365d4cc, # IAT: CreateFileA, SetFilePointer, + 'BS_SEEKF': 0x0365d468, # ReadFile, CloseHandle + 'BS_READF': 0x0365d4bc, + 'BS_CLOSEF': 0x0365d4b8, + 'BS_ZPARTS': 0x00651360, # Z-Gradt's parts its draw places: + 'BS_ZRINGS': 0x006513b8, # most, its rings, its crown, its + 'BS_ZCROWN': 0x006515a8, # side units (its first side's) + 'BS_ZSIDES': 0x006515c0, + 'BS_ROTXA': 0x00408800, # turn the matrix about x, and hand + 'BS_MSETA': 0x00514430, # it to the renderer + 'BS_FXA': 0x01acfa78, # the effects tables: exhaust and such + 'BS_FX2A': 0x01aceff0, + 'BS_NAMEA': 0x005fbb78, # and the machine names + 'BS_LDA': 0x004f45ba, # round animations: mode 0x80's loads + 'BS_LDXA': 0x004f45d7, # the extras after them + 'BS_DRFA': 0x004f4635, # the deref: through, je, past + 'BS_DRJA': 0x004f4684, + 'BS_DRSA': 0x004f46fb, + 'BS_C2A': 0x004f47a4, # mode 0xa + 'BS_TIMEA': 0x01ad09f0, # the ending's frame counter + 'BS_PHASEA': 0x01ad0964, # and phase + 'BS_ENDA': 0x00590875, # resume, phase 1, epilogue (the + 'BS_END1A': 0x005908c4, # button wait) + 'BS_ENDEA': 0x005908f2, + 'BS_VIEWA': 0x00408720, # view translate, sin, cos + 'BS_SINA': 0x004089e0, + 'BS_COSA': 0x00408a00, + 'BS_YAW4': 0x00bf7b94, # the yaw the opening shots place the eye by + 'BS_LIVEA': 0x00513584, # the live camera, resume + 'BS_READYA': 0x01ae35a4, # frames since GET READY + 'BS_INITA': 0x0040637b, # Z-Gradt: init, resume + 'BS_FLYA': 0x00407dda, # fly-in: resume, landed, epilogue + 'BS_FLYPA': 0x00407faa, + 'BS_FLYEA': 0x004085c7, + 'BS_ZMODA': 0x03651434, # the model header its code reads + 'BS_ZTIMA': 0x00a02d18, # fly-in timer + 'BS_RCOUNTA': 0x01ae2004, # A's frames left in a state (GET READY's) + 'BS_ARENA': 0x0345d260, # the arena loaded, 0 to 9 + 'BS_ZBOXA': 0x004062bd, # Z-Gradt's own floor query, the moon gate's box + 'BS_FLOORA': 0x0048fe10, # the arena's floor, the eight's query + 'BS_TM2': 0x00406f42, # the four timer locks: resume, skip + 'BS_TM2S': 0x0040756f, + 'BS_TM4': 0x00406e01, + 'BS_TM4S': 0x00406ef8, + 'BS_CLIP0A': 0x005b7038, # clip banks: pad, AI + 'BS_CLIP3A': 0x005b7052, + 'BS_CLONEA': 0x00406557, # model header clone, resume + 'BS_CLONEFRAME': 0x44, # the frame the clone's prologue makes + 'BS_BSSA': 0x00a02b60, # Z-Gradt's AI state: its globals' first, + 'BS_AIDW': 0x78, # its globals' length in dwords + 'BS_AI1C': 0x1c, # and seven of them, from the first: + 'BS_AITIMER': 0x1b8, # retail's +0x1c, the fly-in timer, + 'BS_AILASER': 0x1c4, # the laser's state, the side's + 'BS_AITAB': 0x1bc, # four tables + 'BS_AITAB2': 0x1c0, + 'BS_AITAB3': 0x4, + 'BS_AITAB4': 0xd0, + 'BS_TICKA': 0x005b8cd1, # its AI tick, resume + 'BS_EVA': 0x03415208, # palette event, per handler + 'BS_ZEVA': 0x00a02c34, # and the one Z-Gradt's AI asks for + 'BS_ZRA5': 0x004f4a52, # event 0x200: slots 5/7, 1/3, the end + 'BS_ZRA1': 0x004f4a75, + 'BS_ZRAX': 0x004f4c38, + 'BS_ZGA5': 0x004f4ad7, # event 0x21f, gold: slots 5/7, 1/3 + 'BS_ZGA1': 0x004f4afa, + 'BS_ZDA5': 0x004f4b47, # events 0x401 on: slots 5/7, 1/3 + 'BS_ZDA1': 0x004f4b7a, + 'BS_ZFA5': 0x004f4bd7, # and 0x420 on + 'BS_ZFA1': 0x004f4c0a, + 'BS_WIND1': 0x00bf8508, # the win camera's distance + 'BS_RPITCH1': 0x00bf8460, # the replay camera's pitch and yaw + 'BS_RYAW1': 0x00bf8464, }, art=('escrgame.bin', 4194304, 'f0c2b33c6d32e8e25cee840a0de65dc0'), - annex=ANNEX_BLOBS) + annex=ANNEX_BLOBS, own=('BOSSES',)) # The Japanese rerelease: the same source six months on, through a newer @@ -3402,8 +3638,221 @@ def annex_place(size, sections): 'GETCLIENT': 0x036585e4, # GetClientRect, the hooked one 'MOVEWINDOW': 0x036585f0, # MoveWindow 'MCISEND': 0x0365864c, # mciSendCommandA + # Playable bosses: retail's captions apply. + 'DR_FLAG': -0x4, + 'CAM_PTR': -0x8, + 'SCAN_SLOT': -0x18, + 'PAL_CPU': -0x4, + 'BS_IDLE': 0x005c0e00, + 'BS_SFX': 0x00592371, + 'BS_SCENEA': 0x01addc54, + 'BS_G1PA': 0x01adcd20, + 'BS_MODEA': 0x01adb924, + 'BS_COL0': 0x0069bd50, + 'BS_COL1': 0x0069bd70, + 'BS_OBJA': 0x01adb930, + 'BS_CPUA': 0x01adbf40, + 'BS_IDA': 0x01adb994, + 'BS_MDLA': 0x01adb99c, + 'BS_JAGA': 0x006368d0, + 'BS_ZGA': 0x006380b0, + 'BS_STAGEA': 0x01adb92c, + 'BS_PALA': 0x0069bd98, + 'BS_PALSETA': 0x004f04e1, + 'BS_PALFIXA': 0x004f067f, + 'BS_PALRETA': 0x004f0696, + 'BS_RPARTA': 0x0045fe01, + 'BS_MPUSHA': 0x004085a0, + 'BS_MPOPA': 0x00408620, + 'BS_MSCALEA': 0x00408700, + 'BS_MIDENTA': 0x00408650, + 'BS_BARMESHA': 0x0078db40, + 'BS_BARONA': 0x0078d800, + 'BS_BARREDA': 0x0078d860, + 'BS_BARLIVEA': 0x0078d8e0, # the live bar's, pulsing + 'BS_CHARGEA': 0x004cda0d, + 'BS_RFLAG': 0x006bb2bc, + 'BS_MATA': 0x01ae0ef0, + 'BS_IDENTA': 0x00408656, + 'BS_LIGHTA': 0x03457e94, + 'BS_SHADEA': 0x0046a5b2, + 'BS_NOSHADEA': 0x0046a92c, + 'BS_ECBLKA': 0x01adcd40, + 'BS_ESTEPA': 0x01acb6a4, + 'BS_ZSHADEA': 0x00404da1, + 'BS_ZNOSHADEA': 0x004050e0, + 'BS_WALLA': 0x0048e3f0, + 'BS_SPDA': 0x01ae4560, + 'BS_SCANA': 0x00585e5e, + 'BS_FOUNDA': 0x00585e9f, + 'BS_SCANBASE': 0x000005e0, + 'BS_ZTAB0': 0x0064d360, + 'BS_ZTAB1': 0x0064d690, + 'BS_ZINITA': 0x00406301, + 'BS_PH0A': 0x005874fc, + 'BS_ZDRAWA': 0x00404022, + 'BS_MDRAWA': 0x00467e9a, + 'BS_SCRPTR': 0x03456968, + 'BS_SELSCRA': 0x0061c640, + 'BS_SELCUR': 0x034569b8, + 'BS_SELINVA': 0x0061c620, + 'BS_COLSEL': 0x006ba770, + 'BS_SELMDLA': 0x00597993, + 'BS_SELINFOA': 0x005977b0, + 'BS_FRAMEA': 0x01adb8d4, + 'BS_SELMODE': 0x006c41e8, + 'BS_SELQINFOA': 0x0059c10e, # the quick select's texts for a cursor, + 'BS_QTXTX': 0x006ba78c, # and where it puts them: the column, + 'BS_QTXTY': 0x006ba794, # the row + 'BS_SELHIDEX': 0x0059b377, # the confirm's hiding of the machines, past it + 'BS_PRINT1A': 0x004cc0db, + 'BS_PRINT2A': 0x004cc113, + 'BS_TXTPOSA': 0x004cb463, + 'BS_TCLEARA': 0x004cd06c, + 'BS_TBLOCKA': 0x004cceac, + 'BS_LOGOJ': 0x0092f36a, + 'BS_LOGOZ': 0x0092f560, + 'BS_ROW': 0x0092cc6a, + 'BS_PLANE': 0x01cbc59a, + 'BS_SELROWS': 0x0061c490, + 'BS_SELSWAP': 0x0061caf0, + 'BS_SELSPEC': 0x0061cb30, + 'BS_SELLCAM': 0x0061cbf0, + 'BS_SELAHEAD': 0x0061cd80, + 'BS_MFRAMEA': 0x0364c07e, + 'BS_SELPADS': 0x01ed0b65, + 'BS_SELFLAME': 0x0061cbb0, + 'BS_SELSKY': 0x006ba780, + 'BS_SELIN': 0x006ba778, + 'BS_SELTICKS': 0x01acb720, + 'BS_STATEA': 0x01addc40, + 'BS_DIFF': 0x01b27281, + 'BS_LOSSA': 0x01addc4c, + 'BS_REPLOGICA': 0x0045f96f, + 'BS_REPTEXTA': 0x00460804, + 'BS_REPMODELA': 0x0045fd73, + 'BS_REPCNT': 0x03410250, + 'BS_TCLRALL': 0x004cb63f, + 'BS_TRESET': 0x004cb0e2, + 'BS_PRINTBIG': 0x004ccb52, + 'BS_PADEDGE': 0x01ed0b5c, + 'BS_FADE': 0x004a23e0, + 'BS_SCNEND': 0x0050e059, + 'BS_FWRITE': 0x005e1120, + 'BS_WBMODE': 0x006ba7dc, + 'BS_ARTPOOL': 0x00668128, + 'BS_ARTPOOL2': 0x00668130, + 'BS_ARTCOUNT': 0x00bf0bdc, + 'BS_ARTEND': 0x0365778c, + 'BS_MALLOC': 0x005e0c60, + 'BS_POLYCOL': 0x006d7294, + 'BS_KEYA': 0x00704480, + 'BS_COLTAB': 0x00668250, + 'BS_SCNNOW': 0x006a0dc8, + 'BS_LOADTEX': 0x0050d43b, + 'BS_FCBUF': 0x02732480, + 'BS_FLDBUF': 0x01ff8d00, + 'BS_GLOW1': 0x0067d77c, + 'BS_GLOW2': 0x00bf1a70, + 'BS_GLOW3': 0x00bf1a74, + 'BS_MTSELMEM': 0x00b53ed0, + 'BS_SEGA': 0x006a0cc0, + 'BS_TXTX': 0x00bf23ac, + 'BS_SLOTS': 0x0069c3e0, + 'BS_LOADFILE': 0x0050dbbb, + 'BS_RBNAMES': 0x0069c300, + 'BS_RBDIR': 0x02772b80, + 'BS_PATHFMT': 0x0064db34, + 'BS_RBMODE': 0x006a0e28, + 'BS_SPRINTF': 0x005dfa40, + 'BS_FOPEN': 0x005e0240, + 'BS_FREAD': 0x005e0f50, + 'BS_FCLOSE': 0x005dff90, + 'BS_PALLOADA': 0x004f05db, + 'BS_PALRAMA': 0x01b13260, + 'BS_SELOBJ': 0x03455d50, + 'BS_SELCAM': 0x034569a8, + 'BS_FRX': 0x0061ce60, + 'BS_HSITE': 0x005992ea, + 'BS_HDOFF': UI_HANGAR_DRAW, # Experience UI has an eight-byte prefix adjustment + 'BS_MESHA': 0x00510aa6, + 'BS_POSEA': 0x0050eddb, + 'BS_ROTYA': 0x00408810, + 'BS_ROTZA': 0x004088b0, + 'BS_CREATEF': 0x036584d0, + 'BS_SEEKF': 0x0365846c, + 'BS_READF': 0x036584cc, + 'BS_CLOSEF': 0x036584d4, + 'BS_ZPARTS': 0x0064d360, + 'BS_ZRINGS': 0x0064d3b8, + 'BS_ZCROWN': 0x0064d5a8, + 'BS_ZSIDES': 0x0064d5c0, + 'BS_ROTXA': 0x00408770, + 'BS_MSETA': 0x00510960, + 'BS_FXA': 0x01ac9c68, + 'BS_FX2A': 0x01aca510, + 'BS_NAMEA': 0x005f6b78, + 'BS_LDA': 0x004f160a, + 'BS_LDXA': 0x004f1627, + 'BS_DRFA': 0x004f1685, + 'BS_DRJA': 0x004f16d4, + 'BS_DRSA': 0x004f174b, + 'BS_C2A': 0x004f17f4, + 'BS_TIMEA': 0x01acb40c, + 'BS_PHASEA': 0x01acb68c, + 'BS_ENDA': 0x0058b8c9, + 'BS_END1A': 0x0058b918, + 'BS_ENDEA': 0x0058b946, + 'BS_VIEWA': 0x00408690, + 'BS_SINA': 0x00408950, + 'BS_COSA': 0x00408970, + 'BS_YAW4': 0x00bf3040, + 'BS_LIVEA': 0x0050fb74, + 'BS_READYA': 0x01adb8e0, + 'BS_INITA': 0x00406307, + 'BS_FLYA': 0x00407d4a, + 'BS_FLYPA': 0x00407f1a, + 'BS_FLYEA': 0x00408537, + 'BS_ZMODA': 0x0364c088, + 'BS_ZTIMA': 0x009fd960, + 'BS_RCOUNTA': 0x01ade354, + 'BS_ARENA': 0x03457ea4, + 'BS_ZBOXA': 0x00406249, # Z-Gradt's own floor query, the moon gate's box + 'BS_FLOORA': 0x0048e960, # the arena's floor, the eight's query + 'BS_TM2': 0x00406ece, + 'BS_TM2S': 0x004074df, + 'BS_TM4': 0x00406d8d, + 'BS_TM4S': 0x00406e84, + 'BS_CLIP0A': 0x005b1aa0, + 'BS_CLIP3A': 0x005b1aba, + 'BS_CLONEA': 0x004064e3, + 'BS_CLONEFRAME': 0x0000000c, + 'BS_BSSA': 0x009fd7b0, + 'BS_AIDW': 0x7a, + 'BS_AI1C': 0x1b4, + 'BS_AITIMER': 0x1b0, + 'BS_AILASER': 0x4, + 'BS_AITAB': 0x28, + 'BS_AITAB2': 0xec, + 'BS_AITAB3': 0x20, + 'BS_AITAB4': 0x18, + 'BS_TICKA': 0x005b36a9, + 'BS_EVA': 0x0340fe6c, + 'BS_ZEVA': 0x009fd7d4, + 'BS_ZRA5': 0x004f1aa2, + 'BS_ZRA1': 0x004f1ac5, + 'BS_ZRAX': 0x004f1c88, + 'BS_ZGA5': 0x004f1b27, + 'BS_ZGA1': 0x004f1b4a, + 'BS_ZDA5': 0x004f1b97, + 'BS_ZDA1': 0x004f1bca, + 'BS_ZFA5': 0x004f1c27, + 'BS_ZFA1': 0x004f1c5a, + 'BS_WIND1': 0x00bf316c, + 'BS_RPITCH1': 0x00bf3124, + 'BS_RYAW1': 0x00bf3128, }, art=('jscrgame.bin', 4194304, '1d892aeb30bb517f57e7d289ed2f4389'), - sites=None, annex=ANNEX_BLOBS) + sites=None, annex=ANNEX_BLOBS, own=('BOSSES',)) # The USA OEM pressing: the same toolchain a month before retail, and the # closest of the builds to it - 7852 of 7934 functions match, 7593 @@ -3451,6 +3900,10 @@ def annex_place(size, sections): 'SAVELINE': -0xcc, 'F_X': -0xc, 'F_Y': -0x10, + 'DR_FLAG': -0xc, + 'CAM_PTR': -0x4, + 'SCAN_SLOT': -0x1c, + 'PAL_CPU': -0xc, 'GAMEPADDEF': 0x0066d5f8, # data 1 votes 'SPEEDSEL': 0x00be42c8, 'FRAMEDIV': 0x006c8468, @@ -3571,7 +4024,217 @@ def annex_place(size, sections): 'GETCLIENT': 0x0365d608, # iat GetClientRect 'MOVEWINDOW': 0x0365d614, # iat MoveWindow 'MCISEND': 0x0365d67c, # iat mciSendCommandA -}, art=RETAIL.art, sites=None, annex=ANNEX_BLOBS) # retail's art + # Playable bosses: retail's captions apply. + 'BS_IDLE': 0x005c604a, + 'BS_SFX': 0x00596de1, + 'BS_SCENEA': 0x01ae2db4, + 'BS_G1PA': 0x01ae0bc8, + 'BS_MODEA': 0x01ae34cc, + 'BS_COL0': 0x0069ffe8, + 'BS_COL1': 0x006a0008, + 'BS_OBJA': 0x01ae0bd0, + 'BS_CPUA': 0x01ae11d0, + 'BS_IDA': 0x01ae0c34, + 'BS_MDLA': 0x01ae0c3c, + 'BS_JAGA': 0x0063bb38, + 'BS_ZGA': 0x0063d318, + 'BS_STAGEA': 0x01ae3520, + 'BS_PALA': 0x006a0030, + 'BS_PALSETA': 0x004f3331, + 'BS_PALFIXA': 0x004f34cf, + 'BS_PALRETA': 0x004f34e6, + 'BS_RPARTA': 0x00460cfd, + 'BS_MPUSHA': 0x00408630, + 'BS_MPOPA': 0x004086b0, + 'BS_MSCALEA': 0x00408790, + 'BS_MIDENTA': 0x004086e0, + 'BS_BARMESHA': 0x00791d70, + 'BS_BARONA': 0x00791a30, + 'BS_BARREDA': 0x00791a90, + 'BS_BARLIVEA': 0x00791b10, # the live bar's, pulsing + 'BS_CHARGEA': 0x004cfd23, + 'BS_RFLAG': 0x006bf53c, + 'BS_MATA': 0x01ae6170, + 'BS_IDENTA': 0x004086e6, + 'BS_LIGHTA': 0x0345d1e4, + 'BS_SHADEA': 0x0046b46e, + 'BS_NOSHADEA': 0x0046b7fb, + 'BS_ECBLKA': 0x01ae3570, + 'BS_ESTEPA': 0x01ad098c, + 'BS_ZSHADEA': 0x00404dc1, + 'BS_ZNOSHADEA': 0x0040511c, + 'BS_WALLA': 0x0048f6f0, + 'BS_SPDA': 0x01aea520, + 'BS_SCANA': 0x0058a556, + 'BS_FOUNDA': 0x0058a597, + 'BS_SCANBASE': 0x600, + 'BS_ZTAB0': 0x00651358, + 'BS_ZTAB1': 0x00651688, + 'BS_ZINITA': 0x00406375, + 'BS_PH0A': 0x0058bc9c, + 'BS_ZDRAWA': 0x00404042, + 'BS_MDRAWA': 0x00468d56, + 'BS_SCRPTR': 0x0345b218, + 'BS_SELSCRA': 0x006218a8, + 'BS_SELCUR': 0x0345bcf8, + 'BS_SELINVA': 0x00621888, + 'BS_COLSEL': 0x006be9f0, + 'BS_SELMDLA': 0x0059c663, + 'BS_SELINFOA': 0x0059c480, + 'BS_FRAMEA': 0x01ae3530, + 'BS_SELMODE': 0x006c8468, + 'BS_SELQINFOA': 0x005a0e46, # the quick select's texts for a cursor, + 'BS_QTXTX': 0x006bea0c, # and where it puts them: the column, + 'BS_QTXTY': 0x006bea14, # the row + 'BS_SELHIDEX': 0x005a00af, # the confirm's hiding of the machines, past it + 'BS_PRINT1A': 0x004ce3db, + 'BS_PRINT2A': 0x004ce413, + 'BS_TXTPOSA': 0x004cd763, + 'BS_TCLEARA': 0x004cf36c, + 'BS_TBLOCKA': 0x004cf1ac, + 'BS_LOGOJ': 0x0093377a, + 'BS_LOGOZ': 0x00933970, + 'BS_ROW': 0x0093107a, + 'BS_PLANE': 0x01cc187a, + 'BS_SELROWS': 0x006216f8, + 'BS_SELSWAP': 0x00621d58, + 'BS_SELSPEC': 0x00621d98, + 'BS_SELLCAM': 0x00621e58, + 'BS_SELAHEAD': 0x00621fe8, + 'BS_MFRAMEA': 0x036513ba, + 'BS_SELPADS': 0x01ed5e55, + 'BS_SELFLAME': 0x00621e18, + 'BS_SELSKY': 0x006bea00, + 'BS_SELIN': 0x006be9f8, + 'BS_SELTICKS': 0x01ad0a10, + 'BS_STATEA': 0x01ae3620, + 'BS_DIFF': 0x01caf451, + 'BS_LOSSA': 0x01ae34c0, + 'BS_REPLOGICA': 0x0046084f, + 'BS_REPTEXTA': 0x00461700, + 'BS_REPMODELA': 0x00460c53, + 'BS_REPCNT': 0x03415574, + 'BS_TCLRALL': 0x004cd93f, + 'BS_TRESET': 0x004cd3e2, + 'BS_PRINTBIG': 0x004cee52, + 'BS_PADEDGE': 0x01ed5e4c, + 'BS_FADE': 0x004a3740, + 'BS_SCNEND': 0x00511587, + 'BS_FWRITE': 0x005e70d0, + 'BS_WBMODE': 0x006bea5c, + 'BS_ARTPOOL': 0x0066c198, + 'BS_ARTPOOL2': 0x0066c1a0, + 'BS_ARTCOUNT': 0x00bf5f3c, + 'BS_ARTEND': 0x0365cab8, + 'BS_MALLOC': 0x005e6c10, + 'BS_POLYCOL': 0x006db4c4, + 'BS_KEYA': 0x007086b0, + 'BS_COLTAB': 0x0066c2c0, + 'BS_SCNNOW': 0x006a5000, + 'BS_LOADTEX': 0x00510a3b, + 'BS_FCBUF': 0x02c05df0, + 'BS_FLDBUF': 0x033464f0, + 'BS_GLOW1': 0x006817ec, + 'BS_GLOW2': 0x00bf6e30, + 'BS_GLOW3': 0x00bf6e2c, + 'BS_MTSELMEM': 0x0122ac08, + 'BS_SEGA': 0x006a4ef8, + 'BS_TXTX': 0x00bf7718, + 'BS_SLOTS': 0x006a0618, + 'BS_LOADFILE': 0x00511059, + 'BS_RBNAMES': 0x006a0538, + 'BS_RBDIR': 0x02b05ce0, + 'BS_PATHFMT': 0x00651b2c, + 'BS_RBMODE': 0x006a5060, + 'BS_SPRINTF': 0x005e5a80, + 'BS_FOPEN': 0x005e61f0, + 'BS_FREAD': 0x005e6f00, + 'BS_FCLOSE': 0x005e5f40, + 'BS_PALLOADA': 0x004f342b, + 'BS_PALRAMA': 0x01cb5490, + 'BS_SELOBJ': 0x0345b220, + 'BS_SELCAM': 0x0345bce8, + 'BS_FRX': 0x006220c8, + 'BS_HSITE': 0x0059dfba, + 'BS_HDOFF': UI_HANGAR_DRAW, + 'BS_MESHA': 0x005140e6, + 'BS_POSEA': 0x0051235b, + 'BS_ROTYA': 0x004088a0, + 'BS_ROTZA': 0x00408940, + 'BS_CREATEF': 0x0365d500, + 'BS_SEEKF': 0x0365d490, + 'BS_READF': 0x0365d4f0, + 'BS_CLOSEF': 0x0365d4ec, + 'BS_ZPARTS': 0x00651358, + 'BS_ZRINGS': 0x006513b0, + 'BS_ZCROWN': 0x006515a0, + 'BS_ZSIDES': 0x006515b8, + 'BS_ROTXA': 0x00408800, + 'BS_MSETA': 0x00513fa0, + 'BS_FXA': 0x01acfa10, + 'BS_FX2A': 0x01acef88, + 'BS_NAMEA': 0x005fbb78, + 'BS_LDA': 0x004f445a, + 'BS_LDXA': 0x004f4477, + 'BS_DRFA': 0x004f44d5, + 'BS_DRJA': 0x004f4524, + 'BS_DRSA': 0x004f459b, + 'BS_C2A': 0x004f4644, + 'BS_TIMEA': 0x01ad0988, + 'BS_PHASEA': 0x01ad08fc, + 'BS_ENDA': 0x00590345, + 'BS_END1A': 0x00590394, + 'BS_ENDEA': 0x005903c2, + 'BS_VIEWA': 0x00408720, + 'BS_SINA': 0x004089e0, + 'BS_COSA': 0x00408a00, + 'BS_YAW4': 0x00bf7b54, + 'BS_LIVEA': 0x005130f4, + 'BS_READYA': 0x01ae3534, + 'BS_INITA': 0x0040637b, + 'BS_FLYA': 0x00407dda, + 'BS_FLYPA': 0x00407faa, + 'BS_FLYEA': 0x004085c7, + 'BS_ZMODA': 0x036513c4, + 'BS_ZTIMA': 0x00a02cd8, + 'BS_RCOUNTA': 0x01ae1f94, + 'BS_ARENA': 0x0345d1f0, + 'BS_ZBOXA': 0x004062bd, # Z-Gradt's own floor query, the moon gate's box + 'BS_FLOORA': 0x0048fcd0, # the arena's floor, the eight's query + 'BS_TM2': 0x00406f42, + 'BS_TM2S': 0x0040756f, + 'BS_TM4': 0x00406e01, + 'BS_TM4S': 0x00406ef8, + 'BS_CLIP0A': 0x005b6b08, + 'BS_CLIP3A': 0x005b6b22, + 'BS_CLONEA': 0x00406557, + 'BS_CLONEFRAME': 0x44, + 'BS_BSSA': 0x00a02b20, + 'BS_AIDW': 0x78, + 'BS_AI1C': 0x1c, + 'BS_AITIMER': 0x1b8, + 'BS_AILASER': 0x1c4, + 'BS_AITAB': 0x1bc, + 'BS_AITAB2': 0x1c0, + 'BS_AITAB3': 0x4, + 'BS_AITAB4': 0xd0, + 'BS_TICKA': 0x005b87a1, + 'BS_EVA': 0x03415198, + 'BS_ZEVA': 0x00a02bf4, + 'BS_ZRA5': 0x004f48f2, + 'BS_ZRA1': 0x004f4915, + 'BS_ZRAX': 0x004f4ad8, + 'BS_ZGA5': 0x004f4977, + 'BS_ZGA1': 0x004f499a, + 'BS_ZDA5': 0x004f49e7, + 'BS_ZDA1': 0x004f4a1a, + 'BS_ZFA5': 0x004f4a77, + 'BS_ZFA1': 0x004f4aaa, + 'BS_WIND1': 0x00bf84a0, + 'BS_RPITCH1': 0x00bf8420, + 'BS_RYAW1': 0x00bf8424, +}, art=RETAIL.art, sites=None, annex=ANNEX_BLOBS, # retail's art + own=('BOSSES',)) # The Japanese original, 1.04J (February 1997, four days before the OEM): # the oldest build, and laid out like the OEM - the same cpuid32.dll @@ -3740,7 +4403,221 @@ def annex_place(size, sections): 'GETCLIENT': 0x0365c608, # iat GetClientRect 'MOVEWINDOW': 0x0365c614, # iat MoveWindow 'MCISEND': 0x0365c67c, # iat mciSendCommandA -}, art=JPRE.art, sites=None, annex=ANNEX_BLOBS) # the rerelease's art + # Playable bosses: retail's captions apply. + 'DR_FLAG': -0xc, + 'CAM_PTR': -0x4, + 'SCAN_SLOT': -0x1c, + 'PAL_CPU': -0xc, + 'BS_IDLE': 0x005c541a, + 'BS_SFX': 0x005961b1, + 'BS_SCENEA': 0x01ae1944, + 'BS_G1PA': 0x01adf758, + 'BS_MODEA': 0x01ae205c, + 'BS_COL0': 0x0069ed48, + 'BS_COL1': 0x0069ed68, + 'BS_OBJA': 0x01adf760, + 'BS_CPUA': 0x01adfd60, + 'BS_IDA': 0x01adf7c4, + 'BS_MDLA': 0x01adf7cc, + 'BS_JAGA': 0x0063a8c0, + 'BS_ZGA': 0x0063c0a0, + 'BS_STAGEA': 0x01ae20b0, + 'BS_PALA': 0x0069ed90, + 'BS_PALSETA': 0x004f2d21, + 'BS_PALFIXA': 0x004f2ebf, + 'BS_PALRETA': 0x004f2ed6, + 'BS_RPARTA': 0x00460cfd, + 'BS_MPUSHA': 0x00408630, + 'BS_MPOPA': 0x004086b0, + 'BS_MSCALEA': 0x00408790, + 'BS_MIDENTA': 0x004086e0, + 'BS_BARMESHA': 0x00790ae0, + 'BS_BARONA': 0x007907a0, + 'BS_BARREDA': 0x00790800, + 'BS_BARLIVEA': 0x00790880, # the live bar's, pulsing + 'BS_CHARGEA': 0x004cfe03, + 'BS_RFLAG': 0x006be29c, + 'BS_MATA': 0x01ae4d00, + 'BS_IDENTA': 0x004086e6, + 'BS_LIGHTA': 0x0345bd74, + 'BS_SHADEA': 0x0046b46e, + 'BS_NOSHADEA': 0x0046b7fb, + 'BS_ECBLKA': 0x01ae2100, + 'BS_ESTEPA': 0x01acf51c, + 'BS_ZSHADEA': 0x00404dc1, + 'BS_ZNOSHADEA': 0x0040511c, + 'BS_WALLA': 0x0048f7f0, + 'BS_SPDA': 0x01ae90b0, + 'BS_SCANA': 0x00589926, + 'BS_FOUNDA': 0x00589967, + 'BS_SCANBASE': 0x600, + 'BS_ZTAB0': 0x00650358, + 'BS_ZTAB1': 0x00650688, + 'BS_ZINITA': 0x00406375, + 'BS_PH0A': 0x0058b06c, + 'BS_ZDRAWA': 0x00404042, + 'BS_MDRAWA': 0x00468d56, + 'BS_SCRPTR': 0x03459da8, + 'BS_SELSCRA': 0x00620630, + 'BS_SELCUR': 0x0345a888, + 'BS_SELINVA': 0x00620610, + 'BS_COLSEL': 0x006bd750, + 'BS_SELMDLA': 0x0059ba33, + 'BS_SELINFOA': 0x0059b850, + 'BS_FRAMEA': 0x01ae20c0, + 'BS_SELMODE': 0x006c71c8, + 'BS_SELQINFOA': 0x005a0216, # the quick select's texts for a cursor, + 'BS_QTXTX': 0x006bd76c, # and where it puts them: the column, + 'BS_QTXTY': 0x006bd774, # the row + 'BS_SELHIDEX': 0x0059f47f, # the confirm's hiding of the machines, past it + 'BS_PRINT1A': 0x004ce4bb, + 'BS_PRINT2A': 0x004ce4f3, + 'BS_TXTPOSA': 0x004cd843, + 'BS_TCLEARA': 0x004cf44c, + 'BS_TBLOCKA': 0x004cf28c, + 'BS_LOGOJ': 0x0093230a, + 'BS_LOGOZ': 0x00932500, + 'BS_ROW': 0x0092fc0a, + 'BS_PLANE': 0x01cc040a, + 'BS_SELROWS': 0x00620480, + 'BS_SELSWAP': 0x00620ae0, + 'BS_SELSPEC': 0x00620b20, + 'BS_SELLCAM': 0x00620be0, + 'BS_SELAHEAD': 0x00620d70, + 'BS_MFRAMEA': 0x0364ff4a, + 'BS_SELPADS': 0x01ed49e5, + 'BS_SELFLAME': 0x00620ba0, + 'BS_SELSKY': 0x006bd760, + 'BS_SELIN': 0x006bd758, + 'BS_SELTICKS': 0x01acf5a0, + 'BS_STATEA': 0x01ae21b0, + 'BS_DIFF': 0x01cadfe1, + 'BS_LOSSA': 0x01ae2050, + 'BS_REPLOGICA': 0x0046084f, + 'BS_REPTEXTA': 0x00461700, + 'BS_REPMODELA': 0x00460c53, + 'BS_REPCNT': 0x03414104, + 'BS_TCLRALL': 0x004cda1f, + 'BS_TRESET': 0x004cd4c2, + 'BS_PRINTBIG': 0x004cef32, + 'BS_PADEDGE': 0x01ed49dc, + 'BS_FADE': 0x004a3840, + 'BS_SCNEND': 0x00510f77, + 'BS_FWRITE': 0x005e6470, + 'BS_WBMODE': 0x006bd7bc, + 'BS_ARTPOOL': 0x0066b120, + 'BS_ARTPOOL2': 0x0066b128, + 'BS_ARTCOUNT': 0x00bf4acc, + 'BS_ARTEND': 0x0365b648, + 'BS_MALLOC': 0x005e5fb0, + 'BS_POLYCOL': 0x006da234, + 'BS_KEYA': 0x00707420, + 'BS_COLTAB': 0x0066b248, + 'BS_SCNNOW': 0x006a3d60, + 'BS_LOADTEX': 0x0051042b, + 'BS_FCBUF': 0x02c04980, + 'BS_FLDBUF': 0x03345080, + 'BS_GLOW1': 0x00680774, + 'BS_GLOW2': 0x00bf59c0, + 'BS_GLOW3': 0x00bf59bc, + 'BS_MTSELMEM': 0x01229798, + 'BS_SEGA': 0x006a3c58, + 'BS_TXTX': 0x00bf62a8, + 'BS_SLOTS': 0x0069f378, + 'BS_LOADFILE': 0x00510a49, + 'BS_RBNAMES': 0x0069f298, + 'BS_RBDIR': 0x02b04870, + 'BS_PATHFMT': 0x00650b2c, + 'BS_RBMODE': 0x006a3dc0, + 'BS_SPRINTF': 0x005e4e20, + 'BS_FOPEN': 0x005e5590, + 'BS_FREAD': 0x005e62a0, + 'BS_FCLOSE': 0x005e52e0, + 'BS_PALLOADA': 0x004f2e1b, + 'BS_PALRAMA': 0x01cb4020, + 'BS_SELOBJ': 0x03459db0, + 'BS_SELCAM': 0x0345a878, + 'BS_FRX': 0x00620e50, + 'BS_HSITE': 0x0059d38a, + 'BS_HDOFF': UI_HANGAR_DRAW, # Experience UI has an eight-byte prefix adjustment + 'BS_MESHA': 0x00513ad6, + 'BS_POSEA': 0x00511d4b, + 'BS_ROTYA': 0x004088a0, + 'BS_ROTZA': 0x00408940, + 'BS_CREATEF': 0x0365c500, + 'BS_SEEKF': 0x0365c490, + 'BS_READF': 0x0365c4f0, + 'BS_CLOSEF': 0x0365c4ec, + 'BS_ZPARTS': 0x00650358, + 'BS_ZRINGS': 0x006503b0, + 'BS_ZCROWN': 0x006505a0, + 'BS_ZSIDES': 0x006505b8, + 'BS_ROTXA': 0x00408800, + 'BS_MSETA': 0x00513990, + 'BS_FXA': 0x01ace5a0, + 'BS_FX2A': 0x01acdb18, + 'BS_NAMEA': 0x005fab78, + 'BS_LDA': 0x004f3e4a, + 'BS_LDXA': 0x004f3e67, + 'BS_DRFA': 0x004f3ec5, + 'BS_DRJA': 0x004f3f14, + 'BS_DRSA': 0x004f3f8b, + 'BS_C2A': 0x004f4034, + 'BS_TIMEA': 0x01acf518, + 'BS_PHASEA': 0x01acf48c, + 'BS_ENDA': 0x0058f715, + 'BS_END1A': 0x0058f764, + 'BS_ENDEA': 0x0058f792, + 'BS_VIEWA': 0x00408720, + 'BS_SINA': 0x004089e0, + 'BS_COSA': 0x00408a00, + 'BS_YAW4': 0x00bf66e4, + 'BS_LIVEA': 0x00512ae4, + 'BS_READYA': 0x01ae20c4, + 'BS_INITA': 0x0040637b, + 'BS_FLYA': 0x00407dda, + 'BS_FLYPA': 0x00407faa, + 'BS_FLYEA': 0x004085c7, + 'BS_ZMODA': 0x0364ff54, + 'BS_ZTIMA': 0x00a01868, + 'BS_RCOUNTA': 0x01ae0b24, + 'BS_ARENA': 0x0345bd80, + 'BS_ZBOXA': 0x004062bd, # Z-Gradt's own floor query, the moon gate's box + 'BS_FLOORA': 0x0048fdd0, # the arena's floor, the eight's query + 'BS_TM2': 0x00406f42, + 'BS_TM2S': 0x0040756f, + 'BS_TM4': 0x00406e01, + 'BS_TM4S': 0x00406ef8, + 'BS_CLIP0A': 0x005b5ed8, + 'BS_CLIP3A': 0x005b5ef2, + 'BS_CLONEA': 0x00406557, + 'BS_CLONEFRAME': 0x44, + 'BS_BSSA': 0x00a016b0, + 'BS_AIDW': 0x78, + 'BS_AI1C': 0x1c, + 'BS_AITIMER': 0x1b8, + 'BS_AILASER': 0x1c4, + 'BS_AITAB': 0x1bc, + 'BS_AITAB2': 0x1c0, + 'BS_AITAB3': 0x4, + 'BS_AITAB4': 0xd0, + 'BS_TICKA': 0x005b7b71, + 'BS_EVA': 0x03413d28, + 'BS_ZEVA': 0x00a01784, + 'BS_ZRA5': 0x004f42e2, + 'BS_ZRA1': 0x004f4305, + 'BS_ZRAX': 0x004f44c8, + 'BS_ZGA5': 0x004f4367, + 'BS_ZGA1': 0x004f438a, + 'BS_ZDA5': 0x004f43d7, + 'BS_ZDA1': 0x004f440a, + 'BS_ZFA5': 0x004f4467, + 'BS_ZFA1': 0x004f449a, + 'BS_WIND1': 0x00bf7030, + 'BS_RPITCH1': 0x00bf6fb0, + 'BS_RYAW1': 0x00bf6fb4, +}, art=JPRE.art, sites=None, annex=ANNEX_BLOBS, + own=('BOSSES',)) # the rerelease's art BUILDS = {RETAIL.md5: RETAIL, JPRE.md5: JPRE, OEM.md5: OEM, JP.md5: JP} @@ -3798,6 +4675,178 @@ def annex_place(size, sections): # SITES JPRE BEGIN JPRE.sites = { + 0x000041b7: (0x00004197, '813d60d99f009a000000'), + 0x00005775: (0x00005701, '558bec535657'), + 0x0000593f: (0x000058cb, 'c70560d99f0000000000'), + 0x0000594e: (0x000a421f, '558bec83ec0c535657'), + 0x000061f4: (0x00006180, '833d60d99f00000f8df7000000'), + 0x000062fc: (0x00006288, 'e895d1ffff'), + 0x00006321: (0x000062ad, 'a1d4d79f00a36cfe4003'), + 0x00006335: (0x000062c1, '833d60d99f00000f8d11060000'), + 0x0000655f: (0x000064cf, 'e875f1ffff'), + 0x000066c6: (0x00006636, 'e80ef0ffff'), + 0x000068b3: (0x00006823, 'e821eeffff'), + 0x00007928: (0x00007898, '8b450833c98a883b010000'), + 0x00102083: (0x000fed83, 'b980010000'), + 0x00102593: (0x000ff293, 'b980010000'), + 0x00103357: (0x0010001f, 'b980010000'), + 0x001033dd: (0x001000a5, 'b980010000'), + 0x001034cd: (0x00100195, 'b980010000'), + 0x00103553: (0x0010021b, 'b980010000'), + 0x0010360b: (0x001002d3, 'b980010000'), + 0x00103686: (0x0010034e, 'b980010000'), + 0x00106baf: (0x0010339c, 'b980010000'), + 0x00106c39: (0x00103426, 'b980010000'), + 0x001072a8: (0x00103a5d, 'b980010000'), + 0x001029ed: (0x000ff6ed, 'b980010000'), + 0x000071d1: (0x00007141, '558bec83ec0c535657'), + 0x00007ae0: (0x00007a50, '558bec535657'), + 0x0006018b: (0x0005f1ef, 'e80d000000'), + 0x00061070: (0x000600d4, 'a120cdad018d04408d048005786b5f00'), + 0x0006a969: (0x000699ad, 'a1947e4503'), + 0x000b2098: (0x000b05d8, '833d54e3ad0100'), + 0x000b21b1: (0x000b06f1, '833d54e3ad0100'), + 0x000b3bbe: (0x000b2036, 'ff054cdcad01'), + 0x000b3e5b: (0x000b22d3, 'c70540dcad011c000000'), + 0x000cc723: (0x000ca2c3, 'e83c59f9ff'), + 0x000cfc15: (0x000cd5a6, '8305ac23bf0002'), + 0x000cfc2f: (0x000cd5c0, '37'), + 0x000cfc31: (0x000cd5c2, '6acc9200'), + 0x000cfc45: (0x000cd5d6, '37'), + 0x000cfc47: (0x000cd5d8, '6acc9200'), + 0x000cfc53: (0x000cd5e4, '8305ac23bf000c'), + 0x000cfcb7: (0x000cd648, '8305ac23bf0002'), + 0x000cfcd1: (0x000cd662, '37'), + 0x000cfcd3: (0x000cd664, '6acc9200'), + 0x000cfce7: (0x000cd678, '37'), + 0x000cfce9: (0x000cd67a, '6acc9200'), + 0x000cfcf5: (0x000cd686, '8305ac23bf000c'), + 0x000d087f: (0x000ce210, '8d044556ddcb01'), + 0x000d08d7: (0x000ce268, '8d04455eddcb01'), + 0x000d094d: (0x000ce2e2, '8d0445a2c5cb01'), + 0x000d09b0: (0x000ce349, '8d0445aac5cb01'), + 0x000d3991: (0x000d11b6, 'c745f81f000000'), + 0x000d39d5: (0x000d11fa, 'c745f81f000000'), + 0x000db986: (0x000d8ab0, 'e8dbeff2ff'), + 0x000f29a5: (0x000ef9f5, '86000000'), + 0x000f39b5: (0x000f0a05, 'a194b9ad01'), + 0x000f3a2b: (0x000f0a7b, '837dfc000f844f000000'), + 0x000f3b9f: (0x000f0bef, 'a194b9ad01'), + 0x000f3e48: (0x000f0e98, '837dfc000f8423000000'), + 0x000f3ecd: (0x000f0f1d, '837dfc000f8423000000'), + 0x000f3f3d: (0x000f0f8d, '837dfc000f8433000000'), + 0x000f3fcd: (0x000f101d, '837dfc000f8433000000'), + 0x0010325f: (0x000fff27, 'e8647bf0ff'), + 0x0010d6d4: (0x00109e54, '99f7f96689157ec06403'), + 0x0010d7b5: (0x00109f35, '99f7f96689157ec06403'), + 0x0010e939: (0x0010b09d, 'd91d6c31bf00'), + 0x0010ede5: (0x0010b4f5, 'd91d6c31bf00'), + 0x0010f06d: (0x0010b745, 'd91d6c31bf00'), + 0x0010f32a: (0x0010b9ca, 'd91d6c31bf00'), + 0x0010f8a1: (0x0010bf09, 'c7056c31bf0000000c42'), + 0x0010f8b0: (0x0010bf18, 'c7056c31bf000000f041'), + 0x0010fb12: (0x0010c15e, 'd91d6c31bf00'), + 0x0010fbf7: (0x0010c243, 'd91d6c31bf00'), + 0x0010fcf6: (0x0010c326, 'd91d6c31bf00'), + 0x0010fedc: (0x0010c4b8, 'd91d6c31bf00'), + 0x00110109: (0x0010c691, 'd91d6c31bf00'), + 0x0011297d: (0x0010ef6d, '8b45f80fbf401e'), + 0x001129f8: (0x0010efe8, '8b45f8d84840'), + 0x00112a2c: (0x0010f01c, '8b45f8d84840'), + 0x00112a60: (0x0010f050, '8b45f8d84840'), + 0x001802cb: (0x0017b4b9, 'e87d13f9ff'), + 0x00189e7e: (0x00185256, '8b45f005e0050000'), + 0x0018a4fd: (0x0018582d, 'e85e22e8ff'), + 0x0018fc68: (0x0018acbc, '833d8cb6ac01000f854f000000'), + 0x0018fcba: (0x0018ad0e, 'e8e9bbffff'), + 0x0018fd0f: (0x0018ad63, 'c70540dcad0116000000'), + 0x0019bf93: (0x00196d93, '558bec83ec30'), + 0x0019bff7: (0x00196df7, '90c46100'), + 0x0019c2e7: (0x001970e7, 'f0ca6100'), + 0x0019c6ab: (0x001974ab, '30cb6100'), + 0x0019c850: (0x00197650, 'f0ca6100'), + 0x0019c973: (0x00197773, 'f0ca6100'), + 0x0019caaa: (0x001978aa, 'f0ca6100'), + 0x0019cbf3: (0x001979f3, 'f0ca6100'), + 0x0019cd94: (0x00197b94, 'e80d83f7ff'), + 0x0019cfeb: (0x00197deb, 'a120cdad01'), + 0x0019d413: (0x00198213, 'a120b7ac01'), + 0x0019d80b: (0x0019860b, 'dc0580cd6100'), + 0x0019d8e5: (0x001986e5, 'f8c56100'), + 0x0019db28: (0x00198928, 'd91c85845d4503'), + 0x0019db81: (0x00198981, 'd91c85845d4503'), + 0x0019dc03: (0x00198a03, 'f8c56100'), + 0x0019dd4a: (0x00198b4a, 'f8c56100'), + 0x0019df8a: (0x00198d8a, 'f8c56100'), + 0x0019e0c2: (0x00198e92, 'd91c85845d4503'), + 0x0019e0f9: (0x00198ec9, 'd91c85845d4503'), + 0x0019e209: (0x00198fd9, 'f8c56100'), + 0x0019e241: (0x00199011, '3b048d505d4503'), + 0x0019e3f8: (0x001991c8, '00c66100'), + 0x0019e590: (0x00199360, '00c66100'), + 0x0019e728: (0x001994f8, '00c66100'), + 0x0019e8cf: (0x0019969f, '00c66100'), + 0x0019eae2: (0x001998b2, '00c66100'), + 0x0019ec20: (0x001999f0, '833c857c69450300'), + 0x0019f30f: (0x0019a0a7, 'e804cbffff'), + 0x0019f317: (0x0019a0af, 'b8eb040000'), + 0x0019f476: (0x0019a20e, '833c85b869450307'), + 0x0019f4cc: (0x0019a264, '833d70a76b0000'), + 0x0019f6a5: (0x0019a43d, '00c66100'), + 0x0019f6f4: (0x0019a48c, 'dc2590cd6100'), + 0x0019f71e: (0x0019a4b6, 'dc2590cd6100'), + 0x0019f780: (0x0019a518, 'dc0590cd6100'), + 0x0019f7aa: (0x0019a542, 'dc0590cd6100'), + 0x0019f8bd: (0x0019a655, '00c66100'), + 0x0019f8c1: (0x0019a659, 'a320cdad01a120cdad01'), + 0x0019f8ec: (0x0019a684, '00c66100'), + 0x0019f91f: (0x0019a6b7, '00c66100'), + 0x0019f9be: (0x0019a756, '837dac0a0f8d17000000'), + 0x0019fc26: (0x0019a9be, '83e007'), + 0x0019fc2c: (0x0019a9c4, '00c66100'), + 0x0019fc3d: (0x0019a9d5, 'f8cb6100'), + 0x0019fc64: (0x0019a9fc, 'f4cb6100'), + 0x0019fc97: (0x0019aa2f, 'f8cb6100'), + 0x0019fccb: (0x0019aa63, 'f0cb6100'), + 0x001a08eb: (0x0019b683, 'e886feffff'), + 0x001a08f3: (0x0019b68b, 'b8eb040000'), + 0x001a0a52: (0x0019b7ea, '833c85b869450307'), + 0x001a0aa8: (0x0019b840, '833d70a76b0000'), + 0x001a0c81: (0x0019ba19, '00c66100'), + 0x001a0e80: (0x0019bc18, '00c66100'), + 0x001a0e84: (0x0019bc1c, 'a320cdad01a120cdad01'), + 0x001a0eaf: (0x0019bc47, '00c66100'), + 0x001a0ee2: (0x0019bc7a, '00c66100'), + 0x001a0f81: (0x0019bd19, '837dac0a0f8d17000000'), + 0x001a171d: (0x0019c4b5, 'c7056869450340c66100'), + 0x001a1764: (0x0019c4fc, 'e8afa6ffff'), + 0x001a17ec: (0x0019c584, '8b048520c66100'), + 0x001a18a5: (0x0019c63d, '8b0485b8694503'), + 0x001a18fb: (0x0019c693, 'e8a301f7ff'), + 0x001b642c: (0x001b0e94, '0fbf403085c00f851a000000'), + 0x001b7f80: (0x001b2958, 'e83d49ebff'), + 0x001b80c8: (0x001b2aa0, '558bec83ec04535657'), + 0x001b82b8: (0x001b2c90, 'e86c2ae5ff'), + 0x001b830d: (0x001b2ce5, 'e8172ae5ff'), + 0x001beb70: (0x001b9510, 'e82633f5ff'), + 0x001c1622: (0x001bbeb6, 'e83519edff'), + 0x001c5b79: (0x001c0448, 'e8b3fdffff'), + 0x001c5bbb: (0x001c048a, 'e871fdffff'), + 0x001d39b1: (0x001ce241, '8b3594726d00'), + 0x001d4704: (0x001cef94, '8b3594726d00'), + 0x001d4ebb: (0x001cf74b, 'a380447000'), + 0x0015c93e: (0x00157e12, '6800d87800'), + 0x0015cb77: (0x0015802f, '6800d87800'), + 0x0015cdb0: (0x0015824c, '6800d87800'), + 0x0015ce2b: (0x001582c7, '5f5e5bc9c3'), + 0x001de8c1: (0x001d9151, '8b3594726d00'), + 0x001df654: (0x001d9ee4, '8b3594726d00'), + 0x001fe638: (0x001f8e40, '6ff94500'), + 0x0023b5d4: (0x00235b5c, '522d574541504f4e00000000000000004c2d574541504f4e0000000000000000524c2d574541504f4e00000000000000'), + 0x0023bca4: (0x0023622c, '522d574541504f4e00000000000000004c2d574541504f4e0000000000000000524c2d574541504f4e00000000000000'), + 0x0023cdb4: (0x0023733c, '522d574541504f4e00000000000000004c2d574541504f4e0000000000000000524c2d574541504f4e000000000000005a49472d524148540000000000000000'), + 0x0023d484: (0x00237a0c, '522d574541504f4e00000000000000004c2d574541504f4e0000000000000000524c2d574541504f4e000000000000005a49472d524148540000000000000000'), + 0x002bb008: (0x002b6168, '5a2d475241542020202020004a41474152414e4449202000'), 0x002bba60: (0x002b6bc0, '0f'), 0x00189546: (0x0018491a, '2256'), 0x00189552: (0x00184926, '88580100'), @@ -4112,6 +5161,33 @@ def annex_place(size, sections): # SITES OEM BEGIN OEM.sites = { + 0x0000655f: (0x0000655f, 'e859f1ffff'), + 0x000066c6: (0x000066c6, 'e8f2efffff'), + 0x000068b3: (0x000068b3, 'e805eeffff'), + 0x00007928: (0x00007928, '8b450833c98a883b010000'), + 0x00102083: (0x00101f23, 'b980010000'), + 0x00102593: (0x00102433, 'b980010000'), + 0x00103357: (0x001031f7, 'b980010000'), + 0x001033dd: (0x0010327d, 'b980010000'), + 0x001034cd: (0x0010336d, 'b980010000'), + 0x00103553: (0x001033f3, 'b980010000'), + 0x0010360b: (0x001034ab, 'b980010000'), + 0x00103686: (0x00103526, 'b980010000'), + 0x00106baf: (0x00106a4f, 'b980010000'), + 0x00106c39: (0x00106ad9, 'b980010000'), + 0x001072a8: (0x00107148, 'b980010000'), + 0x001029ed: (0x0010288d, 'b980010000'), + 0x000d3991: (0x000d3830, 'c745f81f000000'), + 0x000d39d5: (0x000d3874, 'c745f81f000000'), + 0x001129f8: (0x00112568, '8b45fcd84840'), + 0x00112a2c: (0x0011259c, '8b45fcd84840'), + 0x00112a60: (0x001125d0, '8b45fcd84840'), + 0x0019f9be: (0x0019f48e, '837dac0a0f8d17000000'), + 0x001a08eb: (0x001a03bb, 'e886feffff'), + 0x001a0a52: (0x001a0522, '833c85f8bc450307'), + 0x001a0aa8: (0x001a0578, '833df0e96b0000'), + 0x001a0f81: (0x001a0a51, '837dac0a0f8d17000000'), + 0x002bb008: (0x002ba9a0, '5a2d475241542020202020004a41474152414e4449202000'), 0x002bba60: (0x002bb3f8, '0f'), 0x00189546: (0x00189016, '2256'), 0x00189552: (0x00189022, '88580100'), @@ -4394,11 +5470,330 @@ def annex_place(size, sections): 0x001dd67a: (0x001dd1ba, 'd83dd8877000'), 0x001df7a0: (0x001df2e0, '558bec50535152'), 0x001e1e80: (0x001e19c0, '558bec50535152'), + # bosses + 0x001c5b79: (0x001c5692, 'e8b3fdffff'), + 0x001c5bbb: (0x001c56d4, 'e871fdffff'), + 0x0019f8c1: (0x0019f391, 'a3c80bae01a1c80bae01'), + 0x001a0e84: (0x001a0954, 'a3c80bae01a1c80bae01'), + 0x000f29a5: (0x000f2845, '86000000'), + 0x000f39b5: (0x000f3855, 'a1340cae01'), + 0x000f3a2b: (0x000f38cb, '837df4000f844f000000'), + 0x000f3b9f: (0x000f3a3f, 'a1340cae01'), + 0x0018fc68: (0x0018f738, '833dfc08ad01000f854f000000'), + 0x0010325f: (0x001030ff, 'e81c4af0ff'), + 0x000db986: (0x000db826, 'e8f5c2f2ff'), + 0x0011297d: (0x001124ed, '8b45fc0fbf401e'), + 0x00005775: (0x00005775, '558bec535657'), + 0x000071d1: (0x000071d1, '558bec83ec0c535657'), + 0x00006335: (0x00006335, '833dd82ca000000f8d2d060000'), + 0x000061f4: (0x000061f4, '833dd82ca000000f8df7000000'), + 0x001b642c: (0x001b5efc, '0fbf403085c00f851a000000'), + 0x0000594e: (0x0000594e, '558bec83ec44535657'), + 0x001b80c8: (0x001b7b98, '558bec83ec04535657'), + 0x00006321: (0x00006321, 'a1f42ba000a398514103'), + 0x000f3e48: (0x000f3ce8, '837df4000f8423000000'), + 0x000f3ecd: (0x000f3d6d, '837df4000f8423000000'), + 0x000f3f3d: (0x000f3ddd, '837df4000f8433000000'), + 0x000f3fcd: (0x000f3e6d, '837df4000f8433000000'), + 0x0010e939: (0x0010e4a9, 'd91da084bf00'), + 0x0010ede5: (0x0010e955, 'd91da084bf00'), + 0x0010f06d: (0x0010ebdd, 'd91da084bf00'), + 0x0010f32a: (0x0010ee9a, 'd91da084bf00'), + 0x0010fb12: (0x0010f682, 'd91da084bf00'), + 0x0010fbf7: (0x0010f767, 'd91da084bf00'), + 0x0010fcf6: (0x0010f866, 'd91da084bf00'), + 0x0010fedc: (0x0010fa4c, 'd91da084bf00'), + 0x00110109: (0x0010fc79, 'd91da084bf00'), + 0x0010f8a1: (0x0010f411, 'c705a084bf0000000c42'), + 0x0010f8b0: (0x0010f420, 'c705a084bf000000f041'), + 0x00061070: (0x00060fd0, 'a1c80bae018d04408d04800578bb5f00'), + 0x0006018b: (0x000600eb, 'e80d000000'), + 0x00007ae0: (0x00007ae0, '558bec535657'), + 0x0006a969: (0x0006a869, 'a1e4d14503'), + 0x000041b7: (0x000041b7, '813dd82ca0009a000000'), + 0x0018a4fd: (0x00189fcd, 'e84edbe7ff'), + 0x0018fcba: (0x0018f78a, 'e80db9ffff'), + 0x001b82b8: (0x001b7d88, 'e8e8d9e4ff'), + 0x001b830d: (0x001b7ddd, 'e893d9e4ff'), + 0x00189e7e: (0x0018994e, '8b45f00500060000'), + 0x000062fc: (0x000062fc, 'e841d1ffff'), + 0x001c1622: (0x001c10f2, 'e8f9d9ecff'), + 0x001b7f80: (0x001b7a50, 'e80107ebff'), + + 0x001a171d: (0x001a11ed, 'c70518b24503a8186200'), + 0x0019f476: (0x0019ef46, '833c85f8bc450307'), + 0x001a17ec: (0x001a12bc, '8b048588186200'), + 0x0019f4cc: (0x0019ef9c, '833df0e96b0000'), + 0x0019bf93: (0x0019ba63, '558bec83ec30'), + 0x0019f30f: (0x0019eddf, 'e89ccaffff'), + 0x001a1764: (0x001a1234, 'e847a6ffff'), + 0x0019d8e5: (0x0019d3b5, '60186200'), + 0x0019dc03: (0x0019d6d3, '60186200'), + 0x0019dd4a: (0x0019d81a, '60186200'), + 0x0019df8a: (0x0019da5a, '60186200'), + 0x0019e209: (0x0019dcd9, '60186200'), + 0x0019e3f8: (0x0019dec8, '68186200'), + 0x0019e590: (0x0019e060, '68186200'), + 0x0019e728: (0x0019e1f8, '68186200'), + 0x0019e8cf: (0x0019e39f, '68186200'), + 0x0019eae2: (0x0019e5b2, '68186200'), + 0x0019f6a5: (0x0019f175, '68186200'), + 0x0019f8bd: (0x0019f38d, '68186200'), + 0x0019f8ec: (0x0019f3bc, '68186200'), + 0x0019f91f: (0x0019f3ef, '68186200'), + 0x0019fc2c: (0x0019f6fc, '68186200'), + 0x001a0c81: (0x001a0751, '68186200'), + 0x001a0e80: (0x001a0950, '68186200'), + 0x001a0eaf: (0x001a097f, '68186200'), + 0x001a0ee2: (0x001a09b2, '68186200'), + 0x000cfc2f: (0x000cfacf, '37'), + 0x000cfc31: (0x000cfad1, '7a109300'), + 0x000cfc45: (0x000cfae5, '37'), + 0x000cfc47: (0x000cfae7, '7a109300'), + 0x000cfcd1: (0x000cfb71, '37'), + 0x000cfcd3: (0x000cfb73, '7a109300'), + 0x000cfce7: (0x000cfb87, '37'), + 0x000cfce9: (0x000cfb89, '7a109300'), + 0x000cfc15: (0x000cfab5, '83051877bf0002'), + 0x000cfcb7: (0x000cfb57, '83051877bf0002'), + 0x000cfc53: (0x000cfaf3, '83051877bf000c'), + 0x000cfcf5: (0x000cfb95, '83051877bf000c'), + 0x000d087f: (0x000d071f, '8d04453630cc01'), + 0x000d08d7: (0x000d0777, '8d04453e30cc01'), + 0x000d094d: (0x000d07ed, '8d04458218cc01'), + 0x000d09b0: (0x000d0850, '8d04458a18cc01'), + 0x0019bff7: (0x0019bac7, 'f8166200'), + 0x0019f6f4: (0x0019f1c4, 'dc25f81f6200'), + 0x0019f71e: (0x0019f1ee, 'dc25f81f6200'), + 0x0019f780: (0x0019f250, 'dc05f81f6200'), + 0x0019f7aa: (0x0019f27a, 'dc05f81f6200'), + 0x0019cd94: (0x0019c864, 'e87d6cf7ff'), + 0x0019c2e7: (0x0019bdb7, '581d6200'), + 0x0019c850: (0x0019c320, '581d6200'), + 0x0019c973: (0x0019c443, '581d6200'), + 0x0019caaa: (0x0019c57a, '581d6200'), + 0x0019cbf3: (0x0019c6c3, '581d6200'), + 0x0019c6ab: (0x0019c17b, '981d6200'), + 0x0019fc26: (0x0019f6f6, '83e007'), + 0x0019fc3d: (0x0019f70d, '601e6200'), + 0x0019fc64: (0x0019f722, '5c1e6200'), + 0x0019fc97: (0x0019f754, '601e6200'), + 0x0019fccb: (0x0019f789, '581e6200'), + 0x0019cfeb: (0x0019cabb, 'a1c80bae01'), + 0x001a18a5: (0x001a1375, '8b0485f8bc4503'), + 0x0019d80b: (0x0019d2db, 'dc05e81f6200'), + 0x0019ec20: (0x0019e6f0, '833c85bcbc450300'), + 0x0019d413: (0x0019cee3, 'a1100aad01'), + 0x0019e241: (0x0019dd11, '3b048d20b24503'), + 0x000b2098: (0x000b1f38, '833d941fae0100'), + 0x0000593f: (0x0000593f, 'c705d82ca00000000000'), + 0x000b21b1: (0x000b2051, '833d941fae0100'), + 0x001d39b1: (0x001d34f1, '8b35c4b46d00'), + 0x001d4704: (0x001d4244, '8b35c4b46d00'), + 0x001d4ebb: (0x001d49fb, 'a3b0867000'), + 0x0015c93e: (0x0015c4ae, '68301a7900'), + 0x0015cb77: (0x0015c6e7, '68301a7900'), + 0x0015cdb0: (0x0015c920, '68301a7900'), + 0x0015ce2b: (0x0015c99b, '5f5e5bc9c3'), + 0x001de8c1: (0x001de401, '8b35c4b46d00'), + 0x001df654: (0x001df194, '8b35c4b46d00'), + 0x001beb70: (0x001be640, 'e8f617f5ff'), + 0x001802cb: (0x0017fd9b, 'e89b00f9ff'), + 0x001a18fb: (0x001a13cb, 'e86beaf6ff'), + 0x0019f317: (0x0019ede7, 'b8eb040000'), + 0x001a08f3: (0x001a03c3, 'b8eb040000'), + 0x000b3bbe: (0x000b3a5e, 'ff05c034ae01'), + 0x000b3e5b: (0x000b3d00, 'c7052036ae011c000000'), + 0x0018fd0f: (0x0018f7df, 'c7052036ae0116000000'), + 0x000cc723: (0x000cc5c3, 'e83845f9ff'), + 0x001fe638: (0x001fe028, '4f084600'), + 0x0010d6d4: (0x0010d244, '99f7f9668915ba136503'), + 0x0010d7b5: (0x0010d325, '99f7f9668915ba136503'), + 0x0023b5d4: (0x0023afc4, '522d574541504f4e00000000000000004c2d574541504f4e0000000000000000524c2d574541504f4e00000000000000'), + 0x0023bca4: (0x0023b694, '522d574541504f4e00000000000000004c2d574541504f4e0000000000000000524c2d574541504f4e00000000000000'), + 0x0023cdb4: (0x0023c7a4, '522d574541504f4e00000000000000004c2d574541504f4e0000000000000000524c2d574541504f4e000000000000005a49472d524148540000000000000000'), + 0x0023d484: (0x0023ce74, '522d574541504f4e00000000000000004c2d574541504f4e0000000000000000524c2d574541504f4e000000000000005a49472d524148540000000000000000'), + 0x0019db28: (0x0019d5f8, 'd91c8554b24503'), + 0x0019db81: (0x0019d651, 'd91c8554b24503'), + 0x0019e0c2: (0x0019db92, 'd91c8554b24503'), + 0x0019e0f9: (0x0019dbc9, 'd91c8554b24503'), } # SITES OEM END # SITES JP BEGIN JP.sites = { + 0x000041b7: (0x000041b7, '813d6818a0009a000000'), + 0x00005775: (0x00005775, '558bec535657'), + 0x0000593f: (0x0000593f, 'c7056818a00000000000'), + 0x0000594e: (0x0000594e, '558bec83ec44535657'), + 0x000061f4: (0x000061f4, '833d6818a000000f8df7000000'), + 0x000062fc: (0x000062fc, 'e841d1ffff'), + 0x00006321: (0x00006321, 'a18417a000a3283d4103'), + 0x00006335: (0x00006335, '833d6818a000000f8d2d060000'), + 0x0000655f: (0x0000655f, 'e859f1ffff'), + 0x000066c6: (0x000066c6, 'e8f2efffff'), + 0x000068b3: (0x000068b3, 'e805eeffff'), + 0x00007928: (0x00007928, '8b450833c98a883b010000'), + 0x00102083: (0x00101913, 'b980010000'), + 0x00102593: (0x00101e23, 'b980010000'), + 0x00103357: (0x00102be7, 'b980010000'), + 0x001033dd: (0x00102c6d, 'b980010000'), + 0x001034cd: (0x00102d5d, 'b980010000'), + 0x00103553: (0x00102de3, 'b980010000'), + 0x0010360b: (0x00102e9b, 'b980010000'), + 0x00103686: (0x00102f16, 'b980010000'), + 0x00106baf: (0x0010643f, 'b980010000'), + 0x00106c39: (0x001064c9, 'b980010000'), + 0x001072a8: (0x00106b38, 'b980010000'), + 0x001029ed: (0x0010227d, 'b980010000'), + 0x000071d1: (0x000071d1, '558bec83ec0c535657'), + 0x00007ae0: (0x00007ae0, '558bec535657'), + 0x0006018b: (0x000600eb, 'e80d000000'), + 0x00061070: (0x00060fd0, 'a158f7ad018d04408d04800578ab5f00'), + 0x0006a969: (0x0006a869, 'a174bd4503'), + 0x000b2098: (0x000b2038, '833d240bae0100'), + 0x000b21b1: (0x000b2151, '833d240bae0100'), + 0x000b3bbe: (0x000b3b5e, 'ff055020ae01'), + 0x000b3e5b: (0x000b3e00, 'c705b021ae011c000000'), + 0x000cc723: (0x000cc6a3, 'e85844f9ff'), + 0x000cfc15: (0x000cf99c, '8305a862bf0002'), + 0x000cfc2f: (0x000cf9b6, '37'), + 0x000cfc31: (0x000cf9b8, '0afc9200'), + 0x000cfc45: (0x000cf9cc, '37'), + 0x000cfc47: (0x000cf9ce, '0afc9200'), + 0x000cfc53: (0x000cf9da, '8305a862bf000c'), + 0x000cfcb7: (0x000cfa3e, '8305a862bf0002'), + 0x000cfcd1: (0x000cfa58, '37'), + 0x000cfcd3: (0x000cfa5a, '0afc9200'), + 0x000cfce7: (0x000cfa6e, '37'), + 0x000cfce9: (0x000cfa70, '0afc9200'), + 0x000cfcf5: (0x000cfa7c, '8305a862bf000c'), + 0x000d087f: (0x000d0606, '8d0445c61bcc01'), + 0x000d08d7: (0x000d065e, '8d0445ce1bcc01'), + 0x000d094d: (0x000d06d8, '8d04451204cc01'), + 0x000d09b0: (0x000d073f, '8d04451a04cc01'), + 0x000d3991: (0x000d35ab, 'c745f81f000000'), + 0x000d39d5: (0x000d35ef, 'c745f81f000000'), + 0x000db986: (0x000db216, 'e805c9f2ff'), + 0x000f29a5: (0x000f2235, '86000000'), + 0x000f39b5: (0x000f3245, 'a1c4f7ad01'), + 0x000f3a2b: (0x000f32bb, '837df4000f844f000000'), + 0x000f3b9f: (0x000f342f, 'a1c4f7ad01'), + 0x000f3e48: (0x000f36d8, '837df4000f8423000000'), + 0x000f3ecd: (0x000f375d, '837df4000f8423000000'), + 0x000f3f3d: (0x000f37cd, '837df4000f8433000000'), + 0x000f3fcd: (0x000f385d, '837df4000f8433000000'), + 0x0010325f: (0x00102aef, 'e82c50f0ff'), + 0x0010d6d4: (0x0010cc34, '99f7f96689154aff6403'), + 0x0010d7b5: (0x0010cd15, '99f7f96689154aff6403'), + 0x0010e939: (0x0010de99, 'd91d3070bf00'), + 0x0010ede5: (0x0010e345, 'd91d3070bf00'), + 0x0010f06d: (0x0010e5cd, 'd91d3070bf00'), + 0x0010f32a: (0x0010e88a, 'd91d3070bf00'), + 0x0010f8a1: (0x0010ee01, 'c7053070bf0000000c42'), + 0x0010f8b0: (0x0010ee10, 'c7053070bf000000f041'), + 0x0010fb12: (0x0010f072, 'd91d3070bf00'), + 0x0010fbf7: (0x0010f157, 'd91d3070bf00'), + 0x0010fcf6: (0x0010f256, 'd91d3070bf00'), + 0x0010fedc: (0x0010f43c, 'd91d3070bf00'), + 0x00110109: (0x0010f669, 'd91d3070bf00'), + 0x0011297d: (0x00111edd, '8b45fc0fbf401e'), + 0x001129f8: (0x00111f58, '8b45fcd84840'), + 0x00112a2c: (0x00111f8c, '8b45fcd84840'), + 0x00112a60: (0x00111fc0, '8b45fcd84840'), + 0x001802cb: (0x0017f189, 'e89d06f9ff'), + 0x00189e7e: (0x00188d1e, '8b45f00500060000'), + 0x0018a4fd: (0x0018939d, 'e87ee7e7ff'), + 0x0018fc68: (0x0018eb08, '833d8cf4ac01000f854f000000'), + 0x0018fcba: (0x0018eb5a, 'e80db9ffff'), + 0x0018fd0f: (0x0018ebaf, 'c705b021ae0116000000'), + 0x0019bf93: (0x0019ae33, '558bec83ec30'), + 0x0019bff7: (0x0019ae97, '80046200'), + 0x0019c2e7: (0x0019b187, 'e00a6200'), + 0x0019c6ab: (0x0019b54b, '200b6200'), + 0x0019c850: (0x0019b6f0, 'e00a6200'), + 0x0019c973: (0x0019b813, 'e00a6200'), + 0x0019caaa: (0x0019b94a, 'e00a6200'), + 0x0019cbf3: (0x0019ba93, 'e00a6200'), + 0x0019cd94: (0x0019bc34, 'e89d72f7ff'), + 0x0019cfeb: (0x0019be8b, 'a158f7ad01'), + 0x0019d413: (0x0019c2b3, 'a1a0f5ac01'), + 0x0019d80b: (0x0019c6ab, 'dc05700d6200'), + 0x0019d8e5: (0x0019c785, 'e8056200'), + 0x0019db28: (0x0019c9c8, 'd91c85e49d4503'), + 0x0019db81: (0x0019ca21, 'd91c85e49d4503'), + 0x0019dc03: (0x0019caa3, 'e8056200'), + 0x0019dd4a: (0x0019cbea, 'e8056200'), + 0x0019df8a: (0x0019ce2a, 'e8056200'), + 0x0019e0c2: (0x0019cf62, 'd91c85e49d4503'), + 0x0019e0f9: (0x0019cf99, 'd91c85e49d4503'), + 0x0019e209: (0x0019d0a9, 'e8056200'), + 0x0019e241: (0x0019d0e1, '3b048db09d4503'), + 0x0019e3f8: (0x0019d298, 'f0056200'), + 0x0019e590: (0x0019d430, 'f0056200'), + 0x0019e728: (0x0019d5c8, 'f0056200'), + 0x0019e8cf: (0x0019d76f, 'f0056200'), + 0x0019eae2: (0x0019d982, 'f0056200'), + 0x0019ec20: (0x0019dac0, '833c854ca8450300'), + 0x0019f30f: (0x0019e1af, 'e89ccaffff'), + 0x0019f317: (0x0019e1b7, 'b8eb040000'), + 0x0019f476: (0x0019e316, '833c8588a8450307'), + 0x0019f4cc: (0x0019e36c, '833d50d76b0000'), + 0x0019f6a5: (0x0019e545, 'f0056200'), + 0x0019f6f4: (0x0019e594, 'dc25800d6200'), + 0x0019f71e: (0x0019e5be, 'dc25800d6200'), + 0x0019f780: (0x0019e620, 'dc05800d6200'), + 0x0019f7aa: (0x0019e64a, 'dc05800d6200'), + 0x0019f8bd: (0x0019e75d, 'f0056200'), + 0x0019f8c1: (0x0019e761, 'a358f7ad01a158f7ad01'), + 0x0019f8ec: (0x0019e78c, 'f0056200'), + 0x0019f91f: (0x0019e7bf, 'f0056200'), + 0x0019f9be: (0x0019e85e, '837dac0a0f8d17000000'), + 0x0019fc26: (0x0019eac6, '83e007'), + 0x0019fc2c: (0x0019eacc, 'f0056200'), + 0x0019fc3d: (0x0019eadd, 'e80b6200'), + 0x0019fc64: (0x0019eaf2, 'e40b6200'), + 0x0019fc97: (0x0019eb24, 'e80b6200'), + 0x0019fccb: (0x0019eb59, 'e00b6200'), + 0x001a08eb: (0x0019f78b, 'e886feffff'), + 0x001a08f3: (0x0019f793, 'b8eb040000'), + 0x001a0a52: (0x0019f8f2, '833c8588a8450307'), + 0x001a0aa8: (0x0019f948, '833d50d76b0000'), + 0x001a0c81: (0x0019fb21, 'f0056200'), + 0x001a0e80: (0x0019fd20, 'f0056200'), + 0x001a0e84: (0x0019fd24, 'a358f7ad01a158f7ad01'), + 0x001a0eaf: (0x0019fd4f, 'f0056200'), + 0x001a0ee2: (0x0019fd82, 'f0056200'), + 0x001a0f81: (0x0019fe21, '837dac0a0f8d17000000'), + 0x001a171d: (0x001a05bd, 'c705a89d450330066200'), + 0x001a1764: (0x001a0604, 'e847a6ffff'), + 0x001a17ec: (0x001a068c, '8b048510066200'), + 0x001a18a5: (0x001a0745, '8b048588a84503'), + 0x001a18fb: (0x001a079b, 'e88bf0f6ff'), + 0x001b642c: (0x001b52cc, '0fbf403085c00f851a000000'), + 0x001b7f80: (0x001b6e20, 'e83113ebff'), + 0x001b80c8: (0x001b6f68, '558bec83ec04535657'), + 0x001b82b8: (0x001b7158, 'e818e6e4ff'), + 0x001b830d: (0x001b71ad, 'e8c3e5e4ff'), + 0x001beb70: (0x001bda10, 'e8161ef5ff'), + 0x001c1622: (0x001c04c2, 'e829e7ecff'), + 0x001c5b79: (0x001c4a62, 'e8b3fdffff'), + 0x001c5bbb: (0x001c4aa4, 'e871fdffff'), + 0x001d39b1: (0x001d2891, '8b3534a26d00'), + 0x001d4704: (0x001d35e4, '8b3534a26d00'), + 0x001d4ebb: (0x001d3d9b, 'a320747000'), + 0x0015c93e: (0x0015b79e, '68a0077900'), + 0x0015cb77: (0x0015b9d7, '68a0077900'), + 0x0015cdb0: (0x0015bc10, '68a0077900'), + 0x0015ce2b: (0x0015bc8b, '5f5e5bc9c3'), + 0x001de8c1: (0x001dd7a1, '8b3534a26d00'), + 0x001df654: (0x001de534, '8b3534a26d00'), + 0x001fe638: (0x001fd430, '4f084600'), + 0x0023b5d4: (0x0023a14c, '522d574541504f4e00000000000000004c2d574541504f4e0000000000000000524c2d574541504f4e00000000000000'), + 0x0023bca4: (0x0023a81c, '522d574541504f4e00000000000000004c2d574541504f4e0000000000000000524c2d574541504f4e00000000000000'), + 0x0023cdb4: (0x0023b92c, '522d574541504f4e00000000000000004c2d574541504f4e0000000000000000524c2d574541504f4e000000000000005a49472d524148540000000000000000'), + 0x0023d484: (0x0023bffc, '522d574541504f4e00000000000000004c2d574541504f4e0000000000000000524c2d574541504f4e000000000000005a49472d524148540000000000000000'), + 0x002bb008: (0x002b9900, '5a2d475241542020202020004a41474152414e4449202000'), 0x002bba60: (0x002ba358, '0f'), 0x00189546: (0x001883e6, '2256'), 0x00189552: (0x001883f2, '88580100'), @@ -5776,25 +7171,10536 @@ def annex_place(size, sections): '0000007507d83d00000000c3d83d00000000c3833dae000000007507d83d0000' '0000c3d83d00000000c30000000000000000' ), ( - (0x9, 'abs', '.', 170), - (0x28, 'abs', '.', 174), - (0x47, 'abs', '.', 170), - (0x66, 'abs', '.', 174), - (0x7e, 'abs', '.', 170), - (0x87, 'abs', 'PROJA', 0), - (0x8e, 'abs', 'PROJA2D', 0), - (0x95, 'abs', '.', 174), - (0x9e, 'abs', 'PROJB', 0), - (0xa5, 'abs', 'PROJB2D', 0), + (0x9, 'abs', '.', 170), + (0x28, 'abs', '.', 174), + (0x47, 'abs', '.', 170), + (0x66, 'abs', '.', 174), + (0x7e, 'abs', '.', 170), + (0x87, 'abs', 'PROJA', 0), + (0x8e, 'abs', 'PROJA2D', 0), + (0x95, 'abs', '.', 174), + (0x9e, 'abs', 'PROJB', 0), + (0xa5, 'abs', 'PROJB2D', 0), + ), { + 'quad2d_a': 0x0, + 'quad2d_b': 0x1f, + 'walk_a': 0x3e, + 'walk_b': 0x5d, + 'clipproj_a': 0x7c, + 'clipproj_b': 0x93, + 'flag_a': 0xaa, + 'flag_b': 0xae, + }), + 'BOSSES': (bytes.fromhex( + '60e8481c0000e8ba1d0000e870150000e8d10c0000c705e03900000000000031' + 'd20fb7050000000083f820720683f8307301428b0d583a00008915583a000085' + 'c9740b85d2756be81b0d0000eb6485d27460e8ed130000c7055c3a0000000000' + '00c705303b000000000000c705383b000000000000c705343b000000000000c7' + '05ac39000000000000c7059640000000000000c6055839000000e87328000083' + '3d0000000007760ac70500000000000000000fb7050000000083e81083f81073' + '13833d0000000004770ac7055c3a000000000000833d00000000007509c6059e' + '40000000eb52803d9e400000007549a16400000083f808740e83f809753a833d' + '000000005a7231c6059e40000001be00000000bf54bf0200b980010000fcf3a5' + '565751be00000000bf54c50200b900000000fcf3a5595f5e833d000000000075' + '0e85d2740ae81e0b0000e83a08000061e9fcffffffb900000000833d00000000' + '007405b900000000ba00000000c7055c3a000000000000833d00000000007524' + '83f808721f890d683a00005052e8af0e0000a3603a00008915643a00005a58a3' + '5c3a00008902c360803d5c3f0000000f852e010000be00000000bf44340200b9' + '78000000fcf3a5beb0010000bf24360200b90c000000fcf3a5beb0010000bf54' + '360200b90c000000fcf3a5bee0010000bf84360200b9a8000000fcf3a5bb2436' + '0200c7431010000000d9431cd8056c3a0000d9531cd8057c3a0000d95b4cd943' + '48d805803a0000d95b48c7434012000000be00000000bf4c310200b930000000' + 'fcf3a5be50000000bf14320200b904000000fcf3a5be00000000bf3c320200b9' + '08000000fcf3a5be00000000bfdc320200b908000000fcf3a5b8ffffffffa35c' + '320200a360320200a3fc320200a300330200be00000000bf64320200b9180000' + '00fcf3a5be443f0000bfc4320200b903000000fcf3a5be443f0000bfd0320200' + 'b903000000fcf3a5a120000000a30c320200a11c000000a310320200c6055c3f' + '000001b800000000c7054831020000000000833d0000000000750fb844340200' + 'c7054831020001000000a30000000061c3b80a000000833d4831020000740383' + 'c0023945ac7d01c383c404e9fcffffff51b907000000833d0000000000750603' + '0dc5380000390c850000000059c383f8087210833d00000000007501c3b80700' + '0000c38b048500000000c3508b45086bc0548b800000000083f808730958833d' + '0000000000c3833d00000000007441518d0c85783a0000a0000000000a050100' + '0000a820740cff097919c70140000000eb11a8107419ff018339417206c70100' + '000000606a01e8fcffffff83c40461595839c0c3837c24040873105589e583ec' + '30e902000000e9390e0000833d000000000075f28b44240483e8073b05c53800' + '0077e3a1c03a000085c07e063b44240475d48b442404e89b0a0000b805000000' + '837c2404097505b809000000e8190d0000e8970d00008b442404e8360b0000e8' + 'd3090000837c2404097507e8b4000000eb26c605403f000001ff742410ff7424' + '10ff742410ff742410e86dffffff83c410c605403f000000c605c43a000000e9' + 'a00d0000803d403f0000000f84fcffffff837de8070f85fcffffffff742410ff' + '742410ff742410ff742410e8fcffffff83c410e8fcffffffff35583f0000ff35' + '543f0000ff35503f0000e8fcffffff83c40c6a03e8fcffffff83c404e8fcffff' + 'ffa1180000006a00ff7014ff7010ff700ce8fcffffff83c410e8fcffffffe8fc' + 'ffffffc360e8fcffffff833d5c3a000009754c833da80300000275436a00ff35' + '283b00006a00e8fcffffff83c40c83ec04d905303b0000db1c24e8fcffffffff' + '35343b0000e8fcffffff83c4086a00ff352c3b00006a00e8fcffffff83c40cff' + '35843a0000ff35843a0000ff35843a0000e8fcffffff83c40ce80a030000be20' + '3d000031ff833d5c3a000009754d833da8030000027544a19c0300008d8850ff' + 'ffff85c97c2083f91e7d0a8d3c09be283d0000eb1b83f93c7d0c8d79e201ffbe' + '303d0000eb0a0fb74e0431d2f7f189d70fb74e0439cf72038d79ff6a006a0157' + '68c428020068f8280200ff351000000056e8fcffffff83c41c6bff1a83c7196b' + 'ff14033eff7710ff770cff7708e8fcffffff83c40c0fbf470450e8fcffffff0f' + 'bf4702890424e8fcffffff0fbf07890424e8fcffffff83c404be603b0000833e' + '00745681feb03b0000750ae8fcffffffe85a010000e8fcffffffff760cff7608' + 'ff7604e8fcffffff83c40cff7610e8fcffffff83c404e8fcffffff8b066a00ff' + '7008ff7004ff30e8fcffffff83c410e8fcffffff83c614eba5e8fcffffff833d' + '5c3a0000090f85f8000000a19c030000833da8030000020f85e60000003db000' + '00000f8edb000000833d1c0000000075106a016a006aff6a03e8fcffffff83c4' + '1031dbe8fcffffff6a00ff35503b00006a00e8fcffffff83c40c53e8fcffffff' + '83c404a19c0300002db000000083f8147605b814000000ff35743a000050db04' + '24da355c3b0000d91c24ff35743a0000e8fcffffff83c40cff35543b0000e8fc' + 'ffffff83c404ff35583b0000ff35583b0000ff35583b0000e8fcffffff83c40c' + 'e8fcffffffa19c0300004883e0038d0440c1e00203050c0000006a00ff7008ff' + '7004ff30e8fcffffff83c410e8fcffffff81c30040000081fb008000000f8240' + 'ffffffe8fcffffffe8fcffffff61c38b0d383b000085c90f84ba00000083ec04' + 'a10000000083e9187e4d89c2c1e20b8d1452890c24db0424d80d3c3b0000e895' + '000000db1c24e8fcffffffa10000000089c2c1e20c8b0d383b000083e918890c' + '24db0424d80d403b0000e869000000db1c24e8fcffffffa10000000089c2c1e2' + '0a8d1452db05383b0000d80d403b0000e843000000db1c24e8fcffffff83c404' + 'a10000000083c00a8d14c50000000029c2c1e20a6a00db05383b0000d80d443b' + '0000e81100000083ec04d91c246a00e8fcffffff83c40cc352df0424d80d483b' + '0000d9fedec95ac3803dcc3c0000000f859a000000c605cc3c0000016068d43c' + '0000680000000068000000006804330200e8fcffffff83c4106a006880000000' + '6a036a006a0168000000806804330200ff150000000083f8ff745389c3bee03c' + '0000833e0074406a006a00ff3653ff15000000006a0068d03c0000ff7604ff76' + '0853ff15000000008b46043905d03c000075148b7e0c8b460889078b46106689' + '470483c614ebbb53ff150000000061c3dc0500000000837d0c0a742d837d0c0b' + '7533dd0500000000d825783a0000d80d6c3a0000d835783a0000d8057c3a0000' + 'dc2500000000dec1c3d8056c3a0000d825783a0000c3833c85c4ffffff007408' + '833c85000000000bc3833d5c3a0000090f856e010000ba9c030000837a0c020f' + '855f010000833d383b0000007406ff0d383b00008b022db00000007f2b83f8d8' + '751dc705383b000020000000526a14e8fcffffff6a1ce8fcffffff83c4085a8b' + '4238a34c3b0000c383f801750e50526a19e8fcffffff83c4045a5883f829750e' + '50526a07e8fcffffff83c4045a58d905803a000089c183f9287605b928000000' + '51db042459d80df43a0000dec183f828760bd905fc3a0000e8c8000000d905f8' + '3a0000d86238d9eedff17204ddd8eb498105343b000000020000d905083b0000' + 'e8a0000000d9c0d80d0c3b0000d905103b0000dbf17204ddd8eb02ddd9deead8' + '25143b0000d9eedff17204ddd8eb0adcc8d80d183b0000dec1d9c0d86234d9c9' + 'd95a34d94238d9c0d8254c3b0000d9c9d91d4c3b0000d9c1d9f3d80d203b0000' + 'd825303b0000d80d243b0000d805303b0000d91d303b0000d80d1c3b000031c9' + '83b9000000000b750ed981d8ffffffd8c1d999d8ffffff83c15481f9a8000000' + '72deddd8c3d94238d8e1d95a3831c983b9000000000b750ed981dcffffffd8e1' + 'd999dcffffff83c15481f9a800000072deddd8c3833d00000000097536817dfc' + 'e00000007c2dc7050000000001000000d905f83a0000d825043b0000d81dd403' + '0000dfe0f6c401750ac7050000000000000000a100000000c381f9e700000074' + '083b048d00000000c350d905f83a0000d825003b0000d81c8d38000000dfe0f6' + 'c4017517d9eed81c8d34000000dfe0f6c401750731c083f80158c331c039c058' + 'c33de70000007408d91c8534000000c3ddd8c3528d1485000000008b0283f808' + '7274d905703a0000d80d783a0000d825783a000083f809754ad905883a0000d8' + '0d783a0000d825783a0000dec1d9058c3a0000d80d783a0000d842ecd95aecd9' + '05903a0000d80d783a0000d842d8d95ad8d905943a0000d80d783a0000d842fc' + 'd95afcd9c0d842f0d95af0d842dcd95adcb8070000005ac3a10000000083f808' + '7205b803000000c3803d5c3f0000007463e85f000000755c8b1dc03a000083fb' + 'ff745185db740abeb83a0000e9a7010000803db03a0000007513c605b03a0000' + '0131f6bfbc630300e8d5000000bb08000000bea03a00008d43f93b05c5380000' + '77125356e86f0100005e5b83c6084383fb0976e3c3833d00000000047407833d' + '0000000005c3e8eaffffff754ea1c03a000085c0754231c06bc85483b9b40000' + '000274114083f80976eec705b43a000000000000c38b15b43a0000c705b43a00' + '000100000085d2751183f8087305b8ffffffffa3c03a0000eb2dc3c705c03a00' + '0000000000c705b43a0000ffffffffeb163b05c03a000074088d34c5603a0000' + 'c3beb83a0000c3803db03a0000007411c605b03a000000bebc630300e8010000' + '00c3fcbba03a00008b13c1e20981c20000000031c05657b98000000085f67404' + '89d7eb0289d6f3a55f5e85f6740881c600020000eb0681c70002000081c20040' + '00004083f80372cd83c30481fbb03a000072b5c3fc31c089c1c1e10e8d918002' + '00008db1000000008b0bc1e1098dbc0e8000000089d6b920000000f3a581c680' + '00000081c780000000b920000000f3a54083f80372c1c3833dc03a0000007f09' + '803db03a000000740e6089c3e820ffffffe80200000061c35389f3e894ffffff' + '83c304e88cffffff83eb0489de5b8b3e8b760489d8e8e701000085d27519c1e3' + '025357e8fcffffff83c408435356e8fcffffff83c408c35631c9833d00000000' + '007405b9020000008d34818d34b5000000008d5c12fe8b06ff349857e8fcffff' + 'ff83c4088b46045fff74980457e8fcffffff83c408c3608b0d010000008d8905' + '00000081f9000000000f84a400000081e9000000008b54242429ca81fa001c00' + '000f838c000000bed03a000083f8097505bed83a00008b45086bc054d9800000' + '00008b450c6bc054d8a838000000d9ee8b1685d2741fd902dbf2730fdceaddd8' + 'd805783a000083c604ebe5defad9c9d80d783a0000dec1d82de43a0000d80de8' + '3a0000d9e8dff1761ed905ec3a0000dbf17204ddd9eb02ddd8d80df03a0000db' + '99641e0000eb0cddd8c781641e00000000000061c360e8d6fdffff8b1ebfc83a' + '0000e8140000008b5e0483c704e809000000c605c43a00000161c369c3080808' + '00b92000000039048d00000000740c4181f90004000072ee5861c3890fc38b35' + '00000000803dc43a0000007501c39c50518b4a040fb74106c1e8068b04850000' + '00003d0808080074433d28282800743c3d18181800742e3d3838380074275231' + 'c969148da03a00000808080039d074094183f90472eb5aeb245af7c101000000' + '8b4a047407a1cc3a0000eb05a1c83a0000c1e006668361063f6609410659589d' + 'c38b0485783a000031d285c0740a48b908000000f7f142c3c350e8de00000083' + 'f808753e508b45086bc054d980ecffffffd8258c3a0000d998ecffffffd980d8' + 'ffffffd825903a0000d998d8ffffffd980fcffffffd825943a0000d998fcffff' + 'ff585850e89400000083f808740d83f8077410d825743a000058c3d825883a00' + '0058c3d825703a000058c350e86c00000083f809753e508b45086bc054d980ec' + 'ffffffd8058c3a0000d998ecffffffd980d8ffffffd805903a0000d998d8ffff' + 'ffd980fcffffffd805943a0000d998fcffffff585850e82200000083f809740d' + '83f8087410d805743a000058c3d805883a000058c3d805703a000058c38b4508' + '6bc0548b8000000000c36089c580bd38340200007575c6853834020001ff34ed' + '04000000e8fcffffff83c40485c0745b89c6ff34ed0000000068000000006800' + '0000006804330200e8fcffffff83c41068000000006804330200e8fcffffff83' + 'c40885c0742589c3536a01ff34ed0400000056e8fcffffff83c41053e8fcffff' + 'ff83c4048934ad0834020061c360803d70400000007521a11c34020085c07418' + 'ff35140000008f0572400000a314000000c6057040000001803d714000000075' + '21a12c34020085c07418ff35240000008f0576400000a324000000c605714000' + '000161c3803d70400000007413c6057040000000ff35724000008f0514000000' + '803d71400000007413c6057140000000ff35764000008f0524000000c38b4424' + '0483f8087d1e85c00f8cfcffffff56e835010000ba7a400000e84d0100005ee9' + 'fcffffff53568d58f86bdb6881c3903f0000e81201000089dae82d0100006a10' + '6a07e8fcffffff83c4086a036a26e8fcffffff83c408ff7364ff7360ff735ce8' + 'fcffffff83c40c6a0e6a08e8fcffffff83c4088d435050e8fcffffff83c4045e' + '5bc38b44240483f808731985c00f8cfcffffff53bb7a400000e8700000005be9' + 'fcffffff538d58f86bdb6881c3903f00006affe8fcffffff83c404e84e000000' + 'a10000000083c002506a07e8fcffffff83c4086a036a26e8fcffffff83c408ff' + '7364ff7360ff735ce8fcffffff83c40cff35000000006a08e8fcffffff83c408' + '8d435050e8fcffffff83c4045bc3565789de31ffa10000000001f850ff350000' + '0000e8fcffffff83c40856e8fcffffff83c40481fe7a400000740383c61483c7' + '0283ff0872ce5f5ec3a100000000833d00000000027502d1e8be00000000a901' + '0000007405be00000000c35389d36a146a08e8fcffffff83c40853ffd683c404' + '81fb7a400000740383c3146a166a08e8fcffffff83c40853ffd683c40481fb7a' + '400000740383c3146a186a08e8fcffffff83c40853ffd683c40481fb7a400000' + '740383c3146a1a6a08e8fcffffff83c40853ffd683c40481fb7a400000740383' + 'c3145bc3fc31db6bf36e81c600000000668b560c69fb8a00000081c7f82c0200' + 'b937000000f366a56bf30681c67a13000031ede81300000081c68000000045e8' + '070000004383fb0872bdc36689d066abb906000000833d000000000075103b2d' + 'c5380000730889f066ab40e2fbc36689d0f366abc331c0833d00000000007515' + '833dc538000001720cb8040000007405b807000000c350e8d9fffffff7d883c0' + '0201050000000058c350e8c6ffffff83c00c01050000000058c3518d8c00bc17' + '0000e8aeffffff01c029c189c859c3518d8c00c4170000e899ffffff01c029c1' + '89c859c3518d8c0008000000e884ffffff01c029c189c859c3518d8c00100000' + '00e86fffffff01c029c189c859c350e861ffffff01c02945fcd1e883c01f8945' + 'f858c3b8eb040000833d0000000000750e833dc538000000740505b0040000c3' + 'e830ffffffc1e00350db042483c404dd0560400000d8e1dd1d00000000dd0568' + '400000dee1dd1d08000000c3ba00000000e81900000085c00f84fcffffff50ff' + '7508e8fcffffff83c408e9fcffffff31c08b4d0c89cbc1eb023b1d5c3a000075' + '39bb00000000f6c1027405bb000000003b1d683a000075228b1d643a000085db' + '74184b83e103a1603a00008d04818b048283e1018d0c598b0488c339c87c038d' + '41ff66a300000000c3833dd5380000007510837c2404080f844b030000e9a401' + '00008b44240483f8087305e9fcffffff60be00000000bf54b90200b980010000' + 'fcf3a5565751be00000000bf6cc70200b900000000fcf3a5595f5ebe00000000' + 'bf583c0400b9d8000000fcf3a5be00000000bfb83f0400b950010000fcf3a539' + '05b8c90200752abe54c90200bf00000000b980010000fcf3a5565751be54cf02' + '00bf00000000b900000000fcf3a5595f5eff3500000000ff3500000000ff3500' + '000000c7050000000001000000e8fcffffffbe09390000833d64000000097505' + 'be15390000ff36ff36ff36e8fcffffff83c40ca100000000d94024d84608d958' + '24568b3500000000bf3cc70200b90c000000fcf3a55ec6059a40000001bb0000' + '000031c08943088943108b460489430c53837b6409751966c7433400008b436c' + '85c07405a300000000e8be030000eb05e8f203000083c404c6059a40000000e8' + 'fcffffff8f05000000008f05000000008f0500000000beb83f0400bf00000000' + 'b950010000fcf3a5be583c0400bf00000000b9d8000000fcf3a5565751be6cc7' + '0200bf00000000b900000000fcf3a5595f5ebe54b90200bf00000000b9800100' + '00fcf3a561c38b44240483f8087305e9fcffffff60be00000000bf54b90200b9' + '80010000fcf3a5565751be00000000bf6cc70200b900000000fcf3a5595f5ebe' + '00000000bf583c0400b9d8000000fcf3a5be00000000bfb83f0400b950010000' + 'fcf3a53905b8bf0200752abe54bf0200bf00000000b980010000fcf3a5565751' + 'be54c50200bf00000000b900000000fcf3a5595f5eff3500000000ff35000000' + '00ff3500000000c7050000000001000000e8fcffffffbebc390000833d640000' + '00097505bec8390000ff36ff36ff36e8fcffffff83c40ca100000000d94024d8' + '4608d95824568b3500000000bf3cc70200b90c000000fcf3a55ec6059a400000' + '01bb0000000031c08943088943108b460489430c53837b6409751966c7433400' + '008b436c85c07405a300000000e8fcffffffeb03ff530483c404c6059a400000' + '00e8fcffffff8f05000000008f05000000008f0500000000beb83f0400bf0000' + '0000b950010000fcf3a5be583c0400bf00000000b9d8000000fcf3a5565751be' + '6cc70200bf00000000b900000000fcf3a5595f5ebe54b90200bf00000000b980' + '010000fcf3a561c38b44240483f8087305e9fcffffff60be00000000bf54b902' + '00b980010000fcf3a5565751be00000000bf6cc70200b900000000fcf3a5595f' + '5ebe00000000bf583c0400b9d8000000fcf3a5be00000000bfb83f0400b95001' + '0000fcf3a53905b8bf0200752abe54bf0200bf00000000b980010000fcf3a556' + '5751be54c50200bf00000000b900000000fcf3a5595f5eff3500000000ff3500' + '000000ff3500000000c7050000000001000000e8fcffffffbed4390000833d64' + '000000097505bec8390000ff36ff36ff36e8fcffffff83c40ca100000000d940' + '24d84608d95824568b3500000000bf3cc70200b90c000000fcf3a55ec6059a40' + '000001bb0000000031c08943088943108b460489430c53837b6409751966c743' + '3400008b436c85c07405a300000000e8fcffffffeb05e8ac00000083c404c605' + '9a40000000e8fcffffff8f05000000008f05000000008f0500000000beb83f04' + '00bf00000000b950010000fcf3a5be583c0400bf00000000b9d8000000fcf3a5' + '565751be6cc70200bf00000000b900000000fcf3a5595f5ebe54b90200bf0000' + '0000b980010000fcf3a561c3538b5c2408b809000000e80ff6ffffe88df6ffff' + 'e8fcffffffff7310ff730cff7308e8fcffffff83c40ce8a9e9ffffe8fcffffff' + 'e8bff6ffff5bc3833dd53800000974bc538b5c2408b805000000e8cbf5ffffe8' + '49f6ffffe8fcffffffff7310ff730cff7308e8fcffffff83c40cc605403f0000' + '016a006a006a006a08e82de8ffff83c410c605403f000000e8fcffffffe862f6' + 'ffff5bc3803d9a40000000750b5589e5535657e9fcffffff565751be3cc70200' + '8b3d00000000b90c000000fcf3a5595f5ec3803d9a40000000750aa100000000' + 'e9fcffffffe9fcffffff803d9a40000000750f813d000000009a000000e9fcff' + 'ffffe9fcffffffa10000000083f808741183f80974128d04408d048005000000' + '00c3b873380000c3b881380000c3803dc938000000754f60c605c93800000168' + '00000000688c380000e8fcffffff83c40885c0743089c3536a016a0468c53800' + '00e8fcffffff83c41053e8fcffffff83c404833dc538000002760ac705c53800' + '000000000061c3606800000000688c380000e8fcffffff83c40885c0741d89c3' + '536a016a0468c5380000e8fcffffff83c41053e8fcffffff83c40461c30fb705' + '080100008705f0390000833d00000000050f8cc3000000833d0000000009740d' + '833d00000000000f8dad000000b900000000833d96400000007405b924410200' + '83b900000000007c0bc705f439000000000000c33d06020000741566813d0801' + '00000602750ac705f439000001000000833df4390000007460d90508000000d8' + '2508000000d90510000000d82510000000d9f3d835483b0000db1df8390000a1' + 'f8390000662b0584010000983d000200007e07b800020000eb183d00feffff7d' + '07b800feffffeb0ac705f43900000000000066010584010000c3c705f4390000' + '00000000c360a1000000004883f8017714c705cd38000001000000c705d13800' + '0000000000803d00000000027509833d0000000000740ac705cd380000000000' + '00833d000000001f7513833d0000000009750ac705d138000001000000a10000' + '000083f804751d0fb70d0000000083e92083f9100f8392000000e8ec000000e9' + '8800000083f80a740583f80b757e833d00000000007509c6052939000000eb52' + '803d29390000007549a16400000083f808740e83f809753a833d000000005a72' + '31c6052939000001be00000000bf54c90200b980010000fcf3a5565751be0000' + '0000bf54cf0200b900000000fcf3a5595f5e833d5c3a0000097511e81dfeffff' + '66a18401000066a31a00000061c38db4000000000083f84472078db40078ffff' + 'ff0fb70e31f6f7c1ff3f0000743c89cef7c100400000741181e6ff3f0000c1e6' + '07033500000000eb0f81e6ff7f0000c1e60703350000000081fe80ffffff7708' + '81fe00104000730231f6c360fc31db89d8e898ffffff85f6741289dfc1e70781' + 'c73cd10200b920000000f3a54381fb9200000072dac605e53800000161c360fc' + '803de5380000000f84aa000000803de938000000755dbf3c1a0300a100000000' + '29f883e07f01c789fd2b2d000000000f8282000000c1ed078d85920000003d00' + '4000007372be3cd10200b940120000f3a5892ded3800008b0d00000000890df1' + '38000039c87605a300000000c605e9380000018b2ded38000031dbba44000000' + '833dd538000008740abb44000000ba92000000bfbc3b040089d8e8cffeffff31' + 'c0f7c1ff3f000074048d441d0066ab4339d372e461f8c361f9c3803de9380000' + '00741350a1f1380000a300000000c605e93800000058c3803da240000000751b' + '60fcbe00000000bfbc7b0300b900300000f3a5c605a24000000161c3803da240' + '000000741b60fcbebc7b0300bf00000000b900300000f3a5c605a24000000061' + 'c360fc833daa4000000075166804380f00e8fcffffff83c404a3aa40000085c0' + '74598b3daa400000be00000000b980010100f3a5be00000000b910190200f3a5' + 'be00000000b971b30000f3a5a100000000a3be400000a100000000a3b2400000' + 'a100000000a3b6400000a100000000a3ba400000c605ae4000000161c3803dae' + '40000000746660fc8b35aa400000bf00000000b980010100f3a5bf00000000b9' + '10190200f3a5bf00000000b971b30000f3a5a1be400000a300000000a1b24000' + '00a300000000a1b6400000a300000000a1ba400000a300000000a1a6400000a3' + '00000000c605ae4000000061c3837c240801750b508b442408a3c640000058e9' + 'fcffffff833d00000000007510803d00000000027507833dcd38000001c3ff05' + '00000000c705cd38000000000000c3c705000000001c000000e8c6ffffff7535' + '833dc538000000752c833d64000000087523c705c538000001000000e8c6faff' + 'ffc705d538000008000000c705d938000000000000c3833dd1380000007461c7' + '05d138000000000000e876ffffff7550833dc5380000017547c705c538000002' + '000000e87ffaffffa100000000a3a6400000a1c6400000a3c2400000e840feff' + 'ffc705d538000009000000c705d938000000000000c705000000001c000000c3' + 'c7050000000016000000c3833dd5380000007505e9fcffffffc3833dd5380000' + '007505e9fcffffff60833dd9380000000f859a000000681a100000e8fcffffff' + '83c404c705dd38000010010100c605e138000000e87efdffff8b1dd5380000c1' + 'e3028d03506a01e8fcffffff83c4088d4301506a03e8fcffffff83c4088d4302' + '506a05e8fcffffff83c4088d4303506a07e8fcffffff83c408a1d53800008d3c' + 'c5603a00008d0350ff37e8fcffffff83c4088d430150ff7704e8fcffffff83c4' + '086a00e8fcffffff83c404e8fcffffff833dd93800001e75306a00e8fcffffff' + '83c404e8fcffffffff35f9380000ff35f5380000e8fcffffff83c40868973800' + '00e8fcffffff83c404833dd93800003c7541e8e7fbffff723a8b1dd538000083' + 'eb08ff3505390000ff349dfd380000e8fcffffff83c4086bdb6881c3903f0000' + 'ff7364ff736068bc3b0400e8fcffffff83c40c803de1380000007543db05d938' + '0000d80dbd380000d905c1380000dbf1dbc1ddd983ec04d91c24ff3500000000' + 'a1d5380000a300000000ff742404e8fcffffff83c4048f050000000083c404a1' + 'd93800002d2c010000727ba91f000000753989c3ff3525390000ff3521390000' + 'e8fcffffff83c408f7c320000000750f68a4380000e8fcffffff83c404eb0c6a' + '026a34e8fcffffff83c408a1000000002510010100803de13800000075248b0d' + 'dd380000a3dd380000f7d185c87417c605e1380000016a12e8fcffffff83c404' + 'eb0485c07408ff05d938000061c36a00e8fcffffff83c404e8fcffffffe878fb' + 'ffffe8b5fbffff6a00e8fcffffff83c404c70500000000ffffffff6a016aff6a' + '0ae8fcffffff83c40cc705d938000000000000a1d5380000c705d53800000000' + '0000c705000000001c00000083f8087432e807fcffff6a01ff35c2400000e8fc' + 'ffffff83c40866c705000000009100c7050000000081000000c7050000000016' + '00000061c3a10000000083f8080f83fcffffffe9fcffffff833d00000000080f' + '83fcffffff837df4000f84fcffffffe9fcffffffa10000000083f8080f83fcff' + 'ffffe9fcffffffa10000000083e80883f801762a813d0000000000000000741e' + '813d00000000000000007412833d00000000000f85fcffffffe9fcffffffa100' + '00000083f8087205a3ac390000833d0000000000750fc7050000000003000000' + 'e9fcffffffa1ac39000085c07405a300000000833d00000000020f82fcffffff' + '0f84fcffffffe9fcffffff833d00000000097405e9fcffffff813d000000009e' + '0200007510ff0500000000c7050000000001000000813d00000000b005000075' + '06ff050000000050b800000000833d96400000007405b8244102000500000000' + '833d00000000010f843d010000833d00000000020f8277020000c70500000000' + '07000000813804010000751f813d00000000e0000000731366833d7801000070' + '7c0966c705780100007000813d00000000e60000007377803d9439000000752f' + 'c6059439000001c705a039000000000000ff35000000008f059c390000d90500' + '000000d80da4390000d91d00000000ff05a8390000833da8390000037235c705' + 'a83900000000000051528d0d00020000ba200000008039cb750af64103807504' + '66ff490483c1204a75eb5a59eb05e8ff0100008b0d0000000081e93f0200007d' + '0658e9fcffffffe849090000c605b039000000c7055439000000000000c70580' + '3900000000000058ff350c000000ff3510000000d9050c000000d8055c390000' + 'd91d0c000000d90510000000d80560390000d91d10000000e8fcffffff8f0510' + '0000008f050c000000c3833d803900001f732a813d00000000ff000000751eff' + '058039000050a1803900000500020000a30000000058c6058e40000001803db0' + '390000007551833d5439000000752bc705543900000100000066c70570010000' + '060066c7057c010000000066c705780100000000c70000000000813802010000' + '0f8cb0000000c605b039000001c7055439000000000000c70002010000ff0554' + '3900005860beb0000000bff0400000b914000000fcf3a566a17801000066a340' + '41000066a1a401000066a34241000066c70578010000ff7fe8fcffffff66a140' + '41000066a37801000066a14241000066a3a4010000bef0400000bfb0000000b9' + '14000000fcf3a561813d54390000f00000007221c605b039000000c705543900' + '0000000000ff0500000000c7050000000002000000c358c70500000000000000' + '00e8fcffffffc7050000000001000000c3c6055839000000e835000000c605b0' + '39000000c7055439000000000000c705803900000000000058e9fcffffff803d' + '94390000000f84fcffffffd90598390000c3803d94390000007418c605943900' + '00005051a1a03900008b0d9c39000089085958c3833d0000000009740d8b45f0' + '0500000000e9fcffffffa10000000083e802a390390000db0590390000d80d84' + '390000d80510000000d8058c390000d91de8400000d9050c000000d805883900' + '00d91de4400000a108000000a3e0400000c745e4d0400000e9fcffffff833d00' + '000000087305e9fcffffff56be44390000833d00000000097521813d00000000' + '3f0200007d10833d00000000027d0cbe48390000eb05be4c390000d906813d00' + '0000003a0200007d3ad9442408d80524000000dcc8d944240cd80528000000dc' + 'c8dec1d9442410d8052c000000dcc8dec1d9fad83d50390000d8c9dbf17302d9' + 'c9ddd8d9442408d80524000000d8c9d82524000000d95c2408d944240cd80528' + '000000d8c9d82528000000d95c240cd9442410d8052c000000d8c9d8252c0000' + '00d95c2410ddd8b83a0200002b05000000007e4583f8407605b840000000a3b8' + '390000db05b8390000d80db4390000d9052c000000d8442410d8c9d905240000' + '00d8442408d8cad8442410d95c2410d86c2408d95c2408ddd85ee9fcffffff83' + '3d5c3a000009c3e8f3ffffff0f85fcffffff0fbf0d0000000051e8fcffffff83' + 'c404d80d30390000d8442404d95c24040fbf0d0000000051e8fcffffff83c404' + 'd80d30390000d86c240cd95c240ce9fcffffff833d5c3a00000872308b4dfcd9' + '413cd81d3c390000dfe0f6c4017408a13c39000089413ce883ffffff750e6681' + '791e000c7d0666c7411e000c8b45fc0fbf401ee9fcffffff8b45fcd94040833d' + '5c3a0000087508d80d38390000eb24833d5c3a000009751bd80d34390000d815' + '40390000dfe0f6c4017408ddd8d90540390000dec9c3833d5c3a000009751383' + '3d0000000009750a817c240400000000740b5589e5535657e9fcffffffc3833d' + '5c3a0000097513833d0000000009750a817c240400000000740e5589e583ec0c' + '535657e9fcffffff5589e583ec0c5356578b4508833d00000000057d39c68037' + '010000ff66c7800e010000000066c78072010000000066c780860100000000c7' + '80c4010000000000008b406ca300000000e9fcffffff8b406ca300000000e9fc' + 'ffffffc7050000000000000000c705f439000000000000833d5c3a000009753f' + '50518b45083d0000000075318b0d0000000083f90a73268b0c8dfc390000890d' + '0000000083e9787d0231c969c980000000f7d981c100400000668948345958c3' + '833d0000000000753a833d5c3a0000097532833d00000000097429833d000000' + '00007c20813dec390000580200007314ff05ec390000c7050000000001000000' + '83fc00c3c705ec39000000000000833d0000000000c38b450831c93d00000000' + '751b833d5c3a00000975128a884301000080f9ff740d8a8842010000c38a883b' + '010000c3833d00000000060f84fcffffff5589e583ec0cff7514ff7510ff750c' + 'ff7508e8fcffffff83c410d955fcd81d243a0000dfe0f6c4010f848c0000008b' + '45088d4df451ff7010ff700850e8fcffffff83c410d955f8d81d243a0000dfe0' + 'f6c401745ed945fcd865f8d815283a0000dfe0f6c44175438b45088b88c80100' + '008b90cc01000089c825ffffff7f5281e2ffffff7f39d05ab800400000720b85' + 'c97912b800c00000eb0b31c085d27805b8008000008b4d146689018b4508d840' + '0ceb0b8b4508d9400ceb03d945fcc9c3833d5c3a0000097509817d0800000000' + '7412833d00000000000f8dfcffffffe9fcffffff833d00000000050f8dfcffff' + 'ffe9fcffffff833d5c3a0000097509817d08000000007412833d00000000000f' + '8dfcffffffe9fcffffff833d00000000050f8dfcffffffe9fcffffff833d5c3a' + '000009751e833d000000000975153d000000000f84fcffffff837864090f84fc' + 'ffffff0fbf403085c00f85fcffffffe9fcffffff5589e581ec00000000535657' + '833d5c3a0000090f85fcffffff833d00000000090f85fcffffff8b45083d0000' + '00007405e9fcffffff8b486c85c90f84fcffffff81f9243902000f84fcffffff' + '81f9000000000f85fcffffff833d9240000000751989cebf24390200b9000200' + '00fcf3a5c70592400000010000008b706c8b787029f7c7406c243902008dbf24' + '390200897870e9fcffffff833d5c3a0000097513833d0000000009750a817c24' + '0400000000740e5589e583ec04535657e9fcffffff833d9640000000757e5657' + '51be00000000bf24410200b900000000fcf3a5595f5eba24410200c782000000' + '00ffffffffc78200000000ffffffffc78200000000ffffffffc7059640000001' + '000000508b44240883786800b8000000007405b80000000089820000000083c0' + '5889820000000005f001000089820000000083c01889820000000058565751be' + '00000000bf0c430200b900000000fcf3a5595f5e565751be24410200bf000000' + '00b900000000fcf3a5595f5eff742404e832ffffff83c404565751be00000000' + 'bf24410200b900000000fcf3a5595f5e565751be0c430200bf00000000b90000' + '0000fcf3a5595f5ec3c7059640000000000000ff742404e8fcffffff83c4048b' + '4424043d000000007401c366c780700100000000c381f9fb0000007e05b9fb00' + '0000c605583900000183f9357d48b83500000029c8a368390000db0568390000' + 'dcc8d80d6c390000d82d70390000d91d5c390000c705603900000000000069c0' + '80000000f7d805001800007d0231c066a364390000c3a170390000a35c390000' + '83e93583f9507d2b890d68390000db0568390000d80d74390000d9e0d91d6039' + '0000c1e10781c10018000066890d64390000c383e950890d68390000db056839' + '0000d80d78390000d8057c390000d9e0d91d6039000066c705643900000040c3' + '8b442404803db03900000175073d000000007415803d583900000074073d0000' + '00007413e9fcffffffe84900000050e8fcffffff58eb40ff700cff7010ff7034' + 'd9400cd8055c390000d9580cd94010d80560390000d95810668b0d6439000066' + 'f7d96689483450e8fcffffff588f40348f40108f400cc3515231c98b9408b000' + '00008791f0400000899408b000000083c10483f95072e4668b90780100006687' + '154041000066899078010000668b90a401000066871542410000668990a40100' + '005a59c38b44240483786408750d8078300575073d000000007405e9fcffffff' + 'ffb0c000000066c780c2000000000050e8fcffffff588f80c0000000c3a10000' + '0000a300000000c6058e40000000817d08000000007401c3c6058e40000001c3' + '803d8e400000007415813d683a0000000000000f84fcffffffe9fcffffff837d' + 'f4000f84fcffffffe9fcffffff803d8e4000000074488b1d5c3a000085db7505' + 'bb09000000c1e302be01000000813d683a000000000000750883cb02be050000' + '005356e8fcffffff83c4084383c6025356e8fcffffff83c408e9fcffffff837d' + 'f4000f84fcffffffe9fcffffff803d8e400000000f85fcffffff837df4000f84' + 'fcffffffe9fcffffff803d8e400000000f85fcffffff837df4000f84fcffffff' + 'e9fcffffffb9800100006089c2c1ea0969d2e003000081c2f4440200fc81ff00' + '000000754389d6bf00000000b900000000f3a58db2e8010000bf24410200b97a' + '000000f3a58b82d0030000a3964000008b82d4030000a3f43900008b82d80300' + '00a3f039000061c389d7be00000000b900000000f3a58dbae8010000be244102' + '00b97a000000f3a5a1964000008982d0030000a1f43900008982d4030000a1f0' + '3900008982d803000061c3528b55102b15140000003b152c00000073168b5510' + '8b52fcc1ea1283e21f83fa0075052d008000005aa300000000c3837dfc000f84' + '06010000833d5c3a0000090f85f9000000817d08000000000f85ec000000e8ec' + '000000d80d53360000d91d3cb90200e89e010000e8fcffffffe8fcffffff6800' + '00803f68f6285cbe68898888bde8fcffffff83c40cb86f12033b833d44b90200' + '007405b8a69bc43b680000803f50680e74da3ae8fcffffff83c40c680000803f' + 'ff354cb90200ff353cb90200e8fcffffff83c40c6a006a00680000803fe8fcff' + 'ffff83c40ce8fcffffff6a016800000000ff3538b902006a00e8fcffffff83c4' + '10e8fcffffff6a236a1ae8fcffffff83c408833d40b9020000740c6a01e8fcff' + 'ffff83c404eb236a00e8fcffffff83c4046a276a1ae8fcffffff83c408686336' + '0000e8fcffffff83c4045f5e5bc9c3b900000000833d96400000007405b92441' + '02008b8900000000c70538b9020000000000c7054cb902000000a040c70550b9' + '02000000000083f9007c7081f9040100007c2e81f9090200007d6081e9030100' + '006bc96431d289c8b905010000f7f1a334b90200db0534b90200d83557360000' + 'c3c70538b9020000000000a100000000c1e00c50e8fcffffff83c404d80d5b36' + '0000d8055f360000d91d4cb90200c70550b9020001000000d9e8c3c70550b902' + '0001000000c70538b9020000000000d9e8c3c70540b9020000000000833d50b9' + '0200007559833d44b90200007406ff0d44b902008b450880b842010000007448' + '80b84301000000743fc70540b9020001000000c70544b902001e000000833d48' + 'b9020000752cc70548b9020001000000688e000000e8fcffffff83c404c3c705' + '44b9020000000000c70548b9020000000000c3000020420000c8420000404000' + '00c04043414e4e4f4e00596800000000833d5c3a000009751a8b45083d000000' + '00751080b838010000007407c7042400000000ffe1596800000000833d5c3a00' + '0009751a8b45083d00000000751080b839010000007407c7042400000000ffe1' + '596800000000833d5c3a000009751a8b45083d00000000751080b83a01000000' + '7407c7042400000000ffe1508b45088b406483f809741383f808753ad905303a' + '0000d905343a0000eb0cd9052c3a0000d905383a0000d80d3c3a0000d9c9d9e8' + 'dee9d80d3c3a0000d9e8dec1decadbf17602d9c9ddd858c3c7053c3a00000000' + '803fe8a4ffffffd91d00000000c3ff05e039000050a1e0390000c1e80983f804' + '7322a3e4390000db05e4390000d82de8390000d835e8390000d91d3c3a0000e8' + '67ffffff58d91d00000000c3d905403a0000c7053c3a00000000803fe84affff' + 'ffd91d00000000c3d905443a0000c7053c3a00000000803fe82effffffd91d00' + '000000c3a10000000083f809741083f8080f85fcffffffa14c3a0000eb05a148' + '3a0000a3503a00000fbf0d0000000051e8fcffffff83c404d80d503a0000d91d' + '543a00000fbf0d0000000051e8fcffffff83c404d80d543a0000d86c2404d95c' + '24040fbf0d0000000051e8fcffffff83c404d80d543a0000d844240cd95c240c' + '0fbf0d0000000051e8fcffffff83c404d80d503a0000d9e4dfe0f6c4017407dd' + 'd8e9fcffffffd86c2408d95c2408e9fcffffff56522e4a4147554152414e4449' + '0056522e5a2d475241445400626f737365732e62696e00594f5520554e4c4f43' + '4b454400505245535320425554544f4e20544f20434f4e54494e5545000ad7a3' + '3c6666663f000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000002900000013000000240000' + '0028000000160000009a99593f000020410000e0403333b33e000010420000e0' + '40090000002e000000000000009090900000a043000020400000c03f00006042' + '0000344300002040000080400000004100004842000000000000000000000000' + '000000000000000000000000cdcccc3c00008c429a9999400000a0410000c043' + '00000000000040410000f041000020420000000000000000286b6ece00000000' + '00000000000040400000000000000000000000009a99993b000000009a99193f' + '00008040000000006666e63e000020410000a0c09a99593f0000e04000008040' + '0000000000000000000080400000000000000000000000000000000064000000' + 'c7000000640000003c00000064000000c7000000640000006400000064000000' + 'c700000000007a4400008040000080400000004000007a43000000000000803f' + '00000c420000f0410000f0420000a04200000000000000000000000000000000' + '0000000000000000000000000000f0410000c03f0000803f0000a0410000c442' + '0000b0410000803f9a9959409a991940a470dd3f666646400000000000000000' + '15000000190000001d0000000f00000000000000ffffffff0100000003000000' + '000000000000000000000000000000006c3a0000000000007c3a00006c3a0000' + '00000000a470e341abaaaa3d0000803700008047cdcc4c3e0000bec30000c040' + '00001643000070c20000a041cdcc4c3d000020420000fa446f1283393333333f' + '83f922469a99193e0000a0410000a0c100000000000000000000000000000041' + '000080408fc2f53cdb0fc93800000000000070c1c0d6ffff0000804014000000' + '0000000000000000000050c10000d84100000000000000000000d8c1000050c1' + '00000000004000000000000000000000000050c10000d8c10080000000000000' + '0000d841000050c10000000000c000000c00000000000000000070c10000f040' + '0000000000000000000000000000404100000000000000000000000000000000' + '0000404100000000000000001800000000000000000040410000000000000000' + '0000000066661ec20000a0400000000000000000000000009a9901c20000a040' + '00000000000000000000000066661e420000a040000000000000000000000000' + '9a9901420000a040000000000000000024000000000030c10000a04000000000' + '000000003c000000cdccacc100003041000000000000000048000000cdccacc1' + '00007841000000000000000030000000000030410000a0400000000000000000' + '3c000000cdccac4100003041000000000000000048000000cdccac4100007841' + '00000000000000000000000000000000000000006d745f7a69672e62696e0090' + 'e0791100c0f3000044410000203d00007800000018491000e079000004350100' + '283d00003c000000f8ff1000e0790000e4ae0100303d00003c00000000000000' + '383d000001001a00383d000001001a00383d000001001a00b71bff1f06000000' + 'f5dbd0c1a7797c41e5d0d041c41b01e00700000036cdd041696f7c4186dad041' + 'c11b0060f5ff00006eb4d0c1c4427c41aec7d0c1bb1b01a0f8ff0000ccddd041' + '787a7c4101cdd0c1f5ff00a0000000007ce1aec12d210341ebe2ae41420eff1f' + '03000000431c50c10000c841ac1c50413f0eff1f000000001a5186c1f30eb141' + 'd94e8641faffff5ff9ff0000e5e1ae416f12034148e1ae413e0e00e006000000' + '711b50413400c841431c5041410e00e000000000234a8641ea04b1416a4d8641' + 'fdff01e000000000b1bfaec11ff40241c1caaec13b0e0060f8ff0000d20050c1' + '3400c8412eff4fc13e0e006000000000583986c191feb041713d86c1faff0020' + '0000000066e6ae41ce19034154e3aec1340e01a0faff0000091b50416900c841' + '711b50c1420e01a0000000009f4d86412506b141ba4986c103000000fdff0000' + '17b751b93400e04117b75139fdffff7ffdff00006f12833b85eb7f4163ee6fc1' + '03000000fdff00004b59863ba60a80419d117041943ffc3f69c000009eef6fc1' + 'b3ea7f4104e78c3b6bc0fdbf68c00000621070410f0b804127a0893bfdffff7f' + 'fdff00000ad7233b3400a2413480373b03000000fdff00000ad7233b3400a241' + '3480373b943ffc3f69c000000ad7233b3400a2413480373b68c0fdbf64c00000' + '0ad7233b3400a2413480373b000000000000000017b751b93400e04117b75139' + '000000009a99993e8fc2f53cc0ff00000000000014ae07400ad7a3bc00000000' + '0000000000000442000000000400000005000000020000000100000007000000' + '0600000003000000080000000900000042415a4f4f4b41202020202020202020' + '000000005452415020424f4d4220202020202020000000003130204c41534552' + '2020202020202020000000002020202020202020202020202020202000000000' + '5655562d39382d562020000000000000220000000200000052494e4720424541' + '4d20202020202020000000005048414c414e5820202020202020202000000000' + '464c4f4154494e47204d494e45202020000000004c415345522043414e4e4f4e' + '20202020000000005a55562d39392d5a20200000000000001a00000003000000' + '0000000000c055c000000000002061c000000000000000000000202020202020' + '2020202020202020202000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000040000000400000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '0000000000000000000000000000000000000000000000000000000000000000' + '000000000000000000000000000000000000000000000000' + ), ( + (0x17, 'abs', '.', 14816), + (0x24, 'abs', 'BS_SCENEA', 0), + (0x35, 'abs', '.', 14936), + (0x3b, 'abs', '.', 14936), + (0x59, 'abs', '.', 14940), + (0x63, 'abs', '.', 15152), + (0x6d, 'abs', '.', 15160), + (0x77, 'abs', '.', 15156), + (0x81, 'abs', '.', 14764), + (0x8b, 'abs', '.', 16534), + (0x95, 'abs', '.', 14680), + (0xa1, 'abs', 'BS_G1PA', 0), + (0xaa, 'abs', 'BS_G1PA', 0), + (0xb5, 'abs', 'BS_SCENEA', 0), + (0xc3, 'abs', 'BS_STATEA', 0), + (0xcc, 'abs', '.', 14940), + (0xd6, 'abs', 'BS_READYA', 0), + (0xdf, 'abs', '.', 16542), + (0xe8, 'abs', '.', 16542), + (0xf0, 'abs', 'BS_OBJA', 100), + (0x100, 'abs', 'BS_READYA', 0), + (0x109, 'abs', '.', 16542), + (0x10f, 'abs', 'BS_OBJA', 0), + (0x114, 'abs', '.', 180052), + (0x124, 'abs', 'BS_BSSA', 0), + (0x129, 'abs', '.', 181588), + (0x12e, 'abs', 'BS_AIDW', 0), + (0x13a, 'abs', 'GAMEMODE', 0), + (0x151, 'rel', 'BS_IDLE', -4), + (0x156, 'abs', 'BS_COL0', 0), + (0x15c, 'abs', 'BS_MODEA', 0), + (0x164, 'abs', 'BS_COL1', 0), + (0x169, 'abs', 'BS_G1PA', 0), + (0x16f, 'abs', '.', 14940), + (0x179, 'abs', 'GAMEMODE', 0), + (0x187, 'abs', '.', 14952), + (0x193, 'abs', '.', 14944), + (0x199, 'abs', '.', 14948), + (0x1a0, 'abs', '.', 14940), + (0x1aa, 'abs', '.', 16220), + (0x1b6, 'abs', 'BS_SELSCRA', 0), + (0x1bb, 'abs', '.', 144452), + (0x1c8, 'abs', 'BS_SELSCRA', 432), + (0x1cd, 'abs', '.', 144932), + (0x1da, 'abs', 'BS_SELSCRA', 432), + (0x1df, 'abs', '.', 144980), + (0x1ec, 'abs', 'BS_SELSCRA', 480), + (0x1f1, 'abs', '.', 145028), + (0x1fe, 'abs', '.', 144932), + (0x20e, 'abs', '.', 14956), + (0x217, 'abs', '.', 14972), + (0x223, 'abs', '.', 14976), + (0x232, 'abs', 'BS_SELROWS', 0), + (0x237, 'abs', '.', 143692), + (0x244, 'abs', 'BS_SELROWS', 80), + (0x249, 'abs', '.', 143892), + (0x256, 'abs', 'BS_SELSWAP', 0), + (0x25b, 'abs', '.', 143932), + (0x268, 'abs', 'BS_SELSPEC', 0), + (0x26d, 'abs', '.', 144092), + (0x27f, 'abs', '.', 143964), + (0x284, 'abs', '.', 143968), + (0x289, 'abs', '.', 144124), + (0x28e, 'abs', '.', 144128), + (0x293, 'abs', 'BS_SELLCAM', 0), + (0x298, 'abs', '.', 143972), + (0x2a5, 'abs', '.', 16196), + (0x2aa, 'abs', '.', 144068), + (0x2b7, 'abs', '.', 16196), + (0x2bc, 'abs', '.', 144080), + (0x2c9, 'abs', 'BS_JAGA', 32), + (0x2ce, 'abs', '.', 143884), + (0x2d3, 'abs', 'BS_JAGA', 28), + (0x2d8, 'abs', '.', 143888), + (0x2de, 'abs', '.', 16220), + (0x2e4, 'abs', 'BS_SELSCRA', 0), + (0x2ea, 'abs', '.', 143688), + (0x2f4, 'abs', 'GAMEMODE', 0), + (0x2fc, 'abs', '.', 144452), + (0x302, 'abs', '.', 143688), + (0x30b, 'abs', 'BS_SCRPTR', 0), + (0x318, 'abs', '.', 143688), + (0x32c, 'rel', 'BS_SELHIDEX', -4), + (0x338, 'abs', 'GAMEMODE', 0), + (0x341, 'abs', '.', 14533), + (0x348, 'abs', 'BS_SELCUR', 0), + (0x355, 'abs', 'GAMEMODE', 0), + (0x366, 'abs', 'BS_SELINVA', 0), + (0x374, 'abs', 'BS_SELCUR', 0), + (0x380, 'abs', 'BS_COLSEL', 0), + (0x388, 'abs', 'BS_COLSEL', 0), + (0x393, 'abs', '.', 14968), + (0x398, 'abs', 'BS_SELPADS', 0), + (0x39e, 'abs', 'BS_SELPADS', 1), + (0x3c7, 'rel', 'BS_SFX', -4), + (0x3e2, 'rel', 'BS_SELMDLA', 2), + (0x3ed, 'abs', 'GAMEMODE', 0), + (0x3fd, 'abs', '.', 14533), + (0x404, 'abs', '.', 15040), + (0x454, 'abs', '.', 16192), + (0x473, 'abs', '.', 16192), + (0x47a, 'abs', '.', 15044), + (0x486, 'abs', '.', 16192), + (0x48d, 'rel', 'BS_MESHA', -4), + (0x497, 'rel', 'BS_MESHA', -4), + (0x4ac, 'rel', 'BS_MESHA', -4), + (0x4b4, 'rel', 'BS_MPUSHA', -4), + (0x4ba, 'abs', '.', 16216), + (0x4c0, 'abs', '.', 16212), + (0x4c6, 'abs', '.', 16208), + (0x4cb, 'rel', 'BS_VIEWA', -4), + (0x4d5, 'rel', 'BS_ROTXA', -4), + (0x4dd, 'rel', 'BS_MSETA', -4), + (0x4e2, 'abs', 'BS_JAGA', 24), + (0x4f2, 'rel', 'BS_MESHA', -4), + (0x4fa, 'rel', 'BS_MPOPA', -4), + (0x4ff, 'rel', 'BS_MSETA', -4), + (0x506, 'rel', 'BS_MPUSHA', -4), + (0x50c, 'abs', '.', 14940), + (0x515, 'abs', 'BS_SELOBJ', 936), + (0x520, 'abs', '.', 15144), + (0x527, 'rel', 'BS_VIEWA', -4), + (0x533, 'abs', '.', 15152), + (0x53b, 'rel', 'BS_ROTXA', -4), + (0x541, 'abs', '.', 15156), + (0x546, 'rel', 'BS_ROTYA', -4), + (0x551, 'abs', '.', 15148), + (0x558, 'rel', 'BS_VIEWA', -4), + (0x561, 'abs', '.', 14980), + (0x567, 'abs', '.', 14980), + (0x56d, 'abs', '.', 14980), + (0x572, 'rel', 'BS_MSCALEA', -4), + (0x57f, 'abs', '.', 15648), + (0x587, 'abs', '.', 14940), + (0x590, 'abs', 'BS_SELOBJ', 936), + (0x598, 'abs', 'BS_SELOBJ', 924), + (0x5af, 'abs', '.', 15656), + (0x5c0, 'abs', '.', 15664), + (0x5e1, 'abs', '.', 141508), + (0x5e6, 'abs', '.', 141560), + (0x5ec, 'abs', 'BS_ZGA', 16), + (0x5f2, 'rel', 'BS_POSEA', -4), + (0x60e, 'rel', 'BS_VIEWA', -4), + (0x61b, 'rel', 'BS_ROTZA', -4), + (0x627, 'rel', 'BS_ROTYA', -4), + (0x632, 'rel', 'BS_ROTXA', -4), + (0x63a, 'abs', '.', 15200), + (0x645, 'abs', '.', 15280), + (0x64c, 'rel', 'BS_MPUSHA', -4), + (0x656, 'rel', 'BS_MPUSHA', -4), + (0x664, 'rel', 'BS_VIEWA', -4), + (0x66f, 'rel', 'BS_ROTYA', -4), + (0x677, 'rel', 'BS_MSETA', -4), + (0x688, 'rel', 'BS_MESHA', -4), + (0x690, 'rel', 'BS_MPOPA', -4), + (0x69a, 'rel', 'BS_MPOPA', -4), + (0x6a0, 'abs', '.', 14940), + (0x6ac, 'abs', 'BS_SELOBJ', 924), + (0x6b2, 'abs', 'BS_SELOBJ', 936), + (0x6ca, 'abs', 'BS_SLOTS', 28), + (0x6da, 'rel', 'BS_LOADFILE', -4), + (0x6e4, 'rel', 'BS_MPUSHA', -4), + (0x6ec, 'abs', '.', 15184), + (0x6f3, 'rel', 'BS_VIEWA', -4), + (0x6fc, 'rel', 'BS_ROTYA', -4), + (0x704, 'abs', 'BS_SELOBJ', 924), + (0x719, 'abs', '.', 14964), + (0x723, 'abs', '.', 15196), + (0x72c, 'abs', '.', 14964), + (0x731, 'rel', 'BS_MSCALEA', -4), + (0x73a, 'abs', '.', 15188), + (0x73f, 'rel', 'BS_ROTXA', -4), + (0x748, 'abs', '.', 15192), + (0x74e, 'abs', '.', 15192), + (0x754, 'abs', '.', 15192), + (0x759, 'rel', 'BS_MSCALEA', -4), + (0x761, 'rel', 'BS_MSETA', -4), + (0x766, 'abs', 'BS_SELOBJ', 924), + (0x776, 'abs', 'BS_SELFLAME', 12), + (0x785, 'rel', 'BS_MESHA', -4), + (0x78d, 'rel', 'BS_MPOPA', -4), + (0x7a4, 'rel', 'BS_MPOPA', -4), + (0x7a9, 'rel', 'BS_MSETA', -4), + (0x7b1, 'abs', '.', 15160), + (0x7c1, 'abs', 'BS_FRAMEA', 0), + (0x7da, 'abs', '.', 15164), + (0x7e7, 'rel', 'BS_ROTZA', -4), + (0x7ec, 'abs', 'BS_FRAMEA', 0), + (0x7f7, 'abs', '.', 15160), + (0x806, 'abs', '.', 15168), + (0x813, 'rel', 'BS_ROTYA', -4), + (0x818, 'abs', 'BS_FRAMEA', 0), + (0x826, 'abs', '.', 15160), + (0x82c, 'abs', '.', 15168), + (0x839, 'rel', 'BS_ROTXA', -4), + (0x841, 'abs', 'BS_FRAMEA', 0), + (0x858, 'abs', '.', 15160), + (0x85e, 'abs', '.', 15172), + (0x870, 'rel', 'BS_VIEWA', -4), + (0x87e, 'abs', '.', 15176), + (0x88a, 'abs', '.', 15564), + (0x897, 'abs', '.', 15564), + (0x89e, 'abs', '.', 15572), + (0x8a3, 'abs', 'BS_RBDIR', 0), + (0x8a8, 'abs', 'BS_PATHFMT', 0), + (0x8ad, 'abs', '.', 144132), + (0x8b2, 'rel', 'BS_SPRINTF', -4), + (0x8cc, 'abs', '.', 144132), + (0x8d2, 'abs', 'BS_CREATEF', 0), + (0x8de, 'abs', '.', 15584), + (0x8f0, 'abs', 'BS_SEEKF', 0), + (0x8f7, 'abs', '.', 15568), + (0x904, 'abs', 'BS_READF', 0), + (0x90d, 'abs', '.', 15568), + (0x92a, 'abs', 'BS_CLOSEF', 0), + (0x932, 'abs', 'BS_SELAHEAD', 0), + (0x944, 'abs', 'BS_SELAHEAD', 0), + (0x94a, 'abs', '.', 14968), + (0x950, 'abs', '.', 14956), + (0x956, 'abs', '.', 14968), + (0x95c, 'abs', '.', 14972), + (0x962, 'abs', 'BS_SELAHEAD', 0), + (0x96b, 'abs', '.', 14956), + (0x971, 'abs', '.', 14968), + (0x979, 'abs', 'BS_SELCUR', -60), + (0x983, 'abs', 'BS_SELCUR', 0), + (0x98b, 'abs', '.', 14940), + (0x997, 'abs', 'BS_SELOBJ', 924), + (0x9a7, 'abs', '.', 15160), + (0x9b0, 'abs', '.', 15160), + (0x9c4, 'abs', '.', 15160), + (0x9d0, 'rel', 'BS_SFX', -4), + (0x9d7, 'rel', 'BS_SFX', -4), + (0x9e3, 'abs', '.', 15180), + (0x9f2, 'rel', 'BS_SFX', -4), + (0xa05, 'rel', 'BS_SFX', -4), + (0xa10, 'abs', '.', 14976), + (0xa27, 'abs', '.', 15092), + (0xa34, 'abs', '.', 15100), + (0xa3f, 'abs', '.', 15096), + (0xa52, 'abs', '.', 15156), + (0xa5c, 'abs', '.', 15112), + (0xa69, 'abs', '.', 15116), + (0xa6f, 'abs', '.', 15120), + (0xa81, 'abs', '.', 15124), + (0xa93, 'abs', '.', 15128), + (0xaaa, 'abs', '.', 15180), + (0xab2, 'abs', '.', 15180), + (0xabc, 'abs', '.', 15136), + (0xac2, 'abs', '.', 15152), + (0xac8, 'abs', '.', 15140), + (0xace, 'abs', '.', 15152), + (0xad4, 'abs', '.', 15152), + (0xada, 'abs', '.', 15132), + (0xae2, 'abs', 'BS_SELCUR', 0), + (0xaeb, 'abs', 'BS_SELCUR', -40), + (0xaf3, 'abs', 'BS_SELCUR', -40), + (0xb11, 'abs', 'BS_SELCUR', 0), + (0xb1a, 'abs', 'BS_SELCUR', -36), + (0xb22, 'abs', 'BS_SELCUR', -36), + (0xb36, 'abs', 'BS_G1PA', 0), + (0xb48, 'abs', 'BS_SELSKY', 0), + (0xb52, 'abs', '.', 15096), + (0xb58, 'abs', '.', 15108), + (0xb5e, 'abs', 'BS_SELOBJ', 980), + (0xb6b, 'abs', 'BS_SELIN', 0), + (0xb74, 'abs', 'BS_SELTICKS', 0), + (0xb84, 'abs', 'BS_SELOBJ', 0), + (0xb8c, 'abs', '.', 15096), + (0xb92, 'abs', '.', 15104), + (0xb99, 'abs', 'BS_SELOBJ', 56), + (0xba9, 'abs', 'BS_SELOBJ', 52), + (0xbcb, 'abs', 'BS_SELOBJ', 52), + (0xbd7, 'abs', 'BS_SELCUR', 0), + (0xbe4, 'abs', '.', 14960), + (0xbea, 'abs', '.', 14968), + (0xbf0, 'abs', '.', 14968), + (0xbfb, 'abs', '.', 14984), + (0xc01, 'abs', '.', 14968), + (0xc07, 'abs', '.', 14968), + (0xc0f, 'abs', '.', 14988), + (0xc15, 'abs', '.', 14968), + (0xc21, 'abs', '.', 14992), + (0xc27, 'abs', '.', 14968), + (0xc33, 'abs', '.', 14996), + (0xc39, 'abs', '.', 14968), + (0xc59, 'abs', 'BS_G1PA', 0), + (0xc6a, 'abs', '.', 16220), + (0xc7a, 'abs', '.', 15040), + (0xc88, 'abs', '.', 15032), + (0xc93, 'abs', '.', 15024), + (0xc9c, 'abs', '.', 15024), + (0xca4, 'abs', '.', 222140), + (0xcb3, 'abs', '.', 15008), + (0xcbc, 'abs', '.', 14533), + (0xcd7, 'abs', 'BS_STATEA', 0), + (0xce0, 'abs', 'BS_STATEA', 0), + (0xcee, 'abs', '.', 15040), + (0xcfd, 'abs', 'BS_SELOBJ', 180), + (0xd0c, 'abs', '.', 15028), + (0xd17, 'abs', '.', 15028), + (0xd1d, 'abs', '.', 15028), + (0xd34, 'abs', '.', 15040), + (0xd3d, 'abs', '.', 15040), + (0xd47, 'abs', '.', 15028), + (0xd53, 'abs', '.', 15040), + (0xd5c, 'abs', '.', 14944), + (0xd62, 'abs', '.', 15032), + (0xd69, 'abs', '.', 15024), + (0xd72, 'abs', '.', 15024), + (0xd78, 'abs', '.', 222140), + (0xd84, 'abs', '.', 15008), + (0xd8f, 'abs', 'BS_PALRAMA', 0), + (0xdcd, 'abs', '.', 15024), + (0xdde, 'abs', 'BS_PALRAMA', 640), + (0xde4, 'abs', 'BS_PALRAMA', 0), + (0xe19, 'abs', '.', 15040), + (0xe22, 'abs', '.', 15024), + (0xe64, 'rel', 'BS_PALLOADA', -4), + (0xe6f, 'rel', 'BS_PALLOADA', -4), + (0xe7c, 'abs', 'BS_MODEA', 0), + (0xe8e, 'abs', 'BS_PALA', 0), + (0xe9d, 'rel', 'BS_PALSETA', -4), + (0xeae, 'rel', 'BS_PALSETA', -4), + (0xeb9, 'abs', 'BS_HSITE', 1), + (0xebf, 'abs', 'BS_HSITE', 5), + (0xec5, 'abs', 'BS_SELMDLA', 0), + (0xed1, 'abs', 'BS_HDOFF', 0), + (0xee8, 'abs', '.', 15056), + (0xef2, 'abs', '.', 15064), + (0xefe, 'abs', 'BS_SELCAM', 0), + (0xf0a, 'abs', 'BS_SELOBJ', 56), + (0xf22, 'abs', '.', 14968), + (0xf31, 'abs', '.', 14968), + (0xf39, 'abs', '.', 15076), + (0xf3f, 'abs', '.', 15080), + (0xf4b, 'abs', '.', 15084), + (0xf5b, 'abs', '.', 15088), + (0xf7e, 'abs', '.', 15048), + (0xf94, 'abs', '.', 15044), + (0xfa9, 'abs', 'BS_COLTAB', 0), + (0xfc0, 'abs', 'BS_POLYCOL', 0), + (0xfc6, 'abs', '.', 15044), + (0xfde, 'abs', 'BS_COLTAB', 0), + (0x1004, 'abs', '.', 15008), + (0x1026, 'abs', '.', 15052), + (0x102d, 'abs', '.', 15048), + (0x1044, 'abs', '.', 14968), + (0x106d, 'abs', 'BS_SELCUR', -20), + (0x1073, 'abs', '.', 14988), + (0x1079, 'abs', 'BS_SELCUR', -20), + (0x107f, 'abs', 'BS_SELCUR', -40), + (0x1085, 'abs', '.', 14992), + (0x108b, 'abs', 'BS_SELCUR', -40), + (0x1091, 'abs', 'BS_SELCUR', -4), + (0x1097, 'abs', '.', 14996), + (0x109d, 'abs', 'BS_SELCUR', -4), + (0x10b5, 'abs', '.', 14964), + (0x10bd, 'abs', '.', 14984), + (0x10c5, 'abs', '.', 14960), + (0x10df, 'abs', 'BS_SELCUR', -20), + (0x10e5, 'abs', '.', 14988), + (0x10eb, 'abs', 'BS_SELCUR', -20), + (0x10f1, 'abs', 'BS_SELCUR', -40), + (0x10f7, 'abs', '.', 14992), + (0x10fd, 'abs', 'BS_SELCUR', -40), + (0x1103, 'abs', 'BS_SELCUR', -4), + (0x1109, 'abs', '.', 14996), + (0x110f, 'abs', 'BS_SELCUR', -4), + (0x1127, 'abs', '.', 14964), + (0x112f, 'abs', '.', 14984), + (0x1137, 'abs', '.', 14960), + (0x1145, 'abs', 'BS_SELCUR', 0), + (0x114f, 'abs', '.', 144440), + (0x1158, 'abs', '.', 144440), + (0x1160, 'abs', 'BS_RBNAMES', 4), + (0x1165, 'rel', 'BS_MALLOC', -4), + (0x1175, 'abs', 'BS_RBNAMES', 0), + (0x117a, 'abs', 'BS_RBDIR', 0), + (0x117f, 'abs', 'BS_PATHFMT', 0), + (0x1184, 'abs', '.', 144132), + (0x1189, 'rel', 'BS_SPRINTF', -4), + (0x1191, 'abs', 'BS_RBMODE', 0), + (0x1196, 'abs', '.', 144132), + (0x119b, 'rel', 'BS_FOPEN', -4), + (0x11ae, 'abs', 'BS_RBNAMES', 4), + (0x11b4, 'rel', 'BS_FREAD', -4), + (0x11bd, 'rel', 'BS_FCLOSE', -4), + (0x11c7, 'abs', '.', 144392), + (0x11d0, 'abs', '.', 16496), + (0x11d8, 'abs', '.', 144412), + (0x11e2, 'abs', 'BS_SLOTS', 20), + (0x11e8, 'abs', '.', 16498), + (0x11ed, 'abs', 'BS_SLOTS', 20), + (0x11f3, 'abs', '.', 16496), + (0x11fa, 'abs', '.', 16497), + (0x1202, 'abs', '.', 144428), + (0x120c, 'abs', 'BS_SLOTS', 36), + (0x1212, 'abs', '.', 16502), + (0x1217, 'abs', 'BS_SLOTS', 36), + (0x121d, 'abs', '.', 16497), + (0x1226, 'abs', '.', 16496), + (0x122f, 'abs', '.', 16496), + (0x1236, 'abs', '.', 16498), + (0x123c, 'abs', 'BS_SLOTS', 20), + (0x1242, 'abs', '.', 16497), + (0x124b, 'abs', '.', 16497), + (0x1252, 'abs', '.', 16502), + (0x1258, 'abs', 'BS_SLOTS', 36), + (0x126a, 'rel', 'BS_SELINFOA', -4), + (0x1275, 'abs', '.', 16506), + (0x1280, 'rel', 'BS_SELINFOA', -4), + (0x128e, 'abs', '.', 16272), + (0x12a3, 'rel', 'BS_TXTPOSA', -4), + (0x12af, 'rel', 'BS_TCLEARA', -4), + (0x12c0, 'rel', 'BS_TBLOCKA', -4), + (0x12cc, 'rel', 'BS_TXTPOSA', -4), + (0x12d8, 'rel', 'BS_PRINT2A', -4), + (0x12ef, 'rel', 'BS_SELQINFOA', -4), + (0x12f5, 'abs', '.', 16506), + (0x1300, 'rel', 'BS_SELQINFOA', -4), + (0x130d, 'abs', '.', 16272), + (0x1314, 'rel', 'BS_SELQINFOA', -4), + (0x1321, 'abs', 'BS_QTXTY', 0), + (0x132c, 'rel', 'BS_TXTPOSA', -4), + (0x1338, 'rel', 'BS_TCLEARA', -4), + (0x1349, 'rel', 'BS_TBLOCKA', -4), + (0x1352, 'abs', 'BS_QTXTY', 0), + (0x1359, 'rel', 'BS_TXTPOSA', -4), + (0x1365, 'rel', 'BS_PRINT2A', -4), + (0x1375, 'abs', 'BS_QTXTY', 0), + (0x137e, 'abs', 'BS_QTXTX', 0), + (0x1383, 'rel', 'BS_TXTPOSA', -4), + (0x138c, 'rel', 'BS_PRINT2A', -4), + (0x1395, 'abs', '.', 16506), + (0x13aa, 'abs', 'BS_FRAMEA', 0), + (0x13b0, 'abs', 'BS_SELMODE', 0), + (0x13ba, 'abs', 'BS_PRINT2A', 0), + (0x13c6, 'abs', 'BS_PRINT1A', 0), + (0x13d3, 'rel', 'BS_TXTPOSA', -4), + (0x13e2, 'abs', '.', 16506), + (0x13f0, 'rel', 'BS_TXTPOSA', -4), + (0x13ff, 'abs', '.', 16506), + (0x140d, 'rel', 'BS_TXTPOSA', -4), + (0x141c, 'abs', '.', 16506), + (0x142a, 'rel', 'BS_TXTPOSA', -4), + (0x1439, 'abs', '.', 16506), + (0x144c, 'abs', 'BS_ROW', 0), + (0x145c, 'abs', '.', 142584), + (0x1497, 'abs', 'GAMEMODE', 0), + (0x14a0, 'abs', '.', 14533), + (0x14b9, 'abs', 'GAMEMODE', 0), + (0x14c2, 'abs', '.', 14533), + (0x14e3, 'abs', 'BS_TXTX', 0), + (0x14f4, 'abs', 'BS_TXTX', 0), + (0x14fe, 'abs', 'BS_PLANE', 6076), + (0x1513, 'abs', 'BS_PLANE', 6084), + (0x1528, 'abs', 'BS_PLANE', 8), + (0x153d, 'abs', 'BS_PLANE', 16), + (0x156a, 'abs', 'GAMEMODE', 0), + (0x1573, 'abs', '.', 14533), + (0x1591, 'abs', '.', 16480), + (0x1599, 'abs', 'BS_FRX', 0), + (0x159f, 'abs', '.', 16488), + (0x15a7, 'abs', 'BS_FRX', 8), + (0x15ad, 'abs', 'BS_PALA', 0), + (0x15ba, 'rel', 'BS_PALFIXA', -4), + (0x15c3, 'rel', 'BS_PALSETA', -4), + (0x15cb, 'rel', 'BS_PALRETA', -4), + (0x15db, 'abs', '.', 14940), + (0x15e2, 'abs', 'BS_COL0', 0), + (0x15ec, 'abs', 'BS_COL1', 0), + (0x15f2, 'abs', '.', 14952), + (0x15fa, 'abs', '.', 14948), + (0x1607, 'abs', '.', 14944), + (0x1624, 'abs', 'BS_MFRAMEA', 0), + (0x162b, 'abs', '.', 14549), + (0x164c, 'rel', 'BS_RPARTA', -4), + (0x1652, 'abs', 'BS_CPUA', 0), + (0x1657, 'abs', '.', 178516), + (0x1667, 'abs', 'BS_BSSA', 0), + (0x166c, 'abs', '.', 182124), + (0x1671, 'abs', 'BS_AIDW', 0), + (0x167c, 'abs', 'BS_FXA', 0), + (0x1681, 'abs', '.', 277592), + (0x168e, 'abs', 'BS_FX2A', 0), + (0x1693, 'abs', '.', 278456), + (0x16a1, 'abs', '.', 182712), + (0x16a8, 'abs', '.', 182612), + (0x16ad, 'abs', 'BS_CPUA', 0), + (0x16bd, 'abs', '.', 184148), + (0x16c2, 'abs', 'BS_BSSA', 0), + (0x16c7, 'abs', 'BS_AIDW', 0), + (0x16d3, 'abs', 'BS_RFLAG', 0), + (0x16d9, 'abs', 'SEMUTE', 0), + (0x16df, 'abs', 'BS_ZMODA', 0), + (0x16e5, 'abs', 'SEMUTE', 0), + (0x16ee, 'rel', 'BS_MPUSHA', -4), + (0x16f3, 'abs', '.', 14601), + (0x16f9, 'abs', 'BS_CPUA', 100), + (0x1701, 'abs', '.', 14613), + (0x170c, 'rel', 'BS_MSCALEA', -4), + (0x1714, 'abs', 'BS_MATA', 0), + (0x1724, 'abs', 'BS_MATA', 0), + (0x1729, 'abs', '.', 182076), + (0x1738, 'abs', '.', 16538), + (0x173e, 'abs', 'BS_CPUA', 0), + (0x1765, 'abs', 'BS_ZMODA', 0), + (0x177a, 'abs', '.', 16538), + (0x1780, 'rel', 'BS_MPOPA', -4), + (0x1786, 'abs', 'BS_ZMODA', 0), + (0x178c, 'abs', 'SEMUTE', 0), + (0x1792, 'abs', 'BS_RFLAG', 0), + (0x1797, 'abs', '.', 278456), + (0x179c, 'abs', 'BS_FX2A', 0), + (0x17a9, 'abs', '.', 277592), + (0x17ae, 'abs', 'BS_FXA', 0), + (0x17be, 'abs', '.', 182124), + (0x17c3, 'abs', 'BS_BSSA', 0), + (0x17c8, 'abs', 'BS_AIDW', 0), + (0x17d3, 'abs', '.', 178516), + (0x17d8, 'abs', 'BS_CPUA', 0), + (0x17f0, 'rel', 'BS_RPARTA', -4), + (0x17f6, 'abs', 'BS_OBJA', 0), + (0x17fb, 'abs', '.', 178516), + (0x180b, 'abs', 'BS_BSSA', 0), + (0x1810, 'abs', '.', 182124), + (0x1815, 'abs', 'BS_AIDW', 0), + (0x1820, 'abs', 'BS_FXA', 0), + (0x1825, 'abs', '.', 277592), + (0x1832, 'abs', 'BS_FX2A', 0), + (0x1837, 'abs', '.', 278456), + (0x1845, 'abs', '.', 180152), + (0x184c, 'abs', '.', 180052), + (0x1851, 'abs', 'BS_OBJA', 0), + (0x1861, 'abs', '.', 181588), + (0x1866, 'abs', 'BS_BSSA', 0), + (0x186b, 'abs', 'BS_AIDW', 0), + (0x1877, 'abs', 'BS_RFLAG', 0), + (0x187d, 'abs', 'SEMUTE', 0), + (0x1883, 'abs', 'BS_ZMODA', 0), + (0x1889, 'abs', 'SEMUTE', 0), + (0x1892, 'rel', 'BS_MPUSHA', -4), + (0x1897, 'abs', '.', 14780), + (0x189d, 'abs', 'BS_OBJA', 100), + (0x18a5, 'abs', '.', 14792), + (0x18b0, 'rel', 'BS_MSCALEA', -4), + (0x18b8, 'abs', 'BS_MATA', 0), + (0x18c8, 'abs', 'BS_MATA', 0), + (0x18cd, 'abs', '.', 182076), + (0x18dc, 'abs', '.', 16538), + (0x18e2, 'abs', 'BS_OBJA', 0), + (0x1909, 'abs', 'BS_ZMODA', 0), + (0x190e, 'rel', 'BS_ZDRAWA', -4), + (0x191c, 'abs', '.', 16538), + (0x1922, 'rel', 'BS_MPOPA', -4), + (0x1928, 'abs', 'BS_ZMODA', 0), + (0x192e, 'abs', 'SEMUTE', 0), + (0x1934, 'abs', 'BS_RFLAG', 0), + (0x1939, 'abs', '.', 278456), + (0x193e, 'abs', 'BS_FX2A', 0), + (0x194b, 'abs', '.', 277592), + (0x1950, 'abs', 'BS_FXA', 0), + (0x1960, 'abs', '.', 182124), + (0x1965, 'abs', 'BS_BSSA', 0), + (0x196a, 'abs', 'BS_AIDW', 0), + (0x1975, 'abs', '.', 178516), + (0x197a, 'abs', 'BS_OBJA', 0), + (0x1992, 'rel', 'BS_RPARTA', -4), + (0x1998, 'abs', 'BS_OBJA', 0), + (0x199d, 'abs', '.', 178516), + (0x19ad, 'abs', 'BS_BSSA', 0), + (0x19b2, 'abs', '.', 182124), + (0x19b7, 'abs', 'BS_AIDW', 0), + (0x19c2, 'abs', 'BS_FXA', 0), + (0x19c7, 'abs', '.', 277592), + (0x19d4, 'abs', 'BS_FX2A', 0), + (0x19d9, 'abs', '.', 278456), + (0x19e7, 'abs', '.', 180152), + (0x19ee, 'abs', '.', 180052), + (0x19f3, 'abs', 'BS_OBJA', 0), + (0x1a03, 'abs', '.', 181588), + (0x1a08, 'abs', 'BS_BSSA', 0), + (0x1a0d, 'abs', 'BS_AIDW', 0), + (0x1a19, 'abs', 'BS_RFLAG', 0), + (0x1a1f, 'abs', 'SEMUTE', 0), + (0x1a25, 'abs', 'BS_ZMODA', 0), + (0x1a2b, 'abs', 'SEMUTE', 0), + (0x1a34, 'rel', 'BS_MPUSHA', -4), + (0x1a39, 'abs', '.', 14804), + (0x1a3f, 'abs', 'BS_OBJA', 100), + (0x1a47, 'abs', '.', 14792), + (0x1a52, 'rel', 'BS_MSCALEA', -4), + (0x1a5a, 'abs', 'BS_MATA', 0), + (0x1a6a, 'abs', 'BS_MATA', 0), + (0x1a6f, 'abs', '.', 182076), + (0x1a7e, 'abs', '.', 16538), + (0x1a84, 'abs', 'BS_OBJA', 0), + (0x1aab, 'abs', 'BS_ZMODA', 0), + (0x1ab0, 'rel', 'BS_ZDRAWA', -4), + (0x1ac0, 'abs', '.', 16538), + (0x1ac6, 'rel', 'BS_MPOPA', -4), + (0x1acc, 'abs', 'BS_ZMODA', 0), + (0x1ad2, 'abs', 'SEMUTE', 0), + (0x1ad8, 'abs', 'BS_RFLAG', 0), + (0x1add, 'abs', '.', 278456), + (0x1ae2, 'abs', 'BS_FX2A', 0), + (0x1aef, 'abs', '.', 277592), + (0x1af4, 'abs', 'BS_FXA', 0), + (0x1b04, 'abs', '.', 182124), + (0x1b09, 'abs', 'BS_BSSA', 0), + (0x1b0e, 'abs', 'BS_AIDW', 0), + (0x1b19, 'abs', '.', 178516), + (0x1b1e, 'abs', 'BS_OBJA', 0), + (0x1b41, 'rel', 'BS_MPUSHA', -4), + (0x1b4f, 'rel', 'BS_VIEWA', -4), + (0x1b5c, 'rel', 'BS_MPOPA', -4), + (0x1b69, 'abs', '.', 14549), + (0x1b85, 'rel', 'BS_MPUSHA', -4), + (0x1b93, 'rel', 'BS_VIEWA', -4), + (0x1b9c, 'abs', '.', 16192), + (0x1bb3, 'abs', '.', 16192), + (0x1bb9, 'rel', 'BS_MPOPA', -4), + (0x1bc6, 'abs', '.', 16538), + (0x1bd4, 'rel', 'BS_IDENTA', -4), + (0x1bdc, 'abs', '.', 182076), + (0x1be2, 'abs', 'BS_MATA', 0), + (0x1bf4, 'abs', '.', 16538), + (0x1bfc, 'abs', 'BS_LIGHTA', 0), + (0x1c01, 'rel', 'BS_SHADEA', -4), + (0x1c06, 'rel', 'BS_NOSHADEA', -4), + (0x1c0c, 'abs', '.', 16538), + (0x1c15, 'abs', 'BS_ZTIMA', 0), + (0x1c1e, 'rel', 'BS_ZSHADEA', -4), + (0x1c23, 'rel', 'BS_ZNOSHADEA', -4), + (0x1c28, 'abs', 'BS_G1PA', 0), + (0x1c3d, 'abs', 'BS_NAMEA', 0), + (0x1c43, 'abs', '.', 14451), + (0x1c49, 'abs', '.', 14465), + (0x1c50, 'abs', '.', 14537), + (0x1c5a, 'abs', '.', 14537), + (0x1c60, 'abs', 'BS_RBMODE', 0), + (0x1c65, 'abs', '.', 14476), + (0x1c6a, 'rel', 'BS_FOPEN', -4), + (0x1c7d, 'abs', '.', 14533), + (0x1c82, 'rel', 'BS_FREAD', -4), + (0x1c8b, 'rel', 'BS_FCLOSE', -4), + (0x1c94, 'abs', '.', 14533), + (0x1c9d, 'abs', '.', 14533), + (0x1ca9, 'abs', 'BS_WBMODE', 0), + (0x1cae, 'abs', '.', 14476), + (0x1cb3, 'rel', 'BS_FOPEN', -4), + (0x1cc6, 'abs', '.', 14533), + (0x1ccb, 'rel', 'BS_FWRITE', -4), + (0x1cd4, 'rel', 'BS_FCLOSE', -4), + (0x1ce0, 'abs', 'BS_OBJA', 264), + (0x1ce6, 'abs', '.', 14832), + (0x1cec, 'abs', 'BS_READYA', 0), + (0x1cf9, 'abs', 'BS_STAGEA', 0), + (0x1d02, 'abs', 'BS_ZTIMA', 0), + (0x1d0e, 'abs', 'BS_BSSA', 0), + (0x1d14, 'abs', '.', 16534), + (0x1d1c, 'abs', '.', 147748), + (0x1d22, 'abs', 'BS_AILASER', 0), + (0x1d2b, 'abs', '.', 14836), + (0x1d3e, 'abs', 'BS_OBJA', 264), + (0x1d48, 'abs', '.', 14836), + (0x1d52, 'abs', '.', 14836), + (0x1d5b, 'abs', 'BS_OBJA', 8), + (0x1d61, 'abs', 'BS_CPUA', 8), + (0x1d67, 'abs', 'BS_CPUA', 16), + (0x1d6d, 'abs', 'BS_OBJA', 16), + (0x1d75, 'abs', '.', 15176), + (0x1d7b, 'abs', '.', 14840), + (0x1d80, 'abs', '.', 14840), + (0x1d87, 'abs', 'BS_OBJA', 388), + (0x1daa, 'abs', '.', 14836), + (0x1db5, 'abs', 'BS_OBJA', 388), + (0x1dbc, 'abs', '.', 14836), + (0x1dc7, 'abs', 'BS_STATEA', 0), + (0x1dd3, 'abs', '.', 14541), + (0x1ddd, 'abs', '.', 14545), + (0x1de7, 'abs', 'BS_DIFF', 0), + (0x1df0, 'abs', 'GAMEMODE', 0), + (0x1df9, 'abs', '.', 14541), + (0x1e03, 'abs', 'BS_STATEA', 0), + (0x1e0c, 'abs', 'BS_STAGEA', 0), + (0x1e15, 'abs', '.', 14545), + (0x1e1e, 'abs', 'BS_STATEA', 0), + (0x1e2a, 'abs', 'BS_SCENEA', 0), + (0x1e50, 'abs', 'BS_READYA', 0), + (0x1e59, 'abs', '.', 14633), + (0x1e62, 'abs', '.', 14633), + (0x1e6a, 'abs', 'BS_CPUA', 100), + (0x1e7a, 'abs', 'BS_READYA', 0), + (0x1e83, 'abs', '.', 14633), + (0x1e89, 'abs', 'BS_CPUA', 0), + (0x1e8e, 'abs', '.', 182612), + (0x1e9e, 'abs', 'BS_BSSA', 0), + (0x1ea3, 'abs', '.', 184148), + (0x1ea8, 'abs', 'BS_AIDW', 0), + (0x1eb4, 'abs', '.', 14940), + (0x1ec2, 'abs', 'BS_OBJA', 388), + (0x1ec8, 'abs', 'BS_ECBLKA', 26), + (0x1ed1, 'abs', 'BS_LOGOJ', 0), + (0x1edd, 'abs', 'BS_LOGOZ', -136), + (0x1f03, 'abs', 'BS_ARTPOOL2', 0), + (0x1f14, 'abs', 'BS_ARTPOOL', 0), + (0x1f1a, 'abs', 'BS_ARTEND', -128), + (0x1f41, 'abs', '.', 184636), + (0x1f57, 'abs', '.', 14565), + (0x1f62, 'abs', '.', 14565), + (0x1f6f, 'abs', '.', 14569), + (0x1f77, 'abs', '.', 203324), + (0x1f7c, 'abs', 'BS_ARTPOOL', 0), + (0x1f8b, 'abs', 'BS_ARTPOOL', 0), + (0x1fa6, 'abs', '.', 184636), + (0x1fb3, 'abs', '.', 14573), + (0x1fb9, 'abs', 'BS_ARTCOUNT', 0), + (0x1fbf, 'abs', '.', 14577), + (0x1fc8, 'abs', 'BS_ARTCOUNT', 0), + (0x1fce, 'abs', '.', 14569), + (0x1fd5, 'abs', '.', 14573), + (0x1fe2, 'abs', '.', 14549), + (0x1ff4, 'abs', '.', 277436), + (0x201c, 'abs', '.', 14569), + (0x2025, 'abs', '.', 14577), + (0x202a, 'abs', 'BS_ARTCOUNT', 0), + (0x2030, 'abs', '.', 14569), + (0x2039, 'abs', '.', 16546), + (0x2043, 'abs', 'BS_PALRAMA', 0), + (0x2048, 'abs', '.', 228284), + (0x2055, 'abs', '.', 16546), + (0x205e, 'abs', '.', 16546), + (0x2068, 'abs', '.', 228284), + (0x206d, 'abs', 'BS_PALRAMA', 0), + (0x207a, 'abs', '.', 16546), + (0x2085, 'abs', '.', 16554), + (0x2092, 'rel', 'BS_MALLOC', -4), + (0x209a, 'abs', '.', 16554), + (0x20a4, 'abs', '.', 16554), + (0x20a9, 'abs', 'BS_FCBUF', 0), + (0x20b5, 'abs', 'BS_FLDBUF', 0), + (0x20c1, 'abs', 'BS_MTSELMEM', 0), + (0x20cd, 'abs', 'BS_SEGA', 0), + (0x20d2, 'abs', '.', 16574), + (0x20d7, 'abs', 'BS_GLOW1', 0), + (0x20dc, 'abs', '.', 16562), + (0x20e1, 'abs', 'BS_GLOW2', 0), + (0x20e6, 'abs', '.', 16566), + (0x20eb, 'abs', 'BS_GLOW3', 0), + (0x20f0, 'abs', '.', 16570), + (0x20f6, 'abs', '.', 16558), + (0x20ff, 'abs', '.', 16558), + (0x210a, 'abs', '.', 16554), + (0x210f, 'abs', 'BS_FCBUF', 0), + (0x211b, 'abs', 'BS_FLDBUF', 0), + (0x2127, 'abs', 'BS_MTSELMEM', 0), + (0x2133, 'abs', '.', 16574), + (0x2138, 'abs', 'BS_SEGA', 0), + (0x213d, 'abs', '.', 16562), + (0x2142, 'abs', 'BS_GLOW1', 0), + (0x2147, 'abs', '.', 16566), + (0x214c, 'abs', 'BS_GLOW2', 0), + (0x2151, 'abs', '.', 16570), + (0x2156, 'abs', 'BS_GLOW3', 0), + (0x215b, 'abs', '.', 16550), + (0x2160, 'abs', 'BS_SCNNOW', 0), + (0x2166, 'abs', '.', 16558), + (0x217a, 'abs', '.', 16582), + (0x2180, 'rel', 'BS_LOADTEX', -4), + (0x2186, 'abs', 'GAMEMODE', 0), + (0x218f, 'abs', 'BS_DIFF', 0), + (0x2198, 'abs', '.', 14541), + (0x21a0, 'abs', 'BS_LOSSA', 0), + (0x21a6, 'abs', '.', 14541), + (0x21b1, 'abs', 'BS_STATEA', 0), + (0x21c2, 'abs', '.', 14533), + (0x21cb, 'abs', 'BS_CPUA', 100), + (0x21d4, 'abs', '.', 14533), + (0x21e3, 'abs', '.', 14549), + (0x21ed, 'abs', '.', 14553), + (0x21f8, 'abs', '.', 14545), + (0x2201, 'abs', '.', 14545), + (0x2212, 'abs', '.', 14533), + (0x221b, 'abs', '.', 14533), + (0x2229, 'abs', 'BS_SCNNOW', 0), + (0x222e, 'abs', '.', 16550), + (0x2233, 'abs', '.', 16582), + (0x2238, 'abs', '.', 16578), + (0x2243, 'abs', '.', 14549), + (0x224d, 'abs', '.', 14553), + (0x2257, 'abs', 'BS_STATEA', 0), + (0x2262, 'abs', 'BS_STATEA', 0), + (0x226d, 'abs', '.', 14549), + (0x2275, 'rel', 'BS_REPTEXTA', -4), + (0x227c, 'abs', '.', 14549), + (0x2284, 'rel', 'BS_REPLOGICA', -4), + (0x228b, 'abs', '.', 14553), + (0x229c, 'rel', 'BS_SFX', -4), + (0x22a5, 'abs', '.', 14557), + (0x22af, 'abs', '.', 14561), + (0x22bb, 'abs', '.', 14549), + (0x22c8, 'rel', 'BS_PALLOADA', -4), + (0x22d6, 'rel', 'BS_PALLOADA', -4), + (0x22e4, 'rel', 'BS_PALLOADA', -4), + (0x22f2, 'rel', 'BS_PALLOADA', -4), + (0x22fa, 'abs', '.', 14549), + (0x2301, 'abs', '.', 14944), + (0x230b, 'rel', 'BS_PALLOADA', -4), + (0x231a, 'rel', 'BS_PALLOADA', -4), + (0x2324, 'rel', 'BS_TCLRALL', -4), + (0x232c, 'rel', 'BS_TRESET', -4), + (0x2332, 'abs', '.', 14553), + (0x233c, 'rel', 'BS_TCLRALL', -4), + (0x2344, 'rel', 'BS_TRESET', -4), + (0x234a, 'abs', '.', 14585), + (0x2350, 'abs', '.', 14581), + (0x2355, 'rel', 'BS_TXTPOSA', -4), + (0x235d, 'abs', '.', 14487), + (0x2362, 'rel', 'BS_PRINTBIG', -4), + (0x236b, 'abs', '.', 14553), + (0x237b, 'abs', '.', 14549), + (0x2384, 'abs', '.', 14597), + (0x238b, 'abs', '.', 14589), + (0x2390, 'rel', 'BS_TXTPOSA', -4), + (0x239c, 'abs', '.', 16272), + (0x23a7, 'abs', '.', 277436), + (0x23ac, 'rel', 'BS_TBLOCKA', -4), + (0x23b5, 'abs', '.', 14561), + (0x23be, 'abs', '.', 14553), + (0x23c4, 'abs', '.', 14525), + (0x23ca, 'abs', '.', 14529), + (0x23dc, 'abs', 'BS_G1PA', 0), + (0x23e1, 'abs', '.', 14549), + (0x23e6, 'abs', 'BS_G1PA', 0), + (0x23ef, 'rel', 'BS_REPMODELA', -4), + (0x23f8, 'abs', 'BS_G1PA', 0), + (0x2400, 'abs', '.', 14553), + (0x2416, 'abs', '.', 14629), + (0x241c, 'abs', '.', 14625), + (0x2421, 'rel', 'BS_TXTPOSA', -4), + (0x2431, 'abs', '.', 14500), + (0x2436, 'rel', 'BS_PRINTBIG', -4), + (0x2444, 'rel', 'BS_TCLEARA', -4), + (0x244c, 'abs', 'BS_PADEDGE', 0), + (0x2457, 'abs', '.', 14561), + (0x2460, 'abs', '.', 14557), + (0x2465, 'abs', '.', 14557), + (0x2471, 'abs', '.', 14561), + (0x2479, 'rel', 'BS_SFX', -4), + (0x2488, 'abs', '.', 14553), + (0x2491, 'rel', 'BS_TCLRALL', -4), + (0x2499, 'rel', 'BS_TRESET', -4), + (0x24aa, 'rel', 'BS_FADE', -4), + (0x24b3, 'abs', 'BS_REPCNT', 0), + (0x24c2, 'rel', 'BS_SCNEND', -4), + (0x24cb, 'abs', '.', 14553), + (0x24d4, 'abs', '.', 14549), + (0x24da, 'abs', '.', 14549), + (0x24e4, 'abs', 'BS_STATEA', 0), + (0x24fa, 'abs', '.', 16578), + (0x24ff, 'rel', 'BS_LOADTEX', -4), + (0x2509, 'abs', 'BS_SCENEA', 0), + (0x2511, 'abs', 'BS_EVA', 0), + (0x251b, 'abs', 'BS_STATEA', 0), + (0x2526, 'abs', 'BS_IDA', 0), + (0x252f, 'rel', 'BS_LDXA', -4), + (0x2534, 'rel', 'BS_LDA', -4), + (0x253a, 'abs', 'BS_IDA', 0), + (0x2541, 'rel', 'BS_DRSA', -4), + (0x2547, 'abs8', 'DR_FLAG', 0), + (0x254b, 'rel', 'BS_DRJA', -4), + (0x2550, 'rel', 'BS_DRFA', -4), + (0x2555, 'abs', 'BS_IDA', 0), + (0x255e, 'rel', 'BS_LDXA', -4), + (0x2563, 'rel', 'BS_C2A', -4), + (0x2568, 'abs', 'BS_IDA', 0), + (0x2576, 'abs', 'BS_MDLA', 0), + (0x257a, 'abs', 'BS_JAGA', 0), + (0x2582, 'abs', 'BS_MDLA', 0), + (0x2586, 'abs', 'BS_ZGA', 0), + (0x258e, 'abs', 'BS_PHASEA', 0), + (0x2595, 'rel', 'BS_END1A', -4), + (0x259a, 'rel', 'BS_ENDA', -4), + (0x259f, 'abs', 'BS_G1PA', 0), + (0x25a9, 'abs', '.', 14764), + (0x25af, 'abs', 'BS_PHASEA', 0), + (0x25b8, 'abs', 'BS_G1PA', 0), + (0x25c1, 'rel', 'BS_ENDA', -4), + (0x25c6, 'abs', '.', 14764), + (0x25cf, 'abs', 'BS_G1PA', 0), + (0x25d5, 'abs', 'BS_PHASEA', 0), + (0x25dc, 'rel', 'BS_END1A', -4), + (0x25e2, 'rel', 'BS_ENDEA', -4), + (0x25e7, 'rel', 'BS_ENDEA', -4), + (0x25ed, 'abs', 'BS_IDA', 0), + (0x25f5, 'rel', 'BS_PH0A', -4), + (0x25fb, 'abs', 'BS_ESTEPA', 0), + (0x2607, 'abs', 'BS_ESTEPA', 0), + (0x260d, 'abs', 'BS_TIMEA', 0), + (0x2617, 'abs', 'BS_ESTEPA', 0), + (0x2623, 'abs', 'BS_ESTEPA', 0), + (0x2629, 'abs', 'BS_BSSA', 0), + (0x262f, 'abs', '.', 16534), + (0x2637, 'abs', '.', 147748), + (0x263c, 'abs', 'BS_AILASER', 0), + (0x2642, 'abs', 'BS_TIMEA', 0), + (0x264f, 'abs', 'BS_TIMEA', 0), + (0x265c, 'abs', 'BS_G1PA', 0), + (0x266e, 'abs', 'BS_TIMEA', 0), + (0x267b, 'abs', 'BS_OBJA', 376), + (0x2685, 'abs', 'BS_OBJA', 376), + (0x268d, 'abs', 'BS_TIMEA', 0), + (0x2699, 'abs', '.', 14740), + (0x26a2, 'abs', '.', 14740), + (0x26a9, 'abs', '.', 14752), + (0x26ad, 'abs', 'BS_SPDA', 0), + (0x26b3, 'abs', 'BS_SPDA', 0), + (0x26b9, 'abs', '.', 14748), + (0x26bf, 'abs', 'BS_SPDA', 0), + (0x26c5, 'abs', '.', 14756), + (0x26cb, 'abs', 'BS_SPDA', 0), + (0x26d1, 'abs', '.', 14760), + (0x26d7, 'abs', '.', 14760), + (0x26e0, 'abs', '.', 14760), + (0x26ec, 'abs', 'BS_OBJA', 512), + (0x2715, 'abs', 'BS_TIMEA', 0), + (0x2723, 'rel', 'BS_PH0A', -4), + (0x272e, 'abs', '.', 14768), + (0x2735, 'abs', '.', 14676), + (0x273f, 'abs', '.', 14720), + (0x274a, 'abs', 'BS_OBJA', 12), + (0x2750, 'abs', 'BS_OBJA', 16), + (0x2756, 'abs', 'BS_OBJA', 12), + (0x275c, 'abs', '.', 14684), + (0x2762, 'abs', 'BS_OBJA', 12), + (0x2768, 'abs', 'BS_OBJA', 16), + (0x276e, 'abs', '.', 14688), + (0x2774, 'abs', 'BS_OBJA', 16), + (0x2779, 'rel', 'BS_PH0A', -4), + (0x277f, 'abs', 'BS_OBJA', 16), + (0x2785, 'abs', 'BS_OBJA', 12), + (0x278c, 'abs', '.', 14720), + (0x2795, 'abs', 'BS_EVA', 0), + (0x27a1, 'abs', '.', 14720), + (0x27a7, 'abs', '.', 14720), + (0x27b1, 'abs', 'BS_EVA', 0), + (0x27b8, 'abs', '.', 16526), + (0x27bf, 'abs', '.', 14768), + (0x27c8, 'abs', '.', 14676), + (0x27d1, 'abs', '.', 14676), + (0x27dc, 'abs', 'BS_OBJA', 368), + (0x27e5, 'abs', 'BS_OBJA', 380), + (0x27ee, 'abs', 'BS_OBJA', 376), + (0x2808, 'abs', '.', 14768), + (0x280f, 'abs', '.', 14676), + (0x281f, 'abs', '.', 14676), + (0x2826, 'abs', 'BS_OBJA', 176), + (0x282b, 'abs', '.', 16624), + (0x2839, 'abs', 'BS_OBJA', 376), + (0x283f, 'abs', '.', 16704), + (0x2845, 'abs', 'BS_OBJA', 420), + (0x284b, 'abs', '.', 16706), + (0x2852, 'abs', 'BS_OBJA', 376), + (0x2859, 'rel', 'BS_PH0A', -4), + (0x285f, 'abs', '.', 16704), + (0x2865, 'abs', 'BS_OBJA', 376), + (0x286b, 'abs', '.', 16706), + (0x2871, 'abs', 'BS_OBJA', 420), + (0x2876, 'abs', '.', 16624), + (0x287b, 'abs', 'BS_OBJA', 176), + (0x288a, 'abs', '.', 14676), + (0x2896, 'abs', '.', 14768), + (0x289d, 'abs', '.', 14676), + (0x28a7, 'abs', 'BS_ESTEPA', 0), + (0x28ad, 'abs', 'BS_TIMEA', 0), + (0x28b9, 'abs', 'BS_TIMEA', 0), + (0x28c2, 'rel', 'BS_PH0A', -4), + (0x28c8, 'abs', 'BS_TIMEA', 0), + (0x28d3, 'abs', '.', 14680), + (0x28df, 'abs', '.', 14768), + (0x28e6, 'abs', '.', 14676), + (0x28f0, 'abs', '.', 14720), + (0x28fa, 'rel', 'BS_PH0A', -4), + (0x2900, 'abs', '.', 14740), + (0x2907, 'rel', 'BS_WALLA', -4), + (0x290d, 'abs', '.', 14744), + (0x2914, 'abs', '.', 14740), + (0x291d, 'abs', '.', 14740), + (0x2925, 'abs', '.', 14752), + (0x292b, 'abs', '.', 14748), + (0x2936, 'abs', 'BS_IDA', 0), + (0x2941, 'abs', 'BS_SCANBASE', 0), + (0x2946, 'rel', 'BS_SCANA', -4), + (0x294b, 'abs', 'BS_TIMEA', 0), + (0x2953, 'abs', '.', 14736), + (0x2959, 'abs', '.', 14736), + (0x295f, 'abs', '.', 14724), + (0x2965, 'abs', 'BS_OBJA', 16), + (0x296b, 'abs', '.', 14732), + (0x2971, 'abs', '.', 16616), + (0x2977, 'abs', 'BS_OBJA', 12), + (0x297d, 'abs', '.', 14728), + (0x2983, 'abs', '.', 16612), + (0x2988, 'abs', 'BS_OBJA', 8), + (0x298d, 'abs', '.', 16608), + (0x2993, 'abs8', 'SCAN_SLOT', 0), + (0x2994, 'abs', '.', 16592), + (0x2999, 'rel', 'BS_FOUNDA', -4), + (0x299f, 'abs', 'BS_IDA', 0), + (0x29a7, 'rel', 'BS_VIEWA', -4), + (0x29ad, 'abs', '.', 14660), + (0x29b3, 'abs', 'BS_IDA', 0), + (0x29bc, 'abs', 'BS_TIMEA', 0), + (0x29c8, 'abs', 'BS_TIMEA', 0), + (0x29d0, 'abs', '.', 14664), + (0x29d7, 'abs', '.', 14668), + (0x29df, 'abs', 'BS_ESTEPA', 0), + (0x29ef, 'abs', 'BS_ECBLKA', 36), + (0x29fb, 'abs', 'BS_ECBLKA', 40), + (0x2a09, 'abs', 'BS_ECBLKA', 44), + (0x2a15, 'abs', '.', 14672), + (0x2a29, 'abs', 'BS_ECBLKA', 36), + (0x2a31, 'abs', 'BS_ECBLKA', 36), + (0x2a3f, 'abs', 'BS_ECBLKA', 40), + (0x2a47, 'abs', 'BS_ECBLKA', 40), + (0x2a55, 'abs', 'BS_ECBLKA', 44), + (0x2a5d, 'abs', 'BS_ECBLKA', 44), + (0x2a6e, 'abs', 'BS_ESTEPA', 0), + (0x2a7f, 'abs', '.', 14776), + (0x2a85, 'abs', '.', 14776), + (0x2a8b, 'abs', '.', 14772), + (0x2a91, 'abs', 'BS_ECBLKA', 44), + (0x2a9d, 'abs', 'BS_ECBLKA', 36), + (0x2abb, 'rel', 'BS_VIEWA', -4), + (0x2ac1, 'abs', '.', 14940), + (0x2ace, 'rel', 'BS_VIEWA', -4), + (0x2ad5, 'abs', 'BS_YAW4', 0), + (0x2adb, 'rel', 'BS_SINA', -4), + (0x2ae4, 'abs', '.', 14640), + (0x2af3, 'abs', 'BS_YAW4', 0), + (0x2af9, 'rel', 'BS_COSA', -4), + (0x2b02, 'abs', '.', 14640), + (0x2b0f, 'rel', 'BS_VIEWA', -4), + (0x2b15, 'abs', '.', 14940), + (0x2b1e, 'abs8', 'CAM_PTR', 0), + (0x2b24, 'abs', '.', 14652), + (0x2b30, 'abs', '.', 14652), + (0x2b4e, 'abs8', 'CAM_PTR', 0), + (0x2b54, 'rel', 'BS_LIVEA', -4), + (0x2b5a, 'abs8', 'CAM_PTR', 0), + (0x2b60, 'abs', '.', 14940), + (0x2b69, 'abs', '.', 14648), + (0x2b71, 'abs', '.', 14940), + (0x2b7a, 'abs', '.', 14644), + (0x2b80, 'abs', '.', 14656), + (0x2b8f, 'abs', '.', 14656), + (0x2b98, 'abs', '.', 14940), + (0x2ba1, 'abs', 'BS_STAGEA', 0), + (0x2bac, 'abs', 'BS_OBJA', 0), + (0x2bb9, 'rel', 'BS_INITA', -4), + (0x2bc0, 'abs', '.', 14940), + (0x2bc9, 'abs', 'BS_STAGEA', 0), + (0x2bd4, 'abs', 'BS_OBJA', 0), + (0x2be4, 'rel', 'BS_FLYA', -4), + (0x2bf6, 'abs', 'BS_READYA', 0), + (0x2c2d, 'abs', 'BS_ZMODA', 0), + (0x2c32, 'rel', 'BS_FLYEA', -4), + (0x2c3a, 'abs', 'BS_ZMODA', 0), + (0x2c3f, 'rel', 'BS_FLYPA', -4), + (0x2c45, 'abs', 'BS_ZTIMA', 0), + (0x2c4f, 'abs', '.', 14836), + (0x2c59, 'abs', '.', 14940), + (0x2c66, 'abs', 'BS_OBJA', 0), + (0x2c6e, 'abs', 'BS_ARENA', 0), + (0x2c7a, 'abs', '.', 14844), + (0x2c80, 'abs', 'BS_ZTIMA', 0), + (0x2ca2, 'abs', 'BS_RCOUNTA', 0), + (0x2cab, 'abs', '.', 14940), + (0x2cb4, 'abs', 'BS_STAGEA', 0), + (0x2cbd, 'abs', 'BS_ZTIMA', 0), + (0x2cc6, 'abs', '.', 14828), + (0x2cd2, 'abs', '.', 14828), + (0x2cd8, 'abs', 'BS_RCOUNTA', 0), + (0x2ce6, 'abs', '.', 14828), + (0x2cf0, 'abs', 'BS_RCOUNTA', 0), + (0x2cfc, 'abs', 'BS_OBJA', 0), + (0x2d04, 'abs', '.', 14940), + (0x2d26, 'abs', 'BS_ARENA', 0), + (0x2d2d, 'rel', 'BS_ZBOXA', -4), + (0x2d44, 'rel', 'BS_FLOORA', -4), + (0x2d50, 'abs', '.', 14884), + (0x2d6e, 'rel', 'BS_FLOORA', -4), + (0x2d7a, 'abs', '.', 14884), + (0x2d8d, 'abs', '.', 14888), + (0x2df2, 'abs', '.', 14940), + (0x2dfc, 'abs', 'BS_OBJA', 0), + (0x2e04, 'abs', 'BS_ZTIMA', 0), + (0x2e0b, 'rel', 'BS_TM2S', -4), + (0x2e10, 'rel', 'BS_TM2', -4), + (0x2e16, 'abs', 'BS_READYA', 0), + (0x2e1d, 'rel', 'BS_TM2', -4), + (0x2e22, 'rel', 'BS_TM2S', -4), + (0x2e28, 'abs', '.', 14940), + (0x2e32, 'abs', 'BS_OBJA', 0), + (0x2e3a, 'abs', 'BS_ZTIMA', 0), + (0x2e41, 'rel', 'BS_TM4S', -4), + (0x2e46, 'rel', 'BS_TM4', -4), + (0x2e4c, 'abs', 'BS_READYA', 0), + (0x2e53, 'rel', 'BS_TM4', -4), + (0x2e58, 'rel', 'BS_TM4S', -4), + (0x2e5e, 'abs', '.', 14940), + (0x2e67, 'abs', 'BS_STAGEA', 0), + (0x2e6f, 'abs', 'BS_OBJA', 0), + (0x2e75, 'rel', 'BS_CLIP0A', -4), + (0x2e7f, 'rel', 'BS_CLIP3A', -4), + (0x2e8b, 'rel', 'BS_CLIP3A', -4), + (0x2e90, 'rel', 'BS_CLIP0A', -4), + (0x2e99, 'abs', 'BS_CLONEFRAME', 0), + (0x2ea2, 'abs', '.', 14940), + (0x2ea9, 'rel', 'BS_CLONEA', -4), + (0x2eaf, 'abs', 'BS_STAGEA', 0), + (0x2eb6, 'rel', 'BS_CLONEA', -4), + (0x2ebe, 'abs', 'BS_OBJA', 0), + (0x2ec5, 'rel', 'BS_CLONEA', -4), + (0x2ed0, 'rel', 'BS_CLONEA', -4), + (0x2ed6, 'abs', '.', 145700), + (0x2edc, 'rel', 'BS_CLONEA', -4), + (0x2ee2, 'abs', 'BS_ZGA', 0), + (0x2ee8, 'rel', 'BS_CLONEA', -4), + (0x2eee, 'abs', '.', 16530), + (0x2ef8, 'abs', '.', 145700), + (0x2f06, 'abs', '.', 16530), + (0x2f19, 'abs', '.', 145700), + (0x2f1f, 'abs', '.', 145700), + (0x2f27, 'rel', 'BS_CLONEA', -4), + (0x2f2d, 'abs', '.', 14940), + (0x2f36, 'abs', 'BS_STAGEA', 0), + (0x2f41, 'abs', 'BS_OBJA', 0), + (0x2f51, 'rel', 'BS_TICKA', -4), + (0x2f57, 'abs', '.', 16534), + (0x2f62, 'abs', 'BS_BSSA', 0), + (0x2f67, 'abs', '.', 147748), + (0x2f6c, 'abs', 'BS_AIDW', 0), + (0x2f77, 'abs', '.', 147748), + (0x2f7d, 'abs', 'BS_AI1C', 0), + (0x2f87, 'abs', 'BS_AITIMER', 0), + (0x2f91, 'abs', 'BS_AILASER', 0), + (0x2f9b, 'abs', '.', 16534), + (0x2fad, 'abs', 'BS_ZTAB0', 0), + (0x2fb4, 'abs', 'BS_ZTAB1', 0), + (0x2fba, 'abs', 'BS_AITAB', 0), + (0x2fc3, 'abs', 'BS_AITAB2', 0), + (0x2fce, 'abs', 'BS_AITAB3', 0), + (0x2fd7, 'abs', 'BS_AITAB4', 0), + (0x2fe0, 'abs', 'BS_BSSA', 0), + (0x2fe5, 'abs', '.', 148236), + (0x2fea, 'abs', 'BS_AIDW', 0), + (0x2ff8, 'abs', '.', 147748), + (0x2ffd, 'abs', 'BS_BSSA', 0), + (0x3002, 'abs', 'BS_AIDW', 0), + (0x301c, 'abs', 'BS_BSSA', 0), + (0x3021, 'abs', '.', 147748), + (0x3026, 'abs', 'BS_AIDW', 0), + (0x3034, 'abs', '.', 148236), + (0x3039, 'abs', 'BS_BSSA', 0), + (0x303e, 'abs', 'BS_AIDW', 0), + (0x304b, 'abs', '.', 16534), + (0x3058, 'rel', 'BS_ZINITA', -4), + (0x3064, 'abs', 'BS_OBJA', 0), + (0x3084, 'abs', '.', 14680), + (0x3096, 'abs', '.', 14696), + (0x309c, 'abs', '.', 14696), + (0x30a4, 'abs', '.', 14700), + (0x30aa, 'abs', '.', 14704), + (0x30b0, 'abs', '.', 14684), + (0x30b6, 'abs', '.', 14688), + (0x30d1, 'abs', '.', 14692), + (0x30d7, 'abs', '.', 14704), + (0x30dc, 'abs', '.', 14684), + (0x30ea, 'abs', '.', 14696), + (0x30f0, 'abs', '.', 14696), + (0x30f6, 'abs', '.', 14708), + (0x30fe, 'abs', '.', 14688), + (0x310e, 'abs', '.', 14692), + (0x3118, 'abs', '.', 14696), + (0x311e, 'abs', '.', 14696), + (0x3124, 'abs', '.', 14712), + (0x312a, 'abs', '.', 14716), + (0x3132, 'abs', '.', 14688), + (0x3139, 'abs', '.', 14692), + (0x3146, 'abs', '.', 14768), + (0x314e, 'abs', 'BS_OBJA', 0), + (0x3156, 'abs', '.', 14680), + (0x315e, 'abs', 'BS_OBJA', 0), + (0x3165, 'rel', 'BS_ZDRAWA', -4), + (0x3170, 'rel', 'BS_ZDRAWA', -4), + (0x3185, 'abs', '.', 14684), + (0x3191, 'abs', '.', 14688), + (0x319b, 'abs', '.', 14692), + (0x31a8, 'rel', 'BS_ZDRAWA', -4), + (0x31c4, 'abs', '.', 16624), + (0x31e1, 'abs', '.', 16704), + (0x31f6, 'abs', '.', 16706), + (0x3215, 'abs', 'BS_OBJA', 0), + (0x321c, 'rel', 'BS_MDRAWA', -4), + (0x3231, 'rel', 'BS_MDRAWA', -4), + (0x323e, 'abs', 'BS_ZEVA', 0), + (0x3243, 'abs', 'BS_EVA', 0), + (0x3249, 'abs', '.', 16526), + (0x3251, 'abs', 'BS_OBJA', 0), + (0x325a, 'abs', '.', 16526), + (0x3262, 'abs', '.', 16526), + (0x326b, 'abs', '.', 14952), + (0x326f, 'abs', 'BS_COL1', 0), + (0x3275, 'rel', 'BS_ZGA5', -4), + (0x327a, 'rel', 'BS_ZGA1', -4), + (0x3280, 'abs8', 'PAL_CPU', 0), + (0x3284, 'rel', 'BS_ZGA1', -4), + (0x3289, 'rel', 'BS_ZGA5', -4), + (0x328f, 'abs', '.', 16526), + (0x3298, 'abs', '.', 14940), + (0x32af, 'abs', '.', 14952), + (0x32b3, 'abs', 'BS_COL1', 0), + (0x32c4, 'rel', 'BS_PALLOADA', -4), + (0x32d2, 'rel', 'BS_PALLOADA', -4), + (0x32da, 'rel', 'BS_ZRAX', -4), + (0x32e0, 'abs8', 'PAL_CPU', 0), + (0x32e4, 'rel', 'BS_ZRA1', -4), + (0x32e9, 'rel', 'BS_ZRA5', -4), + (0x32ef, 'abs', '.', 16526), + (0x32f6, 'rel', 'BS_ZRAX', -4), + (0x32fc, 'abs8', 'PAL_CPU', 0), + (0x3300, 'rel', 'BS_ZDA1', -4), + (0x3305, 'rel', 'BS_ZDA5', -4), + (0x330b, 'abs', '.', 16526), + (0x3312, 'rel', 'BS_ZRAX', -4), + (0x3318, 'abs8', 'PAL_CPU', 0), + (0x331c, 'rel', 'BS_ZFA1', -4), + (0x3321, 'rel', 'BS_ZFA5', -4), + (0x3338, 'abs', '.', 148724), + (0x333f, 'abs', 'BS_OBJA', 0), + (0x3348, 'abs', 'BS_BSSA', 0), + (0x334d, 'abs', 'BS_AIDW', 0), + (0x335a, 'abs', '.', 147748), + (0x336c, 'abs', '.', 16534), + (0x3377, 'abs', '.', 14836), + (0x3382, 'abs', '.', 14832), + (0x338b, 'abs', 'BS_BSSA', 0), + (0x3390, 'abs', 'BS_AIDW', 0), + (0x339d, 'abs', '.', 147748), + (0x33a9, 'abs', '.', 16534), + (0x33b4, 'abs', '.', 14836), + (0x33bf, 'abs', '.', 14832), + (0x33d1, 'abs', 'BS_SLOTS', 20), + (0x33d7, 'abs', 'BS_RBNAMES', 44), + (0x33f5, 'abs', 'BS_KEYA', 0), + (0x3406, 'abs', '.', 14940), + (0x3414, 'abs', 'BS_OBJA', 0), + (0x3425, 'abs', '.', 13907), + (0x342b, 'abs', '.', 178492), + (0x3435, 'rel', 'BS_MPUSHA', -4), + (0x343a, 'rel', 'BS_MIDENTA', -4), + (0x344e, 'rel', 'BS_VIEWA', -4), + (0x345c, 'abs', '.', 178500), + (0x3474, 'rel', 'BS_MSCALEA', -4), + (0x3482, 'abs', '.', 178508), + (0x3488, 'abs', '.', 178492), + (0x348d, 'rel', 'BS_MSCALEA', -4), + (0x349e, 'rel', 'BS_VIEWA', -4), + (0x34a6, 'rel', 'BS_MSETA', -4), + (0x34ad, 'abs', 'BS_BARMESHA', 0), + (0x34b3, 'abs', '.', 178488), + (0x34ba, 'rel', 'BS_MESHA', -4), + (0x34c2, 'rel', 'BS_MPOPA', -4), + (0x34cb, 'rel', 'BS_TXTPOSA', -4), + (0x34d4, 'abs', '.', 178496), + (0x34de, 'rel', 'BS_CHARGEA', -4), + (0x34ea, 'rel', 'BS_CHARGEA', -4), + (0x34f6, 'rel', 'BS_TXTPOSA', -4), + (0x34fe, 'abs', '.', 13923), + (0x3503, 'rel', 'BS_PRINT2A', -4), + (0x3510, 'abs', 'BS_BSSA', 0), + (0x3516, 'abs', '.', 16534), + (0x351e, 'abs', '.', 147748), + (0x3524, 'abs', 'BS_AILASER', 0), + (0x352a, 'abs', '.', 178488), + (0x352e, 'abs', 'BS_BARREDA', 0), + (0x3534, 'abs', '.', 178508), + (0x353e, 'abs', '.', 178512), + (0x3570, 'abs', '.', 178484), + (0x3576, 'abs', '.', 178484), + (0x357c, 'abs', '.', 13911), + (0x3583, 'abs', '.', 178488), + (0x3587, 'abs', 'BS_BARLIVEA', 0), + (0x358c, 'abs', 'BS_FRAMEA', 0), + (0x3595, 'rel', 'BS_SINA', -4), + (0x359e, 'abs', '.', 13915), + (0x35a4, 'abs', '.', 13919), + (0x35aa, 'abs', '.', 178508), + (0x35b0, 'abs', '.', 178512), + (0x35bd, 'abs', '.', 178512), + (0x35c7, 'abs', '.', 178488), + (0x35cb, 'abs', 'BS_BARONA', 0), + (0x35d4, 'abs', '.', 178496), + (0x35de, 'abs', '.', 178512), + (0x35e7, 'abs', '.', 178500), + (0x35f0, 'abs', '.', 178500), + (0x360b, 'abs', '.', 178496), + (0x3615, 'abs', '.', 178500), + (0x361f, 'abs', '.', 178504), + (0x3628, 'abs', '.', 178504), + (0x3636, 'rel', 'BS_SFX', -4), + (0x3640, 'abs', '.', 178500), + (0x364a, 'abs', '.', 178504), + (0x366c, 'abs', 'BS_BARONA', 0), + (0x3672, 'abs', '.', 14940), + (0x367d, 'abs', 'BS_OBJA', 0), + (0x368f, 'abs', 'BS_BARLIVEA', 0), + (0x3697, 'abs', 'BS_BARONA', 0), + (0x369d, 'abs', '.', 14940), + (0x36a8, 'abs', 'BS_OBJA', 0), + (0x36ba, 'abs', 'BS_BARLIVEA', 0), + (0x36c2, 'abs', 'BS_BARONA', 0), + (0x36c8, 'abs', '.', 14940), + (0x36d3, 'abs', 'BS_OBJA', 0), + (0x36e5, 'abs', 'BS_BARLIVEA', 0), + (0x36fe, 'abs', '.', 14896), + (0x3704, 'abs', '.', 14900), + (0x370c, 'abs', '.', 14892), + (0x3712, 'abs', '.', 14904), + (0x3718, 'abs', '.', 14908), + (0x3724, 'abs', '.', 14908), + (0x373a, 'abs', '.', 14908), + (0x3749, 'abs', 'BS_WIND1', 0), + (0x3750, 'abs', '.', 14816), + (0x3756, 'abs', '.', 14816), + (0x3763, 'abs', '.', 14820), + (0x3769, 'abs', '.', 14820), + (0x376f, 'abs', '.', 14824), + (0x3775, 'abs', '.', 14824), + (0x377b, 'abs', '.', 14908), + (0x3787, 'abs', 'BS_WIND1', 0), + (0x378e, 'abs', '.', 14912), + (0x3794, 'abs', '.', 14908), + (0x37a3, 'abs', 'BS_WIND1', 0), + (0x37aa, 'abs', '.', 14916), + (0x37b0, 'abs', '.', 14908), + (0x37bf, 'abs', 'BS_WIND1', 0), + (0x37c5, 'abs', 'BS_IDA', 0), + (0x37d3, 'rel', 'BS_VIEWA', -4), + (0x37d8, 'abs', '.', 14924), + (0x37df, 'abs', '.', 14920), + (0x37e4, 'abs', '.', 14928), + (0x37eb, 'abs', 'BS_RPITCH1', 0), + (0x37f1, 'rel', 'BS_COSA', -4), + (0x37fa, 'abs', '.', 14928), + (0x3800, 'abs', '.', 14932), + (0x3807, 'abs', 'BS_RYAW1', 0), + (0x380d, 'rel', 'BS_SINA', -4), + (0x3816, 'abs', '.', 14932), + (0x3825, 'abs', 'BS_RYAW1', 0), + (0x382b, 'rel', 'BS_COSA', -4), + (0x3834, 'abs', '.', 14932), + (0x3843, 'abs', 'BS_RPITCH1', 0), + (0x3849, 'rel', 'BS_SINA', -4), + (0x3852, 'abs', '.', 14928), + (0x3862, 'rel', 'BS_VIEWA', -4), + (0x386f, 'rel', 'BS_VIEWA', -4), + (0x3ad0, 'abs', '.', 14956), + (0x3ad8, 'abs', '.', 14972), + (0x3adc, 'abs', '.', 14956), + (0x3b60, 'abs', 'BS_ZPARTS', 0), + (0x3b74, 'abs', 'BS_ZPARTS', 0), + (0x3b88, 'abs', 'BS_ZPARTS', 0), + (0x3b9c, 'abs', 'BS_ZPARTS', 0), + (0x3bb0, 'abs', 'BS_ZPARTS', 12), + (0x3bc4, 'abs', 'BS_ZCROWN', 0), + (0x3bd8, 'abs', 'BS_ZRINGS', 0), + (0x3bec, 'abs', 'BS_ZPARTS', 24), + (0x3c00, 'abs', 'BS_ZSIDES', 0), + (0x3c14, 'abs', 'BS_ZSIDES', 0), + (0x3c28, 'abs', 'BS_ZSIDES', 0), + (0x3c3c, 'abs', 'BS_ZSIDES', 0), + (0x3c50, 'abs', 'BS_ZPARTS', 36), + (0x3c64, 'abs', 'BS_ZPARTS', 60), + (0x3c78, 'abs', 'BS_ZPARTS', 72), + (0x3c8c, 'abs', 'BS_ZPARTS', 48), + (0x3ca0, 'abs', 'BS_ZPARTS', 60), + (0x3cb4, 'abs', 'BS_ZPARTS', 72), + (0x3ce8, 'abs', '.', 16708), + (0x3cec, 'abs', '.', 15648), + (0x3cfc, 'abs', '.', 79108), + (0x3d00, 'abs', '.', 15656), + (0x3d10, 'abs', '.', 110308), + (0x3d14, 'abs', '.', 15664), + (0x3d20, 'abs', '.', 15672), + (0x3d28, 'abs', '.', 15672), + (0x3d30, 'abs', '.', 15672), + (0x3fec, 'abs', 'BS_LOGOJ', 0), + (0x4054, 'abs', 'BS_LOGOZ', 0), ), { - 'quad2d_a': 0x0, - 'quad2d_b': 0x1f, - 'walk_a': 0x3e, - 'walk_b': 0x5d, - 'clipproj_a': 0x7c, - 'clipproj_b': 0x93, - 'flag_a': 0xaa, - 'flag_b': 0xae, + 'tick': 0x0, + 'confirm_a': 0x155, + 'selscr_a': 0x1a7, + 'selhide_a': 0x311, + 'selmax_a': 0x330, + 'selinit_a': 0x34e, + 'selcol_a': 0x36b, + 'selmdl_a': 0x3d4, + 'selpart_a': 0x484, + 'selzdraw': 0x504, + 'selzbounce': 0x7af, + 'sel_loadzmot': 0x888, + 'selcull_a': 0x930, + 'selsled_a': 0x976, + 'selzlift': 0x989, + 'selsky_a': 0xb34, + 'selspray_a': 0xb79, + 'selzy_a': 0xbc1, + 'selpalev_a': 0xbd3, + 'selfloor_a': 0xc58, + 'seljagpal': 0xc68, + 'selstate': 0xcd5, + 'selpalguard': 0xce6, + 'selpair': 0xd51, + 'selpalback': 0xd67, + 'selrows_each': 0xd82, + 'selrest': 0xdd4, + 'seldrawpal': 0xe17, + 'selbosspal': 0xe38, + 'selfade': 0xeb6, + 'selremap': 0xf75, + 'selcol': 0xfbe, + 'selbcol': 0x1041, + 'selstep_sube': 0x1059, + 'selstep_sub': 0x10a3, + 'selstep_adde': 0x10cb, + 'selstep_add': 0x1115, + 'selcur': 0x113d, + 'sel_loadrb': 0x114a, + 'sel_slotsin': 0x11cd, + 'sel_slotsout': 0x1224, + 'selinfo_a': 0x125d, + 'selqinfo_a': 0x12e2, + 'selplane': 0x13a9, + 'sellines': 0x13cb, + 'selrow_make': 0x1444, + 'selshift': 0x14b5, + 'selrowx': 0x14d6, + 'seltitlex': 0x14e9, + 'selmark1': 0x14fa, + 'selmark2': 0x150f, + 'selframe1': 0x1524, + 'selframe2': 0x1539, + 'selclr_a': 0x154e, + 'seltime': 0x1563, + 'selframex': 0x1580, + 'pal_a': 0x15ac, + 'bosspal': 0x15cf, + 'pose_a': 0x161b, + 'model_ra': 0x1629, + 'model_ua': 0x1642, + 'model_rap': 0x17e6, + 'model_raj': 0x1988, + 'unl_zdraw': 0x1b2c, + 'unl_jdraw': 0x1b67, + 'ident_a': 0x1bc4, + 'noshade_a': 0x1bf2, + 'nozshade_a': 0x1c0a, + 'name_a': 0x1c27, + 'unl_load': 0x1c4e, + 'unl_save': 0x1ca7, + 'zlock': 0x1cdd, + 'unl_tick': 0x1dc5, + 'unl_tileat': 0x1ece, + 'unl_grab': 0x1f2b, + 'unl_place': 0x1f5e, + 'unl_unplace': 0x201a, + 'unl_palsave': 0x2037, + 'unl_palback': 0x205c, + 'unl_scnsave': 0x2081, + 'unl_scnback': 0x20fd, + 'unl_ldtex': 0x216d, + 'unl_ok': 0x2184, + 'unl_lost': 0x219e, + 'unl_jag': 0x21af, + 'unl_z': 0x21f6, + 'unl_text': 0x226b, + 'unl_logic': 0x227a, + 'loads_a': 0x2525, + 'deref_a': 0x2538, + 'case2_a': 0x2554, + 'end_a': 0x2567, + 'zend_a': 0x25eb, + 'zwall_a': 0x28fe, + 'zbeam_off': 0x2912, + 'zbeam_a': 0x2934, + 'etrans_a': 0x299d, + 'is_zgradt': 0x2abf, + 'cam_4': 0x2ac7, + 'live_a': 0x2b13, + 'zeye_a': 0x2b58, + 'init_a': 0x2b96, + 'fly_a': 0x2bbe, + 'zflyin_a': 0x2c43, + 'zready_a': 0x2ca0, + 'zfire_a': 0x2cf6, + 'zfloor_a': 0x2d24, + 'tm_2': 0x2df0, + 'tm_4': 0x2e26, + 'clip_a': 0x2e5c, + 'clone_a': 0x2e94, + 'ai_a': 0x2f2b, + 'zinit_a': 0x3049, + 'zflyout': 0x3075, + 'zfly_draw_a': 0x3140, + 'zswap': 0x31b7, + 'jpose_a': 0x3204, + 'zpost_a': 0x323d, + 'zgold_a': 0x3260, + 'zrest_a': 0x328d, + 'zdark_a': 0x32ed, + 'zfade_a': 0x3309, + 'zring_a': 0x3325, + 'jlum_a': 0x33cb, + 'zgauge_a': 0x33fa, + 'zg_fill': 0x350f, + 'zg_press': 0x35d2, + 'zg_full': 0x3653, + 'zg_cent': 0x3657, + 'zg_pamp': 0x365b, + 'zg_pbase': 0x365f, + 'zg_name': 0x3663, + 'zbar_ra': 0x366a, + 'zbar_la': 0x3695, + 'zbar_ba': 0x36c0, + 'winfactor': 0x36eb, + 'win_1': 0x3738, + 'win_1t': 0x374e, + 'win_1a': 0x378c, + 'win_1b': 0x37a8, + 'rep_1': 0x37c4, + 'name_jag': 0x3873, + 'name_z': 0x3881, + 'unl_file': 0x388c, + 'unl_you': 0x3897, + 'unl_press': 0x38a4, + 'unl_grow': 0x38bd, + 'unl_size': 0x38c1, + 'unl_level': 0x38c5, + 'unl_read': 0x38c9, + 'unl_clean': 0x38cd, + 'unl_zwon': 0x38d1, + 'unl_on': 0x38d5, + 'unl_t': 0x38d9, + 'unl_prev': 0x38dd, + 'unl_go': 0x38e1, + 'unl_got': 0x38e5, + 'unl_placed': 0x38e9, + 'unl_first': 0x38ed, + 'unl_count': 0x38f1, + 'unl_x1': 0x38f5, + 'unl_y1': 0x38f9, + 'unl_x2': 0x38fd, + 'unl_y2': 0x3905, + 'urm_jag': 0x3909, + 'urm_z': 0x3915, + 'unl_px': 0x3921, + 'unl_py': 0x3925, + 'stood_ca': 0x3929, + 'pull': 0x3930, + 'zcam_k': 0x3934, + 'jcam_k': 0x3938, + 'cam_min': 0x393c, + 'zcam_near': 0x3940, + 'ecam_jag': 0x3944, + 'ecam_z': 0x3948, + 'ecam_zfly': 0x394c, + 'ecap_d': 0x3950, + 'zcharge': 0x3954, + 'zfly_on': 0x3958, + 'zfly_y': 0x395c, + 'zfly_z': 0x3960, + 'zfly_p': 0x3964, + 'zfly_n': 0x3968, + 'zfly_g': 0x396c, + 'zfly_h': 0x3970, + 'zfly_v1': 0x3974, + 'zfly_v2': 0x3978, + 'zfly_z1': 0x397c, + 'zgold': 0x3980, + 'zbeam_v': 0x3984, + 'zbeam_y': 0x3988, + 'zbeam_z': 0x398c, + 'zbeam_n': 0x3990, + 'zbeam_free': 0x3994, + 'zbeam_far': 0x3998, + 'zspd': 0x399c, + 'zspd_at': 0x39a0, + 'zspd_k': 0x39a4, + 'zslow': 0x39a8, + 'end_g1p': 0x39ac, + 'zstage': 0x39b0, + 'eside': 0x39b4, + 'eside_n': 0x39b8, + 'rm_jag': 0x39bc, + 'rm_z': 0x39c8, + 'rrm_jag': 0x39d4, + 'win_tries': 0x39e0, + 'win_turn': 0x39e4, + 'win_steps': 0x39e8, + 'zr_wait': 0x39ec, + 'zl_prev': 0x39f0, + 'zl_on': 0x39f4, + 'zl_ang': 0x39f8, + 'zf_start': 0x39fc, + 'zfl_wall': 0x3a24, + 'zfl_step': 0x3a28, + 'win_z': 0x3a2c, + 'win_jag': 0x3a30, + 'win_jmin': 0x3a34, + 'win_zmin': 0x3a38, + 'win_share': 0x3a3c, + 'win_35': 0x3a40, + 'win_30': 0x3a44, + 'rep_z': 0x3a48, + 'rep_jag': 0x3a4c, + 'pullk': 0x3a50, + 'pullh': 0x3a54, + 'was': 0x3a58, + 'boss': 0x3a5c, + 'bsrc': 0x3a60, + 'bcolor': 0x3a64, + 'bside': 0x3a68, + 'sel_step': 0x3a6c, + 'sel_bstep': 0x3a70, + 'sel_one': 0x3a74, + 'sel_twenty': 0x3a78, + 'sel_zgap': 0x3a7c, + 'sel_zy': 0x3a80, + 'sel_zscale': 0x3a84, + 'sel_zstep': 0x3a88, + 'sel_zrise': 0x3a8c, + 'sel_zlook': 0x3a90, + 'sel_zback': 0x3a94, + 'sel_bcol': 0x3a98, + 'sel_bslots': 0x3aa0, + 'sel_rowsin': 0x3ab0, + 'sel_objst': 0x3ab4, + 'sel_lpair': 0x3ab8, + 'sel_launch': 0x3ac0, + 'sel_remap': 0x3ac4, + 'sel_remapto': 0x3ac8, + 'sel_fjag': 0x3ad0, + 'sel_fz': 0x3ad8, + 'sel_fedge': 0x3ae4, + 'sel_fslope': 0x3ae8, + 'sel_ffloor': 0x3aec, + 'sel_f65536': 0x3af0, + 'sel_zup': 0x3af4, + 'sel_zexit': 0x3af8, + 'sel_zthrust': 0x3afc, + 'sel_zclear2': 0x3b00, + 'sel_zclear': 0x3b04, + 'sel_zfast': 0x3b08, + 'sel_zdive': 0x3b0c, + 'sel_zdivemax': 0x3b10, + 'sel_zskim': 0x3b14, + 'sel_zclimb': 0x3b18, + 'sel_zeye': 0x3b1c, + 'sel_zrad': 0x3b20, + 'sel_zease': 0x3b24, + 'sel_zpivot': 0x3b28, + 'sel_zpivotn': 0x3b2c, + 'sel_ztilt': 0x3b30, + 'sel_zspin': 0x3b34, + 'sel_zhead': 0x3b38, + 'sel_eight': 0x3b3c, + 'sel_four': 0x3b40, + 'sel_zbob': 0x3b44, + 'sel_zturn': 0x3b48, + 'sel_zprevz': 0x3b4c, + 'sel_zflamey': 0x3b50, + 'sel_zflamerx': 0x3b54, + 'sel_zflames': 0x3b58, + 'sel_zjet': 0x3b5c, + 'selzparts': 0x3b60, + 'selzmotok': 0x3ccc, + 'selzgot': 0x3cd0, + 'selzmtname': 0x3cd4, + 'selzmots': 0x3ce0, + 'selzmot': 0x3d20, + 'selzdip': 0x3d28, + 'selzrec': 0x3d30, + 'selzpose': 0x3d38, + 'seljagdraw': 0x3f40, + 'sel_jagcam': 0x3f44, + 'sel_neck': 0x3f50, + 'selbuilt': 0x3f5c, + 'selt0': 0x3f60, + 'seltxt': 0x3f90, + 'sel_frx': 0x4060, + 'sel_rbin': 0x4070, + 'sel_rbsave': 0x4072, + 'selblank': 0x407a, + 'zmine': 0x408e, + 'copied_a': 0x4092, + 'banked_a': 0x4096, + 'rmbase_on': 0x409a, + 'stood_a': 0x409e, + 'unl_palin': 0x40a2, + 'unl_scn': 0x40a6, + 'unl_scnmem': 0x40aa, + 'unl_scnin': 0x40ae, + 'unl_glow': 0x40b2, + 'unl_sega': 0x40be, + 'unl_texb': 0x40c2, + 'unl_texnow': 0x40c6, + 'bss': 0x40d0, + 'zfake': 0x40d0, + 'zpose': 0x40f0, + 'selzmotion': 0x4144, + 'selzdipf': 0x13504, + 'selzrecf': 0x1aee4, + 'selzvar': 0x228c4, + 'selzout': 0x228f8, + 'selrow': 0x22cf8, + 'selhas': 0x23148, + 'selrows': 0x2314c, + 'seld68': 0x2323c, + 'sellcam': 0x23264, + 'selda8': 0x232dc, + 'selpath': 0x23304, + 'sel_rbbuf': 0x23408, + 'sel_rbtry': 0x23438, + 'selscript': 0x23444, + 'copy_a': 0x23924, + 'bank_a': 0x24124, + 'scratch_a': 0x2430c, + 'zring': 0x244f4, + 'zg_tmp': 0x2b934, + 'zg_mat': 0x2b938, + 'zg_width': 0x2b93c, + 'zg_held': 0x2b940, + 'zg_timer': 0x2b944, + 'zg_sounded': 0x2b948, + 'zg_h': 0x2b94c, + 'zg_ready': 0x2b950, + 'objsave': 0x2b954, + 'stand_a': 0x2bf54, + 'standai_a': 0x2c554, + 'rmbase': 0x2c73c, + 'aisave_a': 0x2c76c, + 'stand_ca': 0x2c954, + 'standai_ca': 0x2cf54, + 'unl_tiles': 0x2d13c, + 'unl_area': 0x31a3c, + 'sel_rowskept': 0x363bc, + 'unl_pals': 0x37bbc, + 'unl_map': 0x43bbc, + 'fxsave': 0x43c58, + 'fx2save': 0x43fb8, }), 'PAD_COND': (bytes.fromhex( '0200000000100000020000000020000002000000004000000200000000800000' @@ -5966,6 +17872,42 @@ def blob_of(name, blobs=None): return blobs[name] +def own_len(name, blobs=None): + """How much of a blob with a section of its own the file carries: up + to its last byte that is not zero. The rest is the section's virtual + size.""" + return len(blob_of(name, blobs)[0].rstrip(b'\0')) + + +def own_place(build, blobs=None): + """name -> (virtual address, file offset) of each of a build's own + sections, as add_section lands them one after the annex: the next page + after the last section, at the next 0x200 of the file.""" + out = {} + if not build.own: + return out + va, raw = build.annex[0], build.annex[1] + vlen = rlen = annex_layout(build, blobs)[1] + for name in build.own: + va = (va + vlen + 0xfff) & ~0xfff + raw += rlen + out[name] = (va, raw) + vlen = len(blob_of(name, blobs)[0]) + rlen = (own_len(name, blobs) + 0x1ff) & ~0x1ff + return out + + +def file_end(build, blobs=None): + """The patched file's length before any apply-time section: the + annex and the build's own sections, every one of them ticked.""" + end = build.size + if build.annex: + end = build.annex[1] + annex_layout(build, blobs)[1] + for name, (_va, raw) in own_place(build, blobs).items(): + end = raw + ((own_len(name, blobs) + 0x1ff) & ~0x1ff) + return end + + def annex_layout(build, blobs=None): """name -> offset into the annex, and the annex's padded length.""" out, at = {}, 0 @@ -5983,6 +17925,8 @@ def cave_va(name, build, blobs=None): blobs = BLOBS if blobs is None else blobs if build.annex and name in build.annex[2]: return build.annex[0] + annex_layout(build, blobs)[0][name] + if name in build.own: + return own_place(build, blobs)[name][0] at = build.caves[name] if isinstance(at, tuple): inner, label = at @@ -6020,7 +17964,7 @@ def link(name, build, blobs=None, base=None): `base` overrides the cave, for a blob whose address is only known at apply time; None means the blob must not name itself.""" code, fixups, _labels = blob_of(name, blobs) - if base is None and (name in build.caves + if base is None and (name in build.caves or name in build.own or (build.annex and name in build.annex[2])): base = cave_va(name, build, blobs) out = bytearray(code) @@ -6137,14 +18081,26 @@ def rva(target): ' end: raise AssertionError('%s at 0x%08x runs %d bytes past the end' % (key, off, off + len(old_b) - end)) @@ -7315,8 +19956,12 @@ def _check_table(build=RETAIL): raise +# Extras that change how the game plays rather than fix it, so start unticked. +OPT_IN = ('bosses', 'bossunlock') + + def default_state(): - return {key: True for key in BY_KEY} + return {key: key not in OPT_IN for key in BY_KEY} def apply_feature(buf, sites): @@ -8823,9 +21468,10 @@ def next_rva(self): unit = self.salign return (last['vaddr'] + last['vsize'] + unit - 1) // unit * unit - def add_section(self, name, payload, chars=0xE0000040): + def add_section(self, name, payload, chars=0xE0000040, vsize=0): """Append a section rather than borrow padding: .text has no room - left and the zero runs in .data are globals the game writes.""" + left and the zero runs in .data are globals the game writes. A + vsize past the payload is mapped too, zeroed by the loader.""" def up(value, unit): return (value + unit - 1) // unit * unit @@ -8841,15 +21487,16 @@ def up(value, unit): rsize = up(len(payload), self.falign) self.d += payload + b'\0' * (rsize - len(payload)) + vsize = max(vsize, len(payload)) struct.pack_into('<8sIIII', self.d, hdr, name.encode('ascii')[:8], - len(payload), vaddr, rsize, raddr) + vsize, vaddr, rsize, raddr) struct.pack_into('