From 6dfe51709499114af49e4c83a0acdfd59e0f36ad Mon Sep 17 00:00:00 2001 From: Alvin Date: Thu, 8 Oct 2026 01:02:30 +0200 Subject: [PATCH] stuff --- BOB32_MIGRATION.md | 229 ++ C_IMPLEMENTATION.md | 373 ++- C_OS.md | 229 +- README.md | 9 + bob-files.b32 | Bin 0 -> 17264 bytes bob.exe | Bin 63875 -> 79583 bytes bob32.exe | Bin 0 -> 79583 bytes build-tool.exe | Bin 0 -> 42852 bytes build.exe | Bin 43703 -> 42852 bytes kernel.basm | 7329 ++++++++++++++++++++++++++---------------- kernel/API.md | 67 +- kernel/bob.h | 5 +- kernel/bob_string.h | 125 + kernel/compiler.c | 773 ++++- kernel/files.c | 109 +- kernel/input.c | 4 + kernel/kernel.c | 4 + kernel/runtime.c | 22 +- kernel/runtime.h | 33 +- kernel/shell.c | 134 +- kernel/stdbool.h | 9 + kernel/stddef.h | 11 + kernel32.b32 | Bin 0 -> 189668 bytes main.c | 726 ++++- storage.c | 81 +- tests/AUDIT.md | 289 ++ tests/test_cpu.c | 380 +++ tests/test_os.c | 896 +++++- tools/arithmetic.c | 14 +- tools/arithmetic32.c | 75 + tools/bobcc.c | 1160 ++++++- tools/build.c | 35 +- tools/unsigned.c | 26 + 33 files changed, 9970 insertions(+), 3177 deletions(-) create mode 100644 BOB32_MIGRATION.md create mode 100644 bob-files.b32 create mode 100644 bob32.exe create mode 100644 build-tool.exe create mode 100644 kernel/bob_string.h create mode 100644 kernel/stdbool.h create mode 100644 kernel/stddef.h create mode 100644 kernel32.b32 create mode 100644 tests/test_cpu.c create mode 100644 tools/arithmetic32.c create mode 100644 tools/unsigned.c diff --git a/BOB32_MIGRATION.md b/BOB32_MIGRATION.md new file mode 100644 index 0000000..e2b118d --- /dev/null +++ b/BOB32_MIGRATION.md @@ -0,0 +1,229 @@ +# bob32 migration and source audit + +The active scope includes completing feasible C support, reviewing every source +file for bugs, and migrating the emulator/toolchain/applications to 32 bits. +These tasks are incomplete. This file tracks actual migration boundaries. + +## Current execution modes + +The emulator uses 32-bit general registers, accumulator and memory words. +B16K images and existing BASM run with 16-bit normalization and condition flags. +B32K images select native 32-bit word arithmetic and load/store behavior. +Both bob.exe and bob32.exe use this implementation. + +Instruction encoding remains 16-bit, while native-mode program counters and +effective addresses are 32-bit word addresses. The original 65,536-word region +uses the existing RAM array; higher addresses use lazily allocated sparse pages +(up to 4,096 resident pages of 4,096 words each). B32K version 2 images can load +and start anywhere in the 32-bit address space. Their payload is currently +limited to 65,536 words by the boot-disk buffer. Version 1 images and supervised +program entry points retain their legacy low-memory bounds. The host C compiler +emits B32K v2 images with `--wide`, and the build generates a B32K kernel image. +Its shell, editor, filesystem and resident compiler run; supervised legacy apps +execute with 16-bit arithmetic compatibility. In B32 mode, resident `cc` and +`go` emit native kind-2 programs with 32-bit `int`, stored in the guest RAM +filesystem and preserved by B32S snapshots. The resident compiler remains a +small C subset, with fixed-size one-dimensional local `int` arrays in bob32. +The host compiler's `--wide-app` mode emits larger B32K v2 images at the +supervised app origin. `import32 HOST_PATH NAME` validates and stores one in the +guest RAM filesystem; `run NAME` loads and executes it from there. `run32 PATH` +remains available for direct host-path execution. The 4,096-word guest file +region is shared by eight slots, so an imported image occupies six metadata +words, its payload and a terminator, less space already used by other files. +The loader validates the header, checksum, exact file size, entry and app-region +bounds, then preflights sparse memory before loading. B32S version 2 snapshots +preserve packed native files. Version 1 fixed-slot B32S snapshots remain +readable and are converted during restore; compatibility mode continues to use +B16S. + +The bob32 kernel is loaded at `0x10000`, above the 64K-word compatibility RAM; +the current image ends at `0x1D115`, leaving a gap before the native app origin. +Resident kind-2 programs and imported B32K v2 apps run from `0x20000`; resident +compiler output can use remaining packed filesystem capacity (up to 4,095 +words for one file), while source text remains limited to 511 words. Legacy kind-1 apps load at +`0xC200..0xCFFF` and keep 16-bit arithmetic compatibility. The 4,096-word B32 heap is +at `0xD000..0xDFFF`; the bob16 heap remains `0xC000..0xDFFF`. Legacy +applications retain access to their shared heap while their downward stack +starts at `0xD000`. +The bob16 OS loads kind-1 programs at `0xA000` to leave room for kernel growth. +Native B32 apps +use a separate high-memory range. + +The bob32 resident C compiler supports local pointers to integer-returning +functions with integer parameters. A pointer can be initialized from a declared +function and invoked indirectly; function-pointer parameters, return values, +globals and pointer arithmetic remain unsupported. This feature is not enabled +in the bob16 resident compiler. + +Resident prototypes distinguish `int f(void)` from `int f()`. The latter keeps +unspecified parameter status, while this compiler requires calls to match the +eventual definition's arity so its stack-based calling convention stays sound. + +## Wide image format + +B32K version 1 retains the original 16-byte header and low-memory bounds. Version +2 uses a 24-byte little-endian header: magic, 16-bit version, 16-bit header size +(24), 32-bit origin, entry, word count and additive checksum, followed by +32-bit little-endian payload words. The loader validates address overflow, +entry range, payload limit, checksum and exact file length before changing RAM. +It loads the payload directly and starts at the 32-bit entry address. Instruction +words still use the low-16-bit encoding and require zero upper bits; data words +retain all 32 bits. Run `bob32.exe --boot PATH` to load a B32K image. B32 +applications compiled with `--wide-app` use origin `0x20000`, and `run32` limits +their payload and entry to the supervised region below `0x100000`. B16K and +`--os` continue selecting the existing compatible kernel. + +## Audit evidence and remaining coverage + +Initial review covered the CPU state, fetch/address/ALU/store paths and image +loader in main.c, plus the snapshot width boundary in storage.c. It found and +fixed undefined negative left shifts in sign extension. Addition now uses +unsigned wraparound, and effective register-relative addresses use unsigned +arithmetic before address truncation, avoiding signed overflow in wide mode. + +tests/test_cpu.c exercises the actual CPU implementation: immediate sign +extension, both word-width boundaries/flags, wide memory loads/stores, wide +image reading, guest boot-disk transfer and execution, and mode selection. +The OS/compiler and native console suites also run against the migrated CPU. + +### Trap and return-register review + +The JSR/PUTS/GETS return-address assignments now apply the selected word-width +normalization, preserving signed bob16 register values above address 0x7fff. +PUTS no longer uses the instruction register as a string temporary; it compares +the complete data word with zero before emitting its low byte. This fixes early +termination of a wide string word such as 0x00010000 and preserves the decoded +trap instruction. GETS computes its input length once rather than repeatedly +scanning the entire string while copying it. + +The direct CPU suite now passes 47 checks, including both return-address widths, +wide supervised program results/parent restoration, instruction-state preservation +and full-width string termination. The compatibility suites pass 915 OS/compiler +checks and 28 native console checks. These are targeted findings from the current +review, not proof that every trap edge case or source line has been reviewed. + +### Image loader and cycle-limit argument review + +The --max-cycles parser previously accepted partial numbers and silently disabled +the limit for zero or invalid text. It now accepts only positive decimal values +within unsigned long range, rejecting signs, whitespace, trailing text and +overflow. Omitting the option still selects unlimited execution. + +The direct suite passes 65 checks, adding malformed wide-image subprocess cases +for short headers/payloads, wrong checksum, trailing bytes, invalid entry and +version, plus cycle-limit boundary/invalid values and an actual limited emulator +run with exit status 2. The 915 OS/compiler and 28 native console checks also +pass. Loader validation and argument parsing have been reviewed; wider addresses, +format evolution and the remaining source audit are still unfinished. + +### Assembler input and data directive review + +Source parsing now closes the input file through one wrapper on both success and +failure. Physical source lines above 255 characters reject rather than becoming +multiple instructions. CRLF characters are token separators. .fill requires one +complete unsigned hexadecimal word and rejects trailing garbage or truncation. + +.stringz now checks remaining memory before writing, fixing a possible host +out-of-bounds write. It emits exactly one terminator instead of appending a second +zero through the common instruction path. Following data therefore starts one +word earlier than with that bug; hand-counted offsets relying on the extra padding +need adjustment. The repository demo and compatibility suites still pass. +Assembly can use all 65,536 slots, with the next word rejected before writing. + +The direct suite now passes 73 checks, including exact-capacity assembly and a +near-end string overflow attempt. The 915 OS/compiler and 28 console checks pass. +Instruction operand parsing/encoding, especially atoi conversions and register +validation, still needs review; this is not a complete assembler or repository +audit. + +### Assembler numeric operands and branch flags + +All fourteen atoi operand conversions now use a complete signed-decimal parser +with host-int range checks. Invalid register-shaped tokens cannot silently become +immediate zero; missing digits, trailing text and overflowing numbers reject. +Valid operands still clamp to the existing instruction field widths. Branch +conditions reject unknown letters instead of silently omitting those flags. +The documented NOP instruction now assembles as zero and rejects extra operands. + +The direct suite passes 94 checks, including every numeric operand path, +malformed branch flags, preserved signed clamping/JSR/JSRR encodings and NOP. +The 915 OS/compiler and 28 console checks also pass. More encoding/decoder +round-trip checks and the other source files remain to audit; the full bob32 +compiler/kernel migration is still incomplete. + +### Storage service source review + +storage.c has been read through for hashing, metadata validation, descriptor +ranges, save replacement/error cleanup, and restore validation/commit ordering. +The descriptor upper bound now uses subtraction rather than descriptor+4, +preventing unsigned overflow in the internal service API. The guest trap already +narrows its argument, but direct service callers must also be safe. Restore now +checks stream errors and close failure before committing any buffered words. + +New direct cases validate empty/used snapshots and reject excessive lengths, +invalid kind/used flags, embedded text zeroes, missing terminators, duplicate +names, overflowing descriptors and wide-mode format use. The direct suite passes +105 checks; compatibility/persistence and console suites pass 915 and 28 checks. +This review does not establish power-loss durability. B32S now preserves full-width data; the remaining migration/audit areas stay open. + +### Native instruction word boundary + +Wide instruction fetch now rejects nonzero reserved upper bits rather than +silently truncating a 32-bit data word into a different instruction. The native +boot ROM stores zero-extended instruction words; legacy ROM/assembly words still +use signed 16-bit normalization. A supervised malformed wide instruction must +fault and restore parent CPU state, while legacy sign-extended RET remains valid. + +The direct suite passes 107 checks, and 915 OS/compiler plus 28 console checks +passed at that stage. The instruction encoding remains compact; B32K v2 later +extends image addresses without changing instruction words. A native 32-bit +compiler/kernel remains unfinished. + +### Register-controlled address boundary + +JMP, JSRR, RET and PUTS consume register-held addresses. In native mode these +paths preserve the complete address; previously values such as 0x10000 aliased +address zero. Compatibility mode retains its existing 16-bit wrapping. CPU +checks cover all four transfers, sparse high-memory loads/stores, indirect +loads/stores, high-address console/input/disk buffers, supervised high-data +access, B32K v2 high-origin boot, top-of-address-space loading, and malformed +header rejection. Version 1 image loading remains low-memory compatible. + +The entire repository has NOT yet been audited line by line. Remaining review +includes assembler/tokenization/error paths, all trap edge cases, image/storage +malformed input, compiler parsing/type checking/emission, arithmetic helpers, +kernel runtime/files/compiler/shell/input/editor, build code and test coverage. +Generated kernel.basm needs generator/round-trip validation rather than merely +assuming generated instructions are correct. Documentation examples and saved +formats also need migration checks. + +## Remaining migration requirements + +- [x] Define the 32-bit instruction/address ABI and emulator/image limits. +- [x] Add a 32-bit C compiler target and native arithmetic/runtime services. +- [x] Port the kernel, resident compiler, editor, memory allocator and filesystem. +- [x] Version persistent storage and verify compatibility/migration of saved files. +- Verify existing BASM, C applications and snapshots against compatibility mode; + verify rebuilt applications against the new ABI. +- Complete the whole-source audit and repair findings with targeted tests. +- Complete the remaining full-C implementation documented in C_IMPLEMENTATION.md. + +Native snapshot update: B32S version 1 used fixed 512-word file slots. Version 2 retains the 16-byte header and 4,312-word payload size, but packs bob32 file contents by length so native apps can exceed 511 words. Both use little-endian 32-bit words and a checksum over all four bytes. Version 1 snapshots are repacked during restore; version 2 is written going forward. + +Native filesystem app workflow: `import32 HOST_PATH NAME` validates B32K v2 images and packs their origin, entry, word count, checksum and payload into a guest file. `run NAME` validates the packed image, reserves all sparse pages before loading, runs the app and reports format, storage, memory, fault and timeout failures. `save` and `restore yes` persist the app through B32S. Integration coverage imports and runs a 629-word image through both `run` and `run32` guest-name commands, snapshots/restores it, and runs it again; direct checks cover checksum corruption and sparse-allocation failure. The current suites pass 203 CPU checks, 1,813 OS/compiler checks and 28 console checks. + +Storage address audit: native trap 7 preserves full-width descriptor and table addresses, allowing the relocated bob32 kernel's globals while checking that each table lies in low kernel RAM or the loaded kernel image. Out-of-range descriptors reject rather than alias. Legacy mode retains the signed 16-bit address representation. Native restore checks also verify changed-kernel handling: binary slots are omitted while source text survives. + +Decoder reserved-bit audit: NOP and RET require zero low 12 bits, register JSR requires zero low 8 bits, and in-place NOT requires zero low 8 bits. These fields were ignored previously. Malformed encodings now fault in both execution modes; valid instruction encodings remain covered by OS/application checks. + +Native trap argument audit: trap 3 accepts a full-width buffer address but keeps its capacity limited to 16 bits; trap 6 remains constrained to the supervised low-memory entry region. Legacy word-address representations remain accepted. Other trap/address paths still require complete review. + +Native disk trap boundary: trap 4 rejects upper bits in its destination, offset and count before narrowing or transferring words. Valid current-range native boot reads and legacy mode remain covered. This closes another argument-aliasing gap; full-width address and image ABI work is still unfinished. + +Assembler source lines now use a bounded byte reader that rejects embedded NULs rather than silently truncating them through C-string tokenization. It preserves the 255-character limit, CRLF handling and acceptance of a final unterminated line. The direct CPU/assembler suite passes 138 checks, including a binary fixture with an embedded zero; 1,568 OS/compiler checks also pass. + +Assembler `not` now requires exactly one destination register or a destination/source register pair. It no longer accepts extra operands or treats an invalid second register as the one-operand form. The direct suite covers those malformed forms and passes 141 checks; the OS/compiler suite passes 1,568 checks. + +All load/store register operands now reject every negative parse result, including malformed names and out-of-range register numbers. Previously those handlers rejected only missing tokens; invalid registers could flow into negative shifts and malformed encodings. Direct tests cover both `r8` and malformed names in each affected field. The suite passes 150 CPU checks; 1,568 OS/compiler checks pass. + +Assembler trap validation now matches the emulator's implemented vector table (0 through 11). Vectors 12 through 15 previously assembled successfully but faulted when executed. New rejection cases cover 12 and 15. Direct decoder tests also confirm reserved register-form ADD/AND bits fault in legacy and wide modes. The direct suite passes 156 CPU checks, and the OS/compiler suite passes 1,568. diff --git a/C_IMPLEMENTATION.md b/C_IMPLEMENTATION.md index 28a5609..080e485 100644 --- a/C_IMPLEMENTATION.md +++ b/C_IMPLEMENTATION.md @@ -11,7 +11,9 @@ the goal complete. Existing programs and the nano-like editor must keep working. unsigned conversions/promotions, pointer arithmetic, alignment, aggregate layouts, calling conventions, floating-point and wider integer representations. - Expand declarations: complete declarators, typedefs, qualifiers, storage - classes, lexical scopes/shadowing, prototypes, function pointers and variadics. + classes, lexical scopes/shadowing, prototypes, complete function-pointer support + and variadics. Typed function pointers and indirect calls now work in the host + compiler; return types and variadic function-pointer cases remain open. - Expand types: unsigned/signed integer variants, enums, structs/unions, nested arrays/pointers and supported floating-point types with software operations. - Expand expressions: sizeof, conditional/comma operators, full lvalue/type @@ -210,3 +212,372 @@ to 16. Function declarator suffixes still use the earlier direct-function parser function pointers and functions returning array pointers remain to implement. Qualifier semantics, compatible incomplete-type merging, the resident compiler architecture, remaining C types and the standard library are also incomplete. + +## Shift assignments and integer operand constraints + +The host lexer recognizes <<= and >>= before their two-character prefixes. +They parse as right-associative assignments and use the existing native shift +helpers, retaining single evaluation of the destination address. Tests cover +indexed destinations with side effects, chained assignment, expression precedence, +zero shifts and signed right shifts. Integer-only binary operators and unary +plus/minus/complement reject pointer operands, including unevaluated sizeof +expressions. This does not yet implement the full arithmetic conversion model. + +All 615 regression checks pass. These changes are in the host compiler; the +resident compiler's corresponding operators and broader C implementation remain +unfinished. + +## Composite function declaration types + +Function declaration checks now recursively form composite pointer/array types. +An unspecified array bound can match a known bound through additional pointer +levels, retaining the known bound. Conflicting known bounds, element types and +pointer depths still reject. Native tests cover forward declarations with +incomplete row types followed by complete definitions; rejection tests also +cover an incomplete declaration followed by two conflicting completions. +All 631 regression checks pass and the kernel rebuild remains 36,009 words. +Qualifier and old-style promotion compatibility, object redeclarations and the +remaining function declarator forms still require implementation. + +## Compound assignment and unevaluated constraints + +Compound assignments share an operator mapping and operand checks across native +emission and sizeof type inference. Pointer compound assignments allow only +integer addition/subtraction offsets with complete pointees; pointer subtraction +from another pointer remains a binary expression yielding an integer, not an +assignable pointer offset. Integer compound assignments reject pointer operands. +Assignment and increment checks inside sizeof require a modifiable scalar lvalue, +rejecting arrays, void objects and literal targets without evaluating operands. + +Native tests verify valid row-pointer offsets and sizeof suppression of indexed +and increment side effects. Rejection tests cover pointer differences in compound +assignments, pointer shifts, array/literal modification and void pointer offsets. +All 671 checks pass; kernel compilation stays at 36,009 words. Const semantics, +simple-assignment conversions and the remaining full expression/type checker +still need implementation, along with the resident compiler expansion. + +## File-scope object declarations and tentative definitions + +Global objects are registered by name and compatible declarations form a composite +type. Repeated tentative definitions share one allocation. One initialized +definition may replace the tentative zero initialization; a second initializer +rejects. File-scope extern declarations, including function declarations, parse +without creating storage for declaration-only objects. Referenced undefined +objects fail relocation resolution, while unused extern declarations are accepted. +Incomplete array bounds can be completed by another declaration, and a remaining +tentative array definition reserves one element at translation-unit completion. + +Native tests combine extern/tentative/initialized scalars, pointer relocations, +completed multidimensional arrays and an uncompleted tentative array. Rejections +cover conflicting object types/bounds, duplicate initialized definitions, +unresolved references and sizeof an uncompleted extern array. All 695 regression +checks pass; the kernel rebuild remains 36,009 words. + +This does not implement block-scope extern/static storage, internal linkage, +separate compilation or declaration-point-sensitive global visibility. Global +resolution still uses the complete source unit. Those semantics, the resident +compiler expansion and the remaining full-C roadmap stay unfinished. + +## Block-scope extern objects + +Block extern object declarations register compatible external types without +allocating local frame slots. Native emission activates a scoped alias to the +global storage; nested aliases can shadow outer automatic locals and repeated +compatible extern declarations in the same scope share the alias. Extern-only +names are withheld from the ordinary file-scope lookup, preventing them from +escaping their declaring block or appearing in another function without a +declaration. Referenced missing definitions still reject at relocation time. + +Native tests verify global writes through a nested alias, preservation of an +outer local, completed array types and repeated extern declarations. Rejection +tests cover unresolved objects, conflicting local/types, block initializers and +names escaping their block/function. All 727 checks pass and the kernel rebuild +remains 36,009 words. Block function declarations, static storage, full linkage +rules and separate compilation remain unfinished; these additions remain in +the host compiler rather than the resident compiler. + +## Function-local static storage + +Block static objects receive unique private data symbols and scoped aliases, +avoiding stack allocation and per-call initialization. Their native data is +initialized once at image load, with zero initialization for omitted values. +Static initializer references resolve against the declaring scope and retain +private symbols in pointer relocations; references to automatic storage reject. +Objects with equal names in different blocks/functions remain independent. + +Native tests exercise persistent counters, pointer access to another local static, +arrays, strings and independent same-name objects. Rejections cover automatic +values/addresses, runtime calls, duplicate declarations, escaped names and +uninitialized unsized arrays. All 755 regression checks pass; the kernel rebuild +remains 36,009 words. File-scope internal linkage, additional constant expression +forms and the resident compiler expansion remain incomplete. + +## File-scope static declarations and linkage checks + +File-scope objects/functions now parse static storage declarations and retain +linkage metadata. Repeated internal object declarations share one allocation; +subsequent extern declarations inherit existing linkage. Objects cannot switch +between external and internal linkage, and a static function declaration cannot +follow an external declaration. A function definition without a storage class +can follow its earlier static prototype. Incomplete internal tentative arrays +reject instead of silently receiving the external tentative-array completion. + +Native tests combine internal objects, arrays, relocated pointers, static +function prototypes and later extern declarations. Negative tests exercise both +object linkage conflict directions, conflicting function declarations and +incomplete internal arrays. All 783 checks pass; the kernel rebuild remains +36,009 words. This remains a single-unit compiler: separate compilation, linker +exports and cross-unit isolation still require implementation, as does the +resident compiler expansion. + +## Sizeof in constant initialization + +The constant evaluator now handles sizeof expressions using their inferred type. +Literal/type-based sizeof can be used in bounds and case labels, and global +initializers can use sizeof registered global objects. Local static initializer +sizeof operands are folded while their lexical bindings are active, allowing +sizes of automatic arrays without treating them as runtime values or addresses. +Unevaluated side effects remain suppressed. + +Native tests cover string/type bounds, global scalar/list initialization, local +static sizes of automatic objects and a sizeof case label. All 787 regression +checks pass and the kernel rebuild remains 36,009 words. Bounds and case labels +are still parsed before runtime symbols are registered, so sizeof a named object +in those contexts requires the remaining declaration-point symbol/type work. +The full-C goal and resident compiler expansion remain incomplete. + +## Parser type bindings for constant sizeof + +The parser retains object type bindings at declaration points, updates inferred +array types after initialization and restores bindings at block/for/function +boundaries. Parameter arrays expose their adjusted pointer type. Constant sizeof +in bounds, designators and case labels can therefore query declared object types +without depending on the later code-generation symbol table. Compatible repeated +file declarations retain a completed array bound in these parser bindings. + +Native tests verify named global/local/parameter sizes, nested shadowing and +restoration, loop scope and named sizeof case labels. Negative tests reject +forward, escaped block/loop and undeclared self references in bounds. All 807 +checks pass and the kernel rebuild remains 36,009 words. Parser type bindings +are limited to 4096 active declarations. This improves constant-expression +contexts; declaration-point visibility in ordinary generated expressions, +typedefs and the remaining full-C/resident work still require implementation. + +## Scoped typedef names + +Parser bindings distinguish objects, functions and typedef names in the ordinary +identifier namespace. Typedef declarations reuse the recursive declarator parser +for the currently supported scalar, pointer and array types, with comma-separated +aliases and identical same-scope redeclarations. Aliases work in declarations, +parameters, casts, sizeof and other aliases. A sole unnamed void alias parameter +specifies no arguments. Scope tracking restores outer aliases after a nested block +or loop and lets inner objects hide outer typedef names. + +Native tests combine scalar/pointer/row/incomplete-character-array aliases, +adjusted array parameters, casts, nested alias/object shadowing, loop declarations +and void aliases. Rejections cover incompatible aliases, object/function namespace +collisions, parameter collisions, escaped aliases and void objects. All 843 checks +pass; the kernel rebuild remains 36,009 words. Function-type aliases, qualifiers, +remaining C types and resident compiler support remain incomplete. + +## Enum types and scoped enumerators + +The host parser supports tagged/anonymous enum definitions, explicit integer +constant values and automatic increments. Enumerators share the ordinary +identifier namespace and become constant AST values at use sites. A separate +scoped tag table permits nested tag shadowing without conflating tag and object +names. Enum descriptors retain distinct identities and use the target's signed +16-bit int representation; declaration composites permit compatibility with that +chosen integer type while rejecting different enum identities. + +Native tests cover negative/automatic values, expressions referring to earlier +enumerators, typedef enum aliases, global objects, function parameters, array +bounds, case labels and nested block/loop shadowing. Rejections cover duplicate +tags/constants, namespace collisions, automatic signed overflow, escaped bindings, +constant assignment and conflicting enum parameter types. All 887 regression +checks pass; the kernel rebuild remains 36,009 words. Tags must already be defined +when referenced; incomplete enum extensions and unsigned/wider representations +remain unsupported. Resident enum parsing is still unfinished. + +## Boolean type and conversions + +The host type parser supports _Bool and aliases of it as a distinct one-word +primitive. Native conversion to 0/1 occurs at explicit casts, scalar/array +initialization, assignment, function arguments/returns and increment/decrement. +Static data initialization and constant casts use the equivalent host folding. +Function parameter emission applies the definition's boolean parameter type, +and declaration compatibility distinguishes bool from int. + +Native tests cover nonzero/zero global/local/static initialization, nested arrays, +integer/pointer casts, arguments, return values, compound assignments and prefix/ +postfix modification. Rejections cover incompatible boolean object/parameter +redeclarations. All 899 regression checks pass; the kernel rebuild remains +36,009 words. The standard stdbool header, complete arithmetic conversion rules, +other numeric types and resident boolean support still need implementation. + +## Unsigned int arithmetic foundation + +The host compiler supports explicit unsigned/unsigned int declarations and U/u +literal suffixes as a distinct 16-bit type. Expression inference propagates the +unsigned arithmetic result for current word-width int operands; comparisons, +division/remainder and right shifts select unsigned native operations. Constant +evaluation applies the corresponding unsigned behavior. Existing wraparound +addition/subtraction/multiplication use the same word instructions. + +tools/unsigned.c provides native unsigned comparisons, fixed-16-step division, +remainder and logical right shift. It is parsed only for a source unit using +explicit unsigned types/literals, preserving the existing kernel layout. +Native tests cover high-bit ordering, mixed signed operands, division/remainder +across the signed boundary, logical shifts, compound shifts and wraparound. +Conflicting parameter/object types and pointer division reject. All 915 checks +pass and the kernel rebuild remains 36,009 words. + +This is not the complete integer conversion model. Unsuffixed literal typing +retains prior behavior, other unsigned/wider integer types and all specifier +orderings are unfinished, and runtime shift/divide exceptional cases retain +the existing helper policy. Resident unsigned parsing/code generation remains +unfinished. Full C stays an active objective. + +Host declaration specifiers: signed and signed int now use the existing signed-int type, and int signed / int unsigned are accepted in either order. This applies to globals, locals, typedefs, parameters, return types, casts and sizeof type names. Duplicate int and repeated/conflicting sign specifiers fail compilation. Wider integer types, signed/unsigned char, qualifier enforcement and the resident compiler remain separate work. + +Host literal audit: all simple C escape sequences are now recognized, including \a, \f, \v and \?. Character and string escapes accept byte values 0..255. Hexadecimal accumulation checks the range before multiplication, preventing signed host overflow; out-of-range octal/hexadecimal escapes fail. A trailing backslash is rejected before advancing past the source terminator. This byte-literal extension does not provide wide literals, Unicode conversion or the remaining integer-width/type-selection work. + +Host input audit: binary zero bytes in preprocessed source are rejected instead of silently truncating the translation unit. Input seeks, reads, stream error and close are checked. Raw newline characters inside ordinary literals and malformed integer token tails now produce lexer errors. This does not expand target integer widths or floating-point support. + +Host relational pointer comparisons now use unsigned target address order, including across 0x8000, while signed integer comparisons retain signed order. Compatible pointer types use composite type checks, including pointers to arrays with known/incomplete bounds. Pointer/integer, incompatible pointee and void-pointer relational comparisons are rejected in evaluated expressions and sizeof operands. Full qualifier and aggregate compatibility remain unfinished. + +Host output audit: assembly, binary and map output streams now check write/close failures, and missing map output is a compilation failure. Derived map extensions apply only to the filename, preserving dotted parent directories. Input/output and map path collisions are rejected before writing; Windows checks normalize absolute paths and case. Hard-link/symlink aliases and atomic publication of all three files remain unresolved, and an I/O failure after publication starts can still leave partial outputs. + +Host void-expression constraints: arithmetic/comparison and logical operands, unary value operators, assignment sources, casts to value types and control-flow conditions now reject void results. Conditional expressions require both branches to be void when either is void. Equivalent checks apply inside sizeof without evaluating its operand. Discarded void calls, casts to void, comma expressions and two-void-branch conditionals remain valid. Other conversion, qualifier and aggregate constraints remain unfinished. + +Host return/argument constraints now reject return expressions in void functions, bare return statements in value-returning functions, void results returned as values, and void arguments to ordinary or trap-backed functions. Full assignment-compatible conversion checking remains incomplete. + +Host switch constraints: controlling expressions and case-label expressions must have an integer type. Pointer/array/void conditions and pointer/void labels are rejected. Unsigned integer, enum and _Bool switches remain supported. Complete integer-constant-expression rules and the remaining type conversion constraints still need review. + +Host const syntax: const can precede or follow scalar, typedef and enum specifiers, appear between signed/unsigned/int specifiers, and repeat at base or pointer levels. Direct const scalar objects, const array elements, scalar parameters, scalar globals, and const pointer objects (including pointer typedef aliases) reject assignment and increment. Address-of preserves const qualification; writes through const-qualified pointers reject, adding const in pointer assignments is allowed, and dropping it is rejected through nested pointer levels and conditional expressions. `bob_puts` accepts a const string. Function redeclarations now require matching pointed-to qualifiers while ignoring top-level parameter qualifiers. Some nested qualified-declarator forms and full C qualifier compatibility remain unfinished. + +Host pointer subtraction now checks composite type compatibility, including the target enum's compatible signed-int type and corresponding array rows. Both pointed-to types must have complete storage sizes. Different enum tags, different known row extents and incomplete element types remain rejected. + +Host conditional pointer types now combine compatible pointee types, preserve known array bounds, select void pointer for object/void pointer combinations, and permit arithmetic integer constant zero as a null branch. Incompatible pointer branches, nonzero integers and nonconstant integer branches are rejected, including inside sizeof. Null-constant recognition still requires review for all permitted unevaluated-expression cases; qualifier merging remains incomplete. + +Native bob16 multiplication now uses a sixteen-step bit-mask algorithm instead of operand-sized repeated addition. It computes the same low 16-bit product for signed and unsigned operands, including INT_MIN, without a sign-normalization branch. The host compiler arithmetic library and rebuilt kernel use it. The resident compiler also receives this improvement through its cc_multiply wrapper, which calls the shared runtime helper. Kernel size is now 36,005 words. + +Resident numeric lexer now treats leading-zero integer spellings as octal, accepts octal word values through 0177777, and rejects digits outside the base or values exceeding one word. Decimal range rules remain unchanged. Error handling sets EOF centrally, and the general compile-error message is shorter. Kernel size is 36,092 words, leaving four words below the current kernel/program boundary; increasing usable kernel capacity remains necessary for further resident features. + +Host code generation now omits zero-argument call cleanup and zero-sized function-frame allocation. Numeric constants normalize to their target 16-bit bit pattern before choosing short literal instructions, so values such as 0xffff can use the short -1 encoding. The rebuilt kernel is 35,909 words, saving 183 words and leaving 187 words below the current boundary. This creates some immediate room but does not replace the required memory-layout/bob32 work. + +Resident literal support now includes all simple C escapes, adding \r, \b, \a, \f, \v and \? to the existing newline/tab/quote/backslash forms. Numeric escapes and embedded string zero bytes remain unfinished. Host code generation collapses !!value to one boolean comparison while evaluating the operand once. Kernel size is 36,096 words: exactly the current reserved region, with no remaining growth space. + +Host frame generation now omits frame-pointer save/setup/restore for functions with no parameters and no automatic local storage. Return addresses remain saved, including recursive calls. Functions needing parameter/local addressing retain the existing frame layout. Kernel size is now 36,054 words, leaving 42 words below the boundary. + +Resident lexer now rejects raw LF/CR inside character and string literals while retaining escaped controls. Host code generation folds unary minus, complement and logical negation directly on numeric literals into target-word constants; runtime operands retain normal evaluation. Kernel size is 36,041 words, leaving 55 words of current-region capacity. + +Resident primary expressions now concatenate adjacent string literal tokens, including intervening comments/newlines and empty pieces. Each piece retains the lexer token limit; combined data goes through the existing bounded code emitter and receives one trailing zero. Numeric escapes and embedded zero bytes remain incomplete. Kernel size is 36,071 words, leaving 25 words below the current boundary. + +Resident code emission now stops after the first compiler error instead of continuing writes to its bounded scratch buffer. The existing 511-word capacity guard remains. Kernel size is 36,080 words, leaving 16 words below the current boundary. + +Native signed division now bypasses repeated subtraction when the normalized divisor is -1, covering original divisors 1 and -1. Sign detection uses the sign of the XOR of operands. Other divisors retain the existing subtraction algorithm. Host code generation also folds numeric-literal addition/subtraction/multiplication with the existing target-word constant evaluator. Kernel size is 36,093 words, leaving three words. + +Host constant evaluation now validates cast, unary, binary and conditional expression types before folding or selecting short-circuit branches. This prevents invalid void operand combinations from being accepted only in static initializers. The broader integer-constant-expression grammar still needs review. + +Host pointer equality now requires compatible pointer types, permits object/void pointer combinations, and requires an integer operand to be a recognized null constant. The checks apply in evaluated expressions and sizeof. Qualifier-aware pointer compatibility and complete null-constant grammar remain unfinished. + +Host simple assignment expressions now check pointer compatibility and null integer constants, rejecting implicit pointer-to-integer assignments except _Bool conversion. Equivalent validation applies inside sizeof. Declaration initializers and parameter/return conversion compatibility still require integration; qualifiers remain incomplete. Kernel source explicitly casts file_content's int-word storage to char source text, preserving existing machine output. + +Host return expressions now receive supported assignment-compatible conversion checks: pointer types must be compatible or object/void combinations, integer-to-pointer returns require a recognized null constant, and pointer-to-integer returns require an explicit cast except _Bool. Existing boolean return normalization remains. Argument/initializer compatibility, qualifications and aggregate conversions remain incomplete. + +Ordinary host-compiled function calls now enforce assignment-compatible argument conversions: compatible object pointers, object/void pointer conversions, integer constant zero and pointer-to-_Bool are accepted; incompatible pointers and implicit pointer/integer conversions are rejected. Trap intrinsic conversions and declaration initializer constraints still need further work. Kernel word-copy/fill and file-write APIs accept generic data pointers; text uses explicit casts where file buffers are word pointers. The regenerated 36,093-word kernel image is unchanged. + +Host scalar declaration initializers now enforce assignment-compatible conversions for automatic variables, global/static objects and individual array elements. Invalid nonzero integer-to-pointer, incompatible pointer, implicit pointer-to-integer and void-value initializers are rejected. Valid object/void pointer conversions, integer constant zero and pointer-to-_Bool conversions remain supported. Trap intrinsic conversion rules, qualifiers and other C constraints remain incomplete. Regenerating the kernel produces the identical binary. + +Emitted trap-backed calls now validate argument conversions against the intrinsic ABI: bob_puts/bob_gets require character pointers, bob_snapshot requires an integer descriptor pointer, and capacities, operations, characters and entry addresses require integer arguments. Object/void pointer conversions and integer null constants follow the same rules as ordinary calls. bob_call also rejects implicit pointer entry arguments. Unevaluated call validation and intrinsic declaration consistency still require review. The regenerated kernel binary is unchanged. + +Calls examined during expression type analysis now validate parameter counts and assignment-compatible argument types, including inside sizeof. Declaration selection prefers a function definition or a parameter-bearing prototype so an earlier empty parameter list cannot mask known parameters. A sizeof runtime fixture verifies arguments with increments remain unevaluated. Intrinsic declaration consistency, bob_address special cases and complete source-order declaration semantics remain open. The regenerated kernel binary is unchanged. + +Host subscript type analysis now rejects void-valued index operands in either order and requires a complete element type for the pointer operand. This also applies to unevaluated address-of/subscript expressions inside sizeof. Reversed indexing and unsigned indexes into multidimensional arrays remain supported. Kernel regeneration produces the identical 36,093-word image. + +Nested sizeof expressions now recursively validate their operands while remaining unevaluated. Address-of type checks reject numeric constants, arithmetic results, casts and increment results even inside sizeof. Address generation now supports pointers to complete string-literal arrays (for example char (*p)[5] = &"bob!"). Function pointers, full qualifier rules and several other lvalue constraints remain incomplete. + +Static address relocation now supports addresses of whole string-literal arrays, including global and block-static pointer-to-array initializers and scaled constant offsets. Existing string-element address initializers continue to work. This closes the storage-duration gap left by automatic address generation support; other static initializer forms remain incomplete. + +Static pointer initializer relocation now handles conditional expressions with constant conditions, including nested selections of object or string addresses. Full conditional type analysis runs before selecting a branch, preserving rejection of incompatible pointer types. Nonconstant conditions remain invalid for static initialization. Null-selected branches use the existing constant initializer path. + +Constant folding of numeric guest pointer arithmetic now scales offsets by complete element size, matching runtime arithmetic for pointer-to-array values. Pointer-plus-integer, integer-plus-pointer, pointer-minus-integer and pointer difference use the same word-based guest layout. Numeric address casts and static pointer differences are implementation extensions; this is not a claim of full standard constant-expression support. + +Unary code generation now performs expression type validation before emitting instructions, including optimized numeric unary operations. This closes a path that allowed increment/decrement of void lvalues to emit loads/stores even though the type-analysis path rejected them. Array increment remains invalid. Existing unary runtime tests continue to cover valid integer, pointer and Boolean operations. + +Static Boolean initializers now convert resolvable object/string addresses to one, including explicit _Bool casts, arrays and block-static objects. Numeric null pointers still convert to zero through constant evaluation. This implements the existing scalar-to-Boolean conversion consistently across automatic and static storage; full standard constant-expression and qualifier constraints remain incomplete. + +Relocation emission now validates both code and relocation capacities before writing either array. Literal-address and static-pointer emission share this checked path. Previously the relocation record was inserted before emit checked code capacity; now rejected oversized programs cannot grow relocation state past the emission boundary. + +Host literal lexing now grows checked heap storage as needed rather than rejecting strings above 8,190 characters. Character literal temporary storage is freed; string tokens retain their allocated bytes and explicit length, including embedded NULs. Overall source, object and emitted-code limits remain in force. This host change does not enlarge the resident compiler's token or file limits. + +Adjacent host string literals now concatenate with one sized allocation and one copy of each piece. The previous repeated-prefix allocations consumed quadratic time and retained quadratic storage for long runs of adjacent literals. Explicit byte lengths still preserve embedded NULs. Length is bounded by the existing source/token limits before parsing. + +Array bounds, array designator indexes and explicit enum values now require an integer expression type before constant evaluation. Pointer- and void-valued expressions are rejected in these contexts. Existing integer constant folding and enum/sizeof behavior remain supported; full standard integer-constant-expression grammar restrictions are still incomplete. + +Jump bookkeeping now routes all host call and branch jump records through a checked helper before appending to the fixed jump table. This makes the 65,536-entry jump limit explicit and keeps long-control-flow failure paths deterministic. Token and code limits normally trigger first, but the table itself is now guarded. + +Generated host labels now stop at an explicit 65,535-label serial limit, preventing signed counter overflow on unusually large generated control flow. The earlier emitted-code cap normally rejects first; this guard keeps the label namespace safe independently. + +Switch parsing now rejects case/default labels outside any switch before code generation and bounds nested switch parsing to 64 levels. This closes a validation gap where generation might fail later or skip malformed code. The host OS/compiler suite passes 1,540 checks, including file-scope and function-scope cases; the 256-labels-per-switch and 64-level boundaries remain explicit. + +Compile-time integer contexts now share one syntax check: array bounds, enum values, array designators and switch labels reject calls, assignments and increments, while integer operators, casts, conditional expressions and unevaluated sizeof expressions remain accepted. The host OS/compiler suite passes 1,556 checks, and the kernel remains 36,093 words. + +Integer constant expression validation now also checks operand types through nested casts and sizeof. Void and pointer expressions cannot be hidden inside an integer cast, unary/binary operation or conditional; regression cases cover sizeof of a void-valued cast in array and enum contexts. All 1,564 OS/compiler checks pass, with the kernel image unchanged. + +Explicit enum values now reject unsigned results outside the documented signed 16-bit int range instead of silently wrapping; signed boundary values remain valid. The OS/compiler suite passes 1,568 checks, with the generated kernel unchanged. + +Host expression parsing now caps recursive nesting at 256 levels, preventing deeply nested parentheses, unary operators or right-associative expressions from exhausting the host compiler stack. A generated 400-level array-bound fixture checks the diagnostic. All 1,573 OS/compiler checks pass; the 36,093-word kernel image hash is unchanged. + +B32 resident expression support now includes the right-associative conditional operator ?:. Code generation branches around the unselected expression, and nesting shares the existing 32-frame parser guard. Runtime coverage checks nested associativity and confirms skipped side effects. Kept B32-only because the bob16 kernel image remains at its 36,093-word size limit. The full suite passes: CPU 179, OS/compiler 1,745, native console 28. + +B32 resident control flow now supports do/while loops. Continue chains patch to the trailing condition, while break chains patch after the loop; regression covers first-iteration behavior, continue, break and a zero condition. The bob16 compiler remains unchanged due to the kernel image limit. Full suite: CPU 179, OS/compiler 1,745, console 28. + +B32 resident C now parses right-associative simple/compound assignment expressions, preserving the assigned value in the surrounding expression. Added <<= and >>= tokenization and code generation. A B32 shell regression checks chained assignment, assignment under comparison, and both compound shifts; it asserts all nine successful shell programs to avoid false positives from skipped/overlong input. Bob16 image remains 36,093 words. Full suite: CPU 189, OS/compiler 1,746, console 28. + +B32 resident C now supports multiple integer functions with stack-based parameters and locals, forward references, nested calls and recursion, including calls used as expression statements. A no-argument output helper, a two-argument helper and recursive factorial exercise the calling convention from the shell. Forward-call patch chains now store relative offsets until the callee definition is known; applying the program base twice previously made the call jump into unmapped memory. The end-to-end workflow checks all nine successful B32 shell programs. Current suite: CPU 189, OS/compiler 1,746, native console 28. + +B32 local declarations now follow lexical block scopes, including legal shadowing and for-initializer scope; stack slots remain unique even after a name leaves scope. Regression coverage also found that the expanded B32 kernel overlaps the old `0x9000` legacy-app base. Kind-1 applications now execute at `0xB000..0xBFFF` in the bob32 OS while bob16 remains at `0x9000`; B32 snapshot descriptors may reside up to that boundary. Removing the unnecessary post-run kernel restore preserves the RAM file table. The end-to-end tests cover recursive resident functions, block shadowing, a legacy `LEA/PUTS/HALT` binary, file listing after execution, and snapshot save/restore. Current CPU suite: 189; OS/compiler: 1,746; console: 28. + +The resident B32 compiler now rejects a 33rd cumulative local stack slot across lexical scopes. Its LDR/STR frame displacements are signed six-bit fields; silently masking larger negative offsets could bind locals to the wrong frame word. A generated 33-block regression confirms the source is rejected cleanly. The rebuilt B32 kernel is 43,113 words; OS/compiler suite: 1,749 checks passed. + +Resident bob32 C now supports fixed-size one-dimensional local `int` arrays within the 32-slot frame budget. Array declarations reserve contiguous slots and zero them; `array[index]` emits a frame-relative load, while indexed assignment statements preserve the computed address across right-hand-side calls. A shell program fills and sums four elements in loops and prints `bob!`. Array initialization, parameter arrays, multidimensional arrays, and bob16 resident array support remain open. The regenerated B32 kernel is 44,250 words, ending 70 words below the then-current `0xB000` legacy-app boundary; OS/compiler suite: 1,752 checks passed. + +To preserve space for further C support, the B32 legacy kind-1 region now starts at `0xB800` and reserves 2,048 words through `0xBFFF`; the largest RAM-file app is 511 words. The emulator, kernel loader, snapshot descriptor boundary, CPU regression and user-facing maps were updated together. The current 44,250-word kernel ends at `0xAFBA`, 2,118 words below the new window. CPU boundary fixtures verify writes at `0xB800` and rejection below it. Full suites: CPU 191, OS/compiler 1,752, console 28. + +Supervised-store review found a range hole: native apps faulted in 0x100000..0x10FFFF but could write again at 0x110000 and above. Store validation now uses the documented half-open application range and denies all other addresses. CPU regressions cover the last valid word, both sides of the boundary, arbitrary high sparse memory and UINT32_MAX. Full suite: CPU 185, OS/compiler 1,746, console 28. + +B32 external application loading now reserves every missing sparse page before installing pages or copying image words. Sparse-page allocation failure returns the loader error without exiting the emulator or modifying the target region. A BOB_TESTING-only allocator fault regression verifies the failure path. The full suite passes: CPU 186, OS/compiler 1,746, console 28. + +Guest trap-6 audit found that a nested run attempt returned the intended -1 but then reset the outer B32 application's mode flag, causing later valid stores to fault. Nested calls now return before touching that flag. A CPU regression verifies the app continues, writes within high memory and exits. The full suite passes: CPU 187, OS/compiler 1,746, console 28. + +Resident bob32 array statements now support indexed postfix increment/decrement and all compound assignments, including shifts implemented through helper calls. The regression fills an array, applies `++`, `+=` and `<<=`, then checks the summed result; indexed addresses remain protected across RHS evaluation and helper calls. The 44,833-word kernel ends at `0xB221`, leaving 1,503 words before the `0xB800` app boundary. Full suites: CPU 191, OS/compiler 1,752, console 28. + +Resident bob32 fixed-size local arrays now accept scalar brace initializers with an optional trailing comma. The compiler retains zero-filled omitted elements and rejects excess elements; an end-to-end program verifies initialized values and zero padding before performing array updates, and a negative program verifies excess-element rejection. B32 kernel: 45,070 words, ending at `0xB30E` with 1,266 words before the `0xB800` legacy window. OS/compiler suite: 1,753 checks passed. + +Resident bob32 array prefix/postfix increment and decrement now compose with expressions: postfix returns the old element after storing the updated value, and prefix returns the updated value. A separate end-to-end app checks both semantics while staying within the 511-word file cap. The kernel is 45,299 words, ending at `0xB3F3` with 1,037 words before the legacy window. OS/compiler suite: 1,754 checks passed. + +Resident bob32 local declarations now accept comma-separated scalar and fixed-array declarators with per-declarator initializers. This includes declarations that initialize a scalar from an array postfix expression. The updated 45,331-word kernel ends at `0xB413`, leaving 1,005 words before the legacy window. OS/compiler suite: 1,754 checks passed. + +Resident bob32 now parses integer function prototypes with optional parameter names. Prototypes set/check call arity, may precede a later definition, and may remain unused without definitions; unresolved calls and conflicting signatures fail. Runtime coverage checks a prototype-declared forward function call, unused unnamed-parameter declaration and conflicting prototypes. The 45,486-word kernel ends at `0xB4AE`, with 850 words before the `0xB800` legacy window. OS/compiler suite: 1,758 checks passed. + +Resident bob32 prototypes now distinguish `int f()` from `int f(void)`. An empty parameter list keeps unspecified status and can be refined by a typed declaration or definition; calls made through it must match the eventual definition's arity to preserve the current stack ABI. End-to-end coverage verifies the valid and mismatched cases. The regenerated B32 kernel is 48,185 words and ends at `0xBF38`, leaving 199 words before the compatibility-app region. CPU 194, OS/compiler 1,764, and console 28 checks pass. + +## Recent bob32 and header additions + +The bob32 resident compiler now recognizes `print`, `println`, `print_dec` and `print_hex` as one-argument kernel built-ins without source prototypes. A regression runs `write bobs.c int main(void){println("Bob!");return 0;}` followed by `go bobs.c` and verifies the exact `Bob!` output and exit 0. The kernel grew into the old bob32 compatibility-app range, so that range now begins at `0xC200`; the emulator checks its entry and write bounds, and memory-map documentation reflects the relocation. Current B32 image: 48,645 words, ending at `0xC164`. + +Added the standard `` header for the host-compiled C workflow, mapping `bool`, `true` and `false` to the existing `_Bool` implementation. B16 and B32 runtime fixtures verify true/false conversion and print `bob!`. Static analysis with GCC `-fanalyzer` reported no diagnostics for the emulator, host compiler or test harness. Full suite at that point: CPU 194, OS/compiler 1,769, console 28. + +Added `` with target-width `size_t` and `ptrdiff_t` plus `NULL`. Corrected `sizeof` expressions and type-name forms to have unsigned `size_t` type, so arithmetic such as `sizeof(int)-2` follows unsigned conversion rules. B16 and B32 runtime tests check array sizes, pointer differences, null pointers and unsigned wraparound. Full suite: CPU 194, OS/compiler 1,773, console 28. + +The host compiler now parses typed function-pointer declarators, including nested pointer parameters, and type-checks their assignments and calls. Function designators and `&function` relocate to code labels; local/global pointer objects and indirect calls use the B16/B32 call ABI. Calls through an empty `()` signature use unspecified argument checking, while calls through prototypes enforce arity and compatible parameter types. Regression apps cover global initialization, local assignment/copy, direct and parenthesized indirect calls, nested function-pointer parameters, and the unspecified form on both targets; negative cases cover signature, arity, object/function pointer mismatches, and invalid object/function pointer casts. Function-pointer return types remain unsupported. Full suite at that stage: CPU 194, OS/compiler 1,793, console 28. + +Resident bob32 syntax diagnostics now include the current token text with the existing character offset and line/column. The source regression checks token context. The packed native application workflow and current verification totals are recorded in `tests/AUDIT.md` and `BOB32_MIGRATION.md`. + +The bob32 resident compiler now emits into the native app staging region and saves generated programs against the remaining 4,096-word packed filesystem capacity; bob16 keeps its 511-word output limit. A short resident C source generates a 1,289-word app, prints `bob!`, survives a B32S snapshot and restore, then runs again from guest storage. Full suites: CPU 203, OS/compiler 1,822, console 28. + +The bob32 resident compiler now accepts one-dimensional array parameters, adjusting them to pointer-valued stack arguments. It derives addresses for local array arguments, loads and indexes parameter pointers in the callee, and preserves mutation visibility through the caller's array. Prototype/definition signatures retain array-versus-scalar parameter shape, and calls reject known mismatches. Tests cover `sum(values,length)`, indexed iteration, mutation, a nested forwarding call, repeated helper calls, conflicting/multidimensional declarations, and existing local-array behavior. Full suites: CPU 203, OS/compiler 1,825, console 28. + +Started the app-side standard library with `kernel/bob_string.h`: basic string operations, whitespace detection, overflow-checked signed decimal/hex parsing, bounded integer formatting and quote-aware in-place tokenization. Runtime tests exercise edge cases in bob32, and a compiled app using the header is imported, launched, snapshotted, restored and run again from the bob32 filesystem. Full suites: CPU 203, OS/compiler 1,840, console 28. diff --git a/C_OS.md b/C_OS.md index f14e975..ebea7e5 100644 --- a/C_OS.md +++ b/C_OS.md @@ -12,9 +12,55 @@ The supplied emulator has been rebuilt for the new kernel services; older executables lack the character-input and supervised-program traps. Alternatively run `bob.exe --boot build/kernel.b16` from the repository root. + +To build and boot the native 32-bit kernel, close the current emulator session +and run `build.exe --run32`. The build also creates `build/kernel32.b32`, which +can be started directly with `bob32.exe --boot build/kernel32.b32`. The native +kernel supports the shell, RAM files, editor, resident C compiler, supervised +bob16 applications and B32S snapshots. In B32 mode, `cc` and `go` compile the +resident C subset to native bob32 programs with 32-bit `int`; kind-1 bob16 apps +still run with 16-bit arithmetic compatibility. The host `bobcc --wide` option +also emits native bob32 application images for direct boot. +The host compiler also emits a runnable bob32 BASM listing; start it with +`bob32.exe --asm32 build/program.basm`. + +To build a native bob32 application for the running bob32 OS, preprocess the C +source and compile it with `--wide-app`: + +```text +gcc -E -P -nostdinc -undef -I kernel app.c -o build/app.i +build/bobcc build/app.i build/app.basm build/app.b32 --wide-app +``` + +Then start the B32 OS with `build.exe --run32` and enter `run32 build/app.b32`. +The application uses the supervised high-memory region and its own 32-bit +stack. `run32` validates the B32K v2 header, range, checksum and file length +before loading it. The image limit is 65,536 words. Apps load from the emulator +host's working directory and are not stored in the guest snapshot. To keep an +image in the guest filesystem, use `import32 build/app.b32 myapp`, then launch +it with `run myapp`. `save` includes imported applications in the B32S snapshot; +after `restore yes`, run them again without re-importing. `run32` remains +available for direct host-path launches. +Set `BOB16_TRACE_FAULT=1` before launching the emulator to log the address and +instruction when a supervised application faults. The updated emulator also accepts `bob.exe --os` from that directory to boot the supplied image directly. The welcome message points to `help` and `go bob.c`. +## Small application string library + +Native C applications may include `bob_string.h` along with `bob.h`. The string +header supplies word-addressed `bob_strlen`, `bob_strcpy`, `bob_strcmp`, +`bob_strcat`, and `bob_strchr`, plus `bob_isspace`, `bob_parse_int`, +`bob_format_int`, and `bob_token_next`. It is included in the app translation +unit, so the compiler emits only helpers reachable from that app; no separate +library link step is needed. The caller provides enough space for copy/append +destinations. `bob_parse_int` accepts signed decimal or `0x` hexadecimal with +surrounding whitespace and reports validity through its second argument. +`bob_format_int` returns the character count or -1 when the output buffer is +too small. `bob_token_next` edits a writable command buffer in place, groups +single- or double-quoted text, honors backslash escapes, and returns 1 for a +token, 0 at end, or -1 for an unclosed quote. + ## Commands | Command | Behavior | @@ -24,7 +70,7 @@ the supplied image directly. The welcome message points to `help` and `go bob.c` | `clear` | Clear an ANSI-capable terminal | | `mem` | Show heap usage and memory regions | | `peek 0xC000` | Read a word | -| `poke 0xC000 98` | Write a word in heap RAM only | +| `poke 0xC000 98` | Write a word in the heap (bob16 mode) | | `alloc 32` | Allocate and zero 32 words; print their address | | `list` | List RAM files, lengths and kinds | | `ls` / `dir` | Aliases for list, with the same RAM-file view | @@ -42,6 +88,8 @@ the supplied image directly. The welcome message points to `help` and `go bob.c` | `restore yes` | Validate/load that snapshot, replacing the RAM files | | `load name 0x4001 ...` | Store raw bob16 machine words as a program file | | `run name` | Load a binary program into reserved RAM, execute, return | +| `run32 path` | Load and run a native B32K v2 image from a host path or guest filename | +| `import32 path name` | Import a host B32K v2 image into bob32 RAM files | | `halt` | Stop the emulator | Command lines hold up to 127 characters. Longer lines are completely consumed @@ -71,9 +119,12 @@ Windows console. Redirected input emits no redraw or candidate lists. Other terminals use ordinary input; full interactive key handling currently targets the native Windows console. -The RAM filesystem has eight slots, names up to 23 characters and content up -to 511 words per file. A character occupies one word. `bob.c` occupies one slot -initially. Unsaved files and allocations are lost on exit. Use `save` to retain +The RAM filesystem has eight slots and names up to 23 characters. bob16 keeps +eight fixed 511-word slots. bob32 packs files into 4,096 words total; text and +resident programs remain limited to 511 words, while native apps use six +metadata words plus payload and a terminator, sharing space with other files. +A character occupies one word. `bob.c` occupies one slot initially. Unsaved +files and allocations are lost on exit. Use `save` to retain files between sessions. Allocation is a zeroing bump allocator with no freeing. `poke` is restricted to heap RAM so it cannot corrupt the shell. @@ -207,36 +258,95 @@ int main(void) { Enter `.` on its own line, followed by `cc count.c count` and `run count`. -The resident compiler supports one `int main(void)` or `int main()` function, -up to 16 integer variables, assignments and compound assignments, decimal/hex/ -character/string literals, parentheses, unary `+ - ! ~`, prefix/postfix increment +The resident compiler supports one zero-argument `int main(void)` plus up to +15 additional `int` functions with integer parameters. Calls may be forward, +nested or recursive, and may be used as expression statements; each function +gets its own parameter/local stack frame. +The compiler supports up to 16 functions, 16 parameters per function and 16 +simultaneously visible local/parameter names. B32 stack frames can reserve up +to 32 local slots across nested scopes; a further declaration is rejected +because frame loads/stores use signed six-bit offsets. It also supports +assignments and compound +assignments, decimal/hex/character/string literals, parentheses, unary `+ - ! ~`, prefix/postfix increment and decrement, arithmetic, bitwise operators, shifts, short-circuit `&&`/`||`, comparisons with C operator precedence, blocks, `if`/`else`, `while`, `for`, `break`, `continue`, and `return`. For-loop initialization can declare an int; its increment can assign, compound-assign or increment/decrement a variable. It supports `print`, `println`, `print_dec`, `print_hex` and `bob_putc` calls with one argument, comments and common string escapes. -Variables have a flat function scope; declare names once (including for-loop -variables). Compound assignments support `+= -= *= /= %= &= |= ^=`; shift -assignments and assignments inside expressions are unsupported. Strings hold up to +Variables follow block scope, including declarations in `for` initializers; +inner blocks may shadow outer names, while duplicate names in one block are +rejected. Compound assignments support `+= -= *= /= %= &= |= ^=`; shift +assignments and assignments inside expressions are unsupported in bob16. Strings hold up to 63 characters and nesting is bounded at 32 parser frames. Both source and output must fit RAM-file limits. Invalid or unsupported syntax reports an error without replacing the output file. +The bob32 resident compiler additionally supports C's right-associative `?:` +conditional expression, including evaluation of only the selected branch. This +operator is not enabled in bob16 because its kernel image is at the address +limit; bob16's compiler behavior is unchanged. B32 resident C also supports +`do/while`, including `break` and `continue` (which proceeds to the condition), +assignment expressions (including right-associative chains), and `<<=`/`>>=`. +Both resident compilers provide `print`, `println`, `print_dec`, and `print_hex` +as one-argument built-ins; bob32 source can call them without a prior prototype. This is a small C subset, not a complete C implementation. Resident includes, -macros, arrays, pointers, additional functions, structs, floating point -and a standard library are unsupported. Programs call the current kernel's +macros, pointers, globals, structs, floating point and a standard library are +unsupported. The bob32 resident compiler supports `int` function prototypes +with integer parameters (prototype parameter names are optional); incompatible +parameter counts are rejected, and a referenced function still needs a +definition. Empty `f()` declarations retain unspecified-parameter status and +may be followed by a typed declaration or definition; calls made through that +declaration must match the eventual definition's arity. bob16 resident +prototypes remain unsupported. The bob32 resident +compiler supports fixed-size, +one-dimensional local `int` arrays with indexed reads and assignment statements; +their elements use the function's 32-word stack-slot budget. Indexed prefix and +postfix increment/decrement work in expressions; indexed compound assignments +work in statements. +Brace initializer lists accept scalar expressions and a trailing comma; omitted +elements are zero-filled and excess elements are rejected. The bob32 resident +compiler accepts one-dimensional `int` array parameters as `values[]` or with a +fixed bound, passing the word-addressed pointer through the ordinary argument +stack. Helpers can index or modify the caller's elements and forward the array +to another helper. Nested/multidimensional arrays and bob16 resident array +parameters remain unsupported. +Local `int` declarations may contain comma-separated scalar and fixed-array +declarators, each with its own initializer. +The bob32 resident compiler also supports local pointers to integer-returning +functions with integer parameters. Initialize or assign one from a previously +declared matching function, copy it to a compatible local pointer, or assign +null (`0`), then call indirectly. Mismatched signatures and integer values are +rejected. Function-pointer parameters, returns, globals, pointer arithmetic +and bob16 resident function pointers remain unsupported. +Programs call the current kernel's console/arithmetic routines and belong to the kernel build that compiled them. +In bob32 mode the same syntax emits native 32-bit instructions and kind-2 RAM +program files, which can be run with `run` and retained in B32S snapshots. B32 +resident programs start at `0x20000` and use variables at `0xF0000..0xF000F`; +their output can use the remaining shared 4,096-word filesystem space. Source +text files remain limited to 511 words. In bob16 mode files remain kind 1 and +use 16-bit integers and the `0xA000` program region. The bob32 shell also runs +kind-1 legacy programs at `0xC200`, clear of the expanded kernel image. ## Native programs and recovery -`run` clears the program region and copies in the binary RAM file at `0x9000`. +`run` clears the program region and copies in the binary RAM file at `0xA000` +in bob16 mode or `0xC200` in bob32 mode. `RET` (`0xE000`) returns to the shell with r0 as the exit status. `TRAP 0` also ends the running program without ending the shell. The emulator saves/restores the shell's CPU state, supplies a separate program stack, stops execution after -five million cycles, and rejects writes outside `0x9000..0xDFFF`. Invalid +five million cycles, and rejects writes outside the legacy app/heap range +(`0xA000..0xDFFF` in bob16, `0xC200..0xDFFF` for bob32 compatibility apps). +Native bob32 apps write only their supervised application and stack region. +Invalid instructions and forbidden services return a program fault. +In bob32 mode `run` also accepts resident kind-2 programs, loading them at +`0x20000` with 32-bit arithmetic. Their compiler variables occupy +`0xF0000..0xF000F`; the host `run32 PATH` command remains available for larger +external B32K images. + Programs can write their program region and the shared heap. This is not process isolation, and input services can wait for input. The raw `load` command accepts what fits in a single command line; use the resident compiler for larger programs. @@ -254,13 +364,16 @@ what fits in a single command line; use the resident compiler for larger program | --- | --- | | `0x0000..0x00FF` | Boot ROM and reserved return sentinel | | `0x0100..0x01FF` | Shell and fallback editor input buffers | -| `0x0300..0x8FFF` | Kernel code, globals and strings | -| `0x9000..0xBFFF` | Loaded program, variables and downward program stack | -| `0xC000..0xDFFF` | 8,192-word heap | -| `0xE000..0xE3FF` | Shared editor/compiler scratch (never used concurrently) | -| `0xE400..0xE5FF` | Four-command shell history | -| `0xE600..0xEFFF` | Kernel stack, growing down from `0xF000` | -| `0xF000..0xFFFF` | Eight file-content buffers; protected from program writes | +| `0x0300..0x9FFF` | Kernel code, globals and strings in bob16; current image ends at `0x90E4` | +| `0xA000..0xBFFF` | Loaded program, variables and downward program stack in bob16 | +| `0x0300..0x9FFF` | bob32 low-memory shell data and compatibility space | +| `0xA000..0xCFFF` | Loaded bob16 compatibility program at `0xC200..0xCFFF` | +| `0xD000..0xDFFF` | bob32 heap and compatibility stack region | +| `0xE000..0xEFFF` | Editor/compiler scratch, history and shell stack | +| `0xF000..0xFFFF` | Packed bob32 RAM filesystem contents | +| `0x10000..0x1FFFF` | Native bob32 kernel code, globals and strings | +| `0x20000..0xEFFFF` | Supervised native bob32 program entry/code region | +| `0xF0000..0xFFFFF` | Native app data and compiler variables; stack starts at `0x100000` | There are no interrupts, multitasking or hardware memory protection. The write checks and cycle limits are emulator services. Keep kernel recursion within its @@ -284,9 +397,11 @@ it does not preserve the volatile RAM files from a previous session. ./build.exe --test ``` -The C build utility detects MSYS2 GCC on Windows. It builds `bob.exe` and -`build/bobcc.exe`, preprocesses guest C with GCC, and generates `kernel.basm`, -`build/kernel.b16` and `build/kernel.map`. `./build.exe --run` builds and boots. +The C build utility detects MSYS2 GCC on Windows. It builds `bob.exe`, +`bob32.exe` and `build/bobcc.exe`, preprocesses guest C with GCC, and generates +both `kernel.basm`/`build/kernel.b16` and `build/kernel32.basm`/ +`build/kernel32.b32`. `./build.exe --run` boots bob16; `./build.exe --run32` +boots bob32. On Linux/macOS compile the utility as `build-tool`, then run `./build-tool`. GCC builds host executables and preprocesses guest C only; `tools/bobcc.c` does @@ -294,6 +409,7 @@ the bob16 code generation. The host compiler supports a broader subset: signed ints/chars, word pointers and casts, fixed arrays, constant global initialization, functions and recursion, assignments/compound assignments, arithmetic/bitwise/shift operators, short-circuit logic, comparisons, +including all arithmetic/bitwise compound assignments and `<<=`/`>>=`, increment/decrement, if, while, do/while, for, break, continue, function-scoped labels/goto and returns. Blocks permit shadowing; for-loop declarations have loop scope. Duplicate declarations in the same scope are rejected. @@ -312,6 +428,12 @@ adjust to pointers to their element or row type; the outer bound may be omitted. Unused prototypes need no definition. Pointer descriptors distinguish current pointee kinds and indirection depth in prototype checks. Qualifier compatibility, complete expression checking and linking external definitions remain incomplete. +Repeated function declarations merge compatible incomplete/complete array bounds +through pointer types; differing known bounds, element types or depths reject. +Compound assignments validate pointer offsets and integer operands, including +within sizeof. Assignment/increment operands in sizeof must be modifiable scalar +lvalues; their side effects remain unevaluated. Const enforcement and full +assignment conversion checks remain incomplete. Multidimensional arrays support indexing, row pointers, scaled pointer arithmetic, increments and pointer differences. Objects are limited to 4096 words and 16 dimensions. Global/local initializer lists accept nested braces and brace @@ -329,8 +451,28 @@ embedded zero characters, including their contribution to sizeof. Conditional `?:` and comma expressions preserve branch/sequence behavior. `sizeof` handles the current word-sized scalar/pointer types, declared arrays and string literals without evaluating its operand; void operands are rejected. -Structs, typedefs, unsigned types, floating point, function pointers, -Variadics and standard headers are unsupported. `sizeof` tracks array/pointer +Typedef declarations support current scalar, pointer and array types at file and +block scope. Aliases work in parameters, casts, sizeof and further declarations; +void aliases can specify a no-argument function. Compatible identical typedef +redeclarations are accepted; namespace conflicts reject. Inner objects or aliases +can shadow an outer alias, which is restored when the inner scope ends. +Structs, short integer types and floating point remain unsupported. The host +compiler accepts typed function pointers in local and file-scope objects, +function-pointer parameters, address-of function designators and indirect calls +on both targets. Function-pointer/object-pointer conversions and mismatched +signatures are rejected. Returning function pointers and variadic function +pointers are unsupported. The host compiler's bob32 `--wide` target accepts `long` and +`long long` as 32-bit aliases of `int`, consistent with the word-addressed ABI; +`sizeof` reports addressable words (one byte per word). Enums support tagged/anonymous definitions, explicit constant +values, automatic increments, typedef aliases and block/loop tag shadowing. +Enumerators are scoped integer constants usable in bounds, case labels and +initializers. Enum objects use signed 16-bit int storage; distinct enum types +remain distinct in declaration checks and are compatible with this chosen int +representation. Automatic values exceeding 32767 reject. Enum tags must already +be defined when referenced; incomplete enum extensions are unsupported. +Variadics and most standard headers are unsupported; the host C workflow provides +`` and `` with `_Bool`, `size_t`, `ptrdiff_t` and `NULL`. +`sizeof` has the unsigned `size_t` type and tracks array/pointer expression types, including *&array and array decay in comma/conditional expressions. Recursive object declarators support grouped names, pointers to arrays such as `int (*rows)[3]`, and arrays of those pointers. Abstract declarators @@ -340,6 +482,41 @@ pointee has no size for sizeof or arithmetic. Declarators have limits of 32 parenthesis levels and 64 derived types. Function pointer declarators, functions returning pointers to arrays, and complete C type checking remain unsupported. Host tools themselves use ordinary host C types. +The host compiler supports `_Bool` as a one-word type. Initializers, assignment, +casts, returns and arguments to boolean parameters convert zero to 0 and nonzero +to 1. Boolean arrays, typedef aliases and static objects use the same conversion; +increment/decrement and compound assignments preserve normalized storage. The +host workflow includes `` with `bool`, `true` and `false` definitions. +Unsigned 16-bit int is available as `unsigned` or `unsigned int`, with `u`/`U` +literal suffixes. Mixed int/unsigned arithmetic uses unsigned comparisons, +division and remainder; right shifts of unsigned values fill with zeros. +Arithmetic storage wraps modulo 65536. Unsigned helpers are included only when +explicit unsigned types/literals are used. Unsuffixed literal selection retains +the earlier compiler behavior; full C literal selection, unsigned char/short/long +and all declaration-specifier orderings remain incomplete. +Sizeof is accepted in constant initialization; local static initializers may +query automatic-object types without evaluating their values. Type/literal sizeof +works in bounds and case labels. Named-object sizeof in those contexts uses +parser type bindings with block/for scope and parameter array adjustment. +Objects must already be declared and complete; later or escaped bindings reject. +File-scope object declarations support `extern`, compatible repeated tentative +definitions and a single initialized definition. Incomplete array declarations +merge with known bounds; an uncompleted tentative array reserves one element. +Unused extern objects need no definition, while referenced ones must be defined +in this source unit. Block-scope extern object declarations refer to that same +storage without allocating stack slots. They can shadow an outer local, and +names introduced only in a block do not escape it. Block extern initializers +and conflicts with a local in the same scope reject. Block function declarations, +separate-unit linking remain unsupported. File-scope static objects/functions +use internal linkage within the current source unit. Later extern declarations +inherit prior internal linkage; conflicting external/internal declarations +reject. Function declarations without a storage class retain an earlier static +declaration's linkage. Internal tentative arrays need a complete bound. +Block-scope static objects have private persistent storage initialized once, +including arrays and pointers to other static objects. Initializers must use +supported constant expressions or static addresses; automatic-object addresses +and runtime calls are rejected. Equal names in different blocks/functions remain +independent, and a static object's name is scoped to its declaring block. To compile another standalone guest source from the repository root: diff --git a/README.md b/README.md index 365ff68..1a33a39 100644 --- a/README.md +++ b/README.md @@ -100,3 +100,12 @@ condition codes are set after instructions with *, so if the result of an instru negative -> n bit is set\ zero -> z bit is set\ positive -> p bit is set +# bob32 migration status + +`bob32.exe` supports 32-bit words and addresses, including high-origin B32K v2 +images. `build.exe --run32` builds and boots the B32 kernel, with its shell, +editor, filesystem, B32S snapshots, and compatibility for supervised bob16 +applications. Native B32K apps can be imported into guest RAM files with +`import32`, launched by guest filename, and preserved in B32S snapshots. The +resident C compiler and full C conformance remain in progress. See [BOB32_MIGRATION.md](BOB32_MIGRATION.md) for image +details, verified behavior and remaining migration requirements. diff --git a/bob-files.b32 b/bob-files.b32 new file mode 100644 index 0000000000000000000000000000000000000000..376dd66ad62df99a25721e4d18de4296b5983cc0 GIT binary patch literal 17264 zcmeIxF-`(e6o%1}m5f$cU6(4gLSq{*Qrh0etpaOo`#vaYnAHWn!iea-{Z^vtnQhoHr4!7s@c!}bIrGDnug!) zviA@mK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs a0RjXF5FkK+009C72oNAZfB=D06Zi$0q8Dob literal 0 HcmV?d00001 diff --git a/bob.exe b/bob.exe index 626bb35ffa1e24886ff92be4db86c84c68d7b85d..e773967bb5dc1c208446ddc6764ffd484dca51a6 100644 GIT binary patch literal 79583 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 X341iUoXeu-5237XKn79v;PC$dBo8&n literal 0 HcmV?d00001 diff --git a/build.exe b/build.exe index fc7e24641710ee98fb69b4466868b5a8f0c27658..85e0c5eb719fdfa9aaa0c484d0d6fa6aa2bae893 100644 GIT binary patch delta 10104 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 Yq_LcOeiYOH_uiQz9XhF_C1+axA3FyddH?_b delta 10881 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 diff --git a/kernel.basm b/kernel.basm index d251dcc..3ad3a4b 100644 --- a/kernel.basm +++ b/kernel.basm @@ -1,4 +1,4 @@ -; bob16 C kernel, generated by tools/bobcc.c +; bob16 C program, generated by tools/bobcc.c .fill 4601 .fill b600 .fill 0300 @@ -773,7 +773,7 @@ .fill 2b80 .fill 4601 .fill ae01 -.fill 728a +.fill 78d6 .fill c300 .fill f000 .fill 1dff @@ -889,7 +889,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -986,7 +986,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 @@ -1068,7 +1068,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 @@ -1176,13 +1176,12 @@ .fill 1dff .fill 9b80 .fill 1ae0 -.fill 1d80 .fill 10d0 .fill 1182 .fill 6000 .fill 1dff .fill 9180 -.fill cfb8 +.fill cfb9 .fill 1d81 .fill 2180 .fill 118a @@ -1219,7 +1218,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 74df +.fill 7b36 .fill c300 .fill 1d82 .fill 6380 @@ -1249,7 +1248,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7424 +.fill 7a67 .fill c300 .fill 1d82 .fill 6380 @@ -1298,7 +1297,6 @@ .fill 1dff .fill 9b80 .fill 1ae0 -.fill 1d80 .fill 10d0 .fill 1182 .fill 6000 @@ -1313,7 +1311,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 @@ -1339,7 +1337,7 @@ .fill 6000 .fill 1dff .fill 9180 -.fill cf6e +.fill cf6f .fill 1d81 .fill 2180 .fill 1cd0 @@ -1356,10 +1354,10 @@ .fill 1dfd .fill 4001 .fill ae01 -.fill 7852 +.fill 7e99 .fill 1dff .fill 9180 -.fill cf07 +.fill cf09 .fill 1d81 .fill 10d0 .fill 11ff @@ -1384,7 +1382,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 @@ -1420,7 +1418,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 @@ -1432,7 +1430,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7751 +.fill 7d97 .fill 1dff .fill 9180 .fill 10d0 @@ -1450,7 +1448,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7424 +.fill 7a67 .fill c300 .fill 1d82 .fill 1dff @@ -1481,7 +1479,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7761 +.fill 7da7 .fill 1dff .fill 9180 .fill 10d0 @@ -1525,7 +1523,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 @@ -1603,18 +1601,16 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 -.fill a409 +.fill a407 .fill 2180 -.fill 1181 -.fill 3100 -.fill 1181 +.fill 11ff .fill 4601 .fill ae01 -.fill 07a1 +.fill 0795 .fill b600 .fill ae00 .fill 10d0 @@ -1636,7 +1632,7 @@ .fill 2180 .fill 1181 .fill 1080 -.fill a4e0 +.fill a4de .fill 10d0 .fill 11fe .fill 1dff @@ -1651,9 +1647,7 @@ .fill 1dff .fill 9180 .fill 2180 -.fill 1181 -.fill 3100 -.fill 1181 +.fill 11ff .fill 6380 .fill 1d81 .fill 1dff @@ -1662,7 +1656,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -1682,7 +1676,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -1716,7 +1710,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -1737,7 +1731,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -1787,7 +1781,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7404 +.fill 7a48 .fill c300 .fill 1d82 .fill 1080 @@ -1817,7 +1811,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 @@ -1860,7 +1854,7 @@ .fill 1d81 .fill 9040 .fill ae00 -.fill af1c +.fill af1e .fill 10d0 .fill 1182 .fill 6000 @@ -1882,12 +1876,10 @@ .fill 11fd .fill 6000 .fill 1080 -.fill a406 +.fill a404 .fill 2180 -.fill 1181 -.fill 3100 -.fill 1181 -.fill ae40 +.fill 11ff +.fill ae3c .fill ae00 .fill 10d0 .fill 11fe @@ -1895,9 +1887,7 @@ .fill 1dff .fill 9180 .fill 2180 -.fill 1181 -.fill 3100 -.fill 1181 +.fill 11ff .fill 6380 .fill 1d81 .fill 1dff @@ -1906,7 +1896,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -1925,7 +1915,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -1940,11 +1930,9 @@ .fill ae01 .fill 2180 .fill 1080 -.fill a406 +.fill a404 .fill 2180 -.fill 1182 -.fill 3100 -.fill 1181 +.fill 11fe .fill ae06 .fill ae00 .fill 10d0 @@ -1979,7 +1967,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 @@ -1996,7 +1984,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7750 +.fill 7d96 .fill 6000 .fill 6380 .fill 1d81 @@ -2011,7 +1999,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7363 +.fill 79ab .fill c300 .fill 1d82 .fill 2380 @@ -2042,7 +2030,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7750 +.fill 7d96 .fill 6000 .fill 6380 .fill 1d81 @@ -2052,12 +2040,12 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 7750 +.fill 7d96 .fill 1dff .fill 9180 .fill 4001 .fill ae01 -.fill 7750 +.fill 7d96 .fill 6000 .fill 1dff .fill 9180 @@ -2117,7 +2105,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7765 +.fill 7dab .fill 6380 .fill 1d81 .fill 9040 @@ -2134,7 +2122,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7825 +.fill 7e6b .fill 6380 .fill 1d81 .fill 9040 @@ -2151,7 +2139,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 782d +.fill 7e73 .fill 6380 .fill 1d81 .fill 9040 @@ -2168,7 +2156,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7835 +.fill 7e7b .fill 6380 .fill 1d81 .fill 9040 @@ -2195,9 +2183,7 @@ .fill 1dff .fill 9180 .fill 2180 -.fill 1181 -.fill 3100 -.fill 1181 +.fill 11ff .fill 6380 .fill 1d81 .fill 1dff @@ -2206,14 +2192,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a40b .fill 4001 .fill ae01 -.fill 7855 +.fill 7e9c .fill 1dff .fill 9180 .fill 4601 @@ -2236,14 +2222,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 .fill a40b .fill 4001 .fill ae01 -.fill 78a7 +.fill 7eee .fill 1dff .fill 9180 .fill 4601 @@ -2266,14 +2252,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a40b .fill 4001 .fill ae01 -.fill 78d1 +.fill 7f18 .fill 1dff .fill 9180 .fill 4601 @@ -2284,7 +2270,7 @@ .fill ae29 .fill 4001 .fill ae01 -.fill 7902 +.fill 7f49 .fill 1dff .fill 9180 .fill 4601 @@ -2307,14 +2293,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a40b .fill 4001 .fill ae01 -.fill 792f +.fill 7f76 .fill 1dff .fill 9180 .fill 4601 @@ -2335,10 +2321,9 @@ .fill 1dff .fill 9b80 .fill 1ae0 -.fill 1d80 .fill 4001 .fill ae01 -.fill 7765 +.fill 7dab .fill 1dff .fill 9180 .fill 10d0 @@ -2356,7 +2341,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7424 +.fill 7a67 .fill c300 .fill 1d82 .fill 6380 @@ -2375,7 +2360,6 @@ .fill 1dff .fill 9b80 .fill 1ae0 -.fill 1d80 .fill 4001 .fill ae01 .fill f000 @@ -2397,7 +2381,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7424 +.fill 7a67 .fill c300 .fill 1d82 .fill 6380 @@ -2440,14 +2424,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 .fill a44d .fill 4001 .fill ae01 -.fill 7835 +.fill 7e7b .fill 1dff .fill 9180 .fill 10d0 @@ -2469,7 +2453,7 @@ .fill 6000 .fill 1dff .fill 9180 -.fill cf74 +.fill cf76 .fill 1d81 .fill 1dff .fill 9180 @@ -2489,7 +2473,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -2508,7 +2492,7 @@ .fill 10d0 .fill 11ff .fill 6000 -.fill ae13 +.fill ae11 .fill ae00 .fill 10d0 .fill 11ff @@ -2523,9 +2507,7 @@ .fill 10c0 .fill af9f .fill 2180 -.fill 1181 -.fill 3100 -.fill 1181 +.fill 11ff .fill ae01 .fill 2180 .fill 1cd0 @@ -2571,7 +2553,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -2591,7 +2573,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73b9 +.fill 79ff .fill c300 .fill 1d82 .fill 2380 @@ -2607,14 +2589,12 @@ .fill 2180 .fill 1181 .fill 1080 -.fill a409 +.fill a407 .fill 2180 -.fill 1181 -.fill 3100 -.fill 1181 +.fill 11ff .fill 4601 .fill ae01 -.fill 0b5f +.fill 0b47 .fill b600 .fill ae00 .fill 10d0 @@ -2641,11 +2621,11 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 -.fill a459 +.fill a457 .fill 10d0 .fill 1182 .fill 6000 @@ -2670,7 +2650,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 @@ -2700,7 +2680,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7363 +.fill 79ab .fill c300 .fill 1d82 .fill 2380 @@ -2716,12 +2696,10 @@ .fill 2180 .fill 1181 .fill 1080 -.fill a406 +.fill a404 .fill 2180 -.fill 1181 -.fill 3100 -.fill 1181 -.fill aebc +.fill 11ff +.fill aeba .fill ae00 .fill 10d0 .fill 11fd @@ -2734,7 +2712,7 @@ .fill 1d81 .fill 9040 .fill 10c0 -.fill af92 +.fill af94 .fill 10d0 .fill 11ff .fill 1dff @@ -2744,7 +2722,7 @@ .fill 6000 .fill 1dff .fill 9180 -.fill ceb2 +.fill ceb8 .fill 1d81 .fill 6380 .fill 1d81 @@ -2763,7 +2741,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73b9 +.fill 79ff .fill c300 .fill 1d82 .fill 1080 @@ -2771,7 +2749,7 @@ .fill 10d0 .fill 11ff .fill 6000 -.fill ae8a +.fill ae88 .fill ae00 .fill 10d0 .fill 11ff @@ -2796,14 +2774,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 .fill a467 .fill 4001 .fill ae01 -.fill 7835 +.fill 7e7b .fill 1dff .fill 9180 .fill 10d0 @@ -2836,7 +2814,7 @@ .fill 6000 .fill 1dff .fill 9180 -.fill ce05 +.fill ce0d .fill 1d81 .fill 1dff .fill 9180 @@ -2860,7 +2838,7 @@ .fill 6000 .fill 1dff .fill 9180 -.fill cded +.fill cdf5 .fill 1d81 .fill 1dff .fill 9180 @@ -2871,7 +2849,7 @@ .fill 1d83 .fill 4001 .fill ae01 -.fill 7835 +.fill 7e7b .fill 1dff .fill 9180 .fill 10d0 @@ -2890,7 +2868,7 @@ .fill 10d0 .fill 11ff .fill 6000 -.fill ae13 +.fill ae11 .fill ae00 .fill 10d0 .fill 11ff @@ -2905,9 +2883,590 @@ .fill 10c0 .fill af85 .fill 2180 -.fill 1181 +.fill 11ff +.fill ae01 +.fill 2180 +.fill 1cd0 +.fill 6b80 +.fill 1d81 +.fill 6f80 +.fill 1d81 +.fill e000 +.fill 1dff +.fill 9f80 +.fill 1dff +.fill 9b80 +.fill 1ae0 +.fill 1dfd +.fill 10d0 +.fill 11fd +.fill 1dff +.fill 9180 +.fill 10d0 +.fill 1182 +.fill 6000 +.fill 1dff +.fill 9180 +.fill 4601 +.fill ae01 +.fill 0309 +.fill c300 +.fill 1d81 +.fill 6380 +.fill 1d81 +.fill 9040 +.fill 10d0 +.fill 11fd +.fill 6000 +.fill 2380 .fill 3100 .fill 1181 +.fill 1010 +.fill a402 +.fill 2180 +.fill ae02 +.fill 2180 +.fill 1181 +.fill 1080 +.fill aa1c +.fill 10d0 +.fill 11fd +.fill 6000 +.fill 1dff +.fill 9180 +.fill 2180 +.fill 1198 +.fill 6380 +.fill 1d81 +.fill 1dff +.fill 9180 +.fill 1dff +.fill 9380 +.fill 4601 +.fill ae01 +.fill 79ff +.fill c300 +.fill 1d82 +.fill 2380 +.fill 3100 +.fill 1181 +.fill 1010 +.fill aa02 +.fill 2180 +.fill ae02 +.fill 2180 +.fill 1181 +.fill ae02 +.fill 2180 +.fill 1181 +.fill 1080 +.fill aa1f +.fill 10d0 +.fill 1182 +.fill 6000 +.fill 1dff +.fill 9180 +.fill cdc4 +.fill 1d81 +.fill 1dff +.fill 9180 +.fill 2180 +.fill 6380 +.fill 1d81 +.fill 1dff +.fill 9180 +.fill 1dff +.fill 9380 +.fill 4601 +.fill ae01 +.fill 79ff +.fill c300 +.fill 1d82 +.fill 2380 +.fill 3100 +.fill 1181 +.fill 1010 +.fill aa02 +.fill 2180 +.fill ae02 +.fill 2180 +.fill 1181 +.fill ae02 +.fill 2180 +.fill 1181 +.fill 1080 +.fill a407 +.fill 2180 +.fill 11ff +.fill 4601 +.fill ae01 +.fill 0d8e +.fill b600 +.fill ae00 +.fill 10d0 +.fill 11ff +.fill 1dff +.fill 9180 +.fill 2180 +.fill 6380 +.fill 1d81 +.fill 9040 +.fill 10d0 +.fill 11ff +.fill 6000 +.fill 1dff +.fill 9180 +.fill 10d0 +.fill 11fd +.fill 6000 +.fill 6380 +.fill 1d81 +.fill 1dff +.fill 9180 +.fill 1dff +.fill 9380 +.fill 4601 +.fill ae01 +.fill 7981 +.fill c300 +.fill 1d82 +.fill 1080 +.fill a45a +.fill 10d0 +.fill 1182 +.fill 6000 +.fill 1dff +.fill 9180 +.fill 10d0 +.fill 11ff +.fill 6000 +.fill 6380 +.fill 1d81 +.fill 1010 +.fill 6000 +.fill 1dff +.fill 9180 +.fill 2180 +.fill 11a1 +.fill 6380 +.fill 1d81 +.fill 1dff +.fill 9180 +.fill 1dff +.fill 9380 +.fill 4601 +.fill ae01 +.fill 7981 +.fill c300 +.fill 1d82 +.fill 1080 +.fill aa26 +.fill 10d0 +.fill 1182 +.fill 6000 +.fill 1dff +.fill 9180 +.fill 10d0 +.fill 11ff +.fill 6000 +.fill 6380 +.fill 1d81 +.fill 1010 +.fill 6000 +.fill 1dff +.fill 9180 +.fill 4001 +.fill ae01 +.fill 007e +.fill 6380 +.fill 1d81 +.fill 1dff +.fill 9180 +.fill 1dff +.fill 9380 +.fill 4601 +.fill ae01 +.fill 79ab +.fill c300 +.fill 1d82 +.fill 2380 +.fill 3100 +.fill 1181 +.fill 1010 +.fill aa02 +.fill 2180 +.fill ae02 +.fill 2180 +.fill 1181 +.fill ae02 +.fill 2180 +.fill 1181 +.fill 1080 +.fill a407 +.fill 2180 +.fill 11ff +.fill 4601 +.fill ae01 +.fill 0d8e +.fill b600 +.fill ae00 +.fill 10d0 +.fill 11ff +.fill 1dff +.fill 9180 +.fill 6000 +.fill 1880 +.fill 1181 +.fill 6380 +.fill 1d81 +.fill 9040 +.fill 10c0 +.fill af91 +.fill 10d0 +.fill 11fe +.fill 1dff +.fill 9180 +.fill 2180 +.fill 6380 +.fill 1d81 +.fill 9040 +.fill 10d0 +.fill 11ff +.fill 1dff +.fill 9180 +.fill 2180 +.fill 6380 +.fill 1d81 +.fill 9040 +.fill 10d0 +.fill 11ff +.fill 6000 +.fill 1dff +.fill 9180 +.fill 2180 +.fill 1188 +.fill 6380 +.fill 1d81 +.fill 1dff +.fill 9180 +.fill 1dff +.fill 9380 +.fill 4601 +.fill ae01 +.fill 7981 +.fill c300 +.fill 1d82 +.fill 1080 +.fill a4b2 +.fill 4001 +.fill ae01 +.fill 7e7b +.fill 1dff +.fill 9180 +.fill 10d0 +.fill 11ff +.fill 6000 +.fill 6380 +.fill 1d81 +.fill 1010 +.fill 6000 +.fill 1080 +.fill a498 +.fill 10d0 +.fill 11ff +.fill 6000 +.fill 1dff +.fill 9180 +.fill 10d0 +.fill 11fe +.fill 6000 +.fill 6380 +.fill 1d81 +.fill 1dff +.fill 9180 +.fill 1dff +.fill 9380 +.fill 4601 +.fill ae01 +.fill 7a48 +.fill c300 +.fill 1d82 +.fill 1080 +.fill a477 +.fill 2180 +.fill 1198 +.fill 1dff +.fill 9180 +.fill 10d0 +.fill 11ff +.fill 6000 +.fill 1dff +.fill 9180 +.fill cc89 +.fill 1d81 +.fill 1dff +.fill 9180 +.fill 10d0 +.fill 11fe +.fill 6000 +.fill 1dff +.fill 9180 +.fill cc80 +.fill 1d81 +.fill 1dff +.fill 9180 +.fill 4601 +.fill ae01 +.fill 03bd +.fill c300 +.fill 1d83 +.fill 4001 +.fill ae01 +.fill 7e6b +.fill 1dff +.fill 9180 +.fill 10d0 +.fill 11fe +.fill 6000 +.fill 6380 +.fill 1d81 +.fill 1010 +.fill 1dff +.fill 9180 +.fill 4001 +.fill ae01 +.fill 7e6b +.fill 1dff +.fill 9180 +.fill 10d0 +.fill 11ff +.fill 6000 +.fill 6380 +.fill 1d81 +.fill 1010 +.fill 6000 +.fill 6380 +.fill 1d81 +.fill 9040 +.fill 4001 +.fill ae01 +.fill 7e73 +.fill 1dff +.fill 9180 +.fill 10d0 +.fill 11fe +.fill 6000 +.fill 6380 +.fill 1d81 +.fill 1010 +.fill 1dff +.fill 9180 +.fill 4001 +.fill ae01 +.fill 7e73 +.fill 1dff +.fill 9180 +.fill 10d0 +.fill 11ff +.fill 6000 +.fill 6380 +.fill 1d81 +.fill 1010 +.fill 6000 +.fill 6380 +.fill 1d81 +.fill 9040 +.fill 4001 +.fill ae01 +.fill 7e7b +.fill 1dff +.fill 9180 +.fill 10d0 +.fill 11fe +.fill 6000 +.fill 6380 +.fill 1d81 +.fill 1010 +.fill 1dff +.fill 9180 +.fill 2180 +.fill 1181 +.fill 6380 +.fill 1d81 +.fill 9040 +.fill 4001 +.fill ae01 +.fill 7e7b +.fill 1dff +.fill 9180 +.fill 10d0 +.fill 11ff +.fill 6000 +.fill 6380 +.fill 1d81 +.fill 1010 +.fill 1dff +.fill 9180 +.fill 2180 +.fill 6380 +.fill 1d81 +.fill 9040 +.fill ae00 +.fill 10d0 +.fill 11fe +.fill 1dff +.fill 9180 +.fill 6000 +.fill 1880 +.fill 1181 +.fill 6380 +.fill 1d81 +.fill 9040 +.fill 10c0 +.fill ae00 +.fill 10d0 +.fill 11ff +.fill 1dff +.fill 9180 +.fill 6000 +.fill 1880 +.fill 1181 +.fill 6380 +.fill 1d81 +.fill 9040 +.fill 10c0 +.fill af3a +.fill 10d0 +.fill 11fe +.fill 6000 +.fill 1dff +.fill 9180 +.fill 2180 +.fill 1188 +.fill 6380 +.fill 1d81 +.fill 1dff +.fill 9180 +.fill 1dff +.fill 9380 +.fill 4601 +.fill ae01 +.fill 7a29 +.fill c300 +.fill 1d82 +.fill 1080 +.fill a404 +.fill 2180 +.fill 11ff +.fill ae6e +.fill ae00 +.fill 2180 +.fill 1198 +.fill 1dff +.fill 9180 +.fill 2180 +.fill 1dff +.fill 9180 +.fill 10d0 +.fill 11fe +.fill 6000 +.fill 1dff +.fill 9180 +.fill 4601 +.fill ae01 +.fill 090d +.fill c300 +.fill 1d81 +.fill 1dff +.fill 9180 +.fill 4601 +.fill ae01 +.fill 040f +.fill c300 +.fill 1d83 +.fill 10d0 +.fill 11fd +.fill 6000 +.fill 1dff +.fill 9180 +.fill 10d0 +.fill 1182 +.fill 6000 +.fill 1dff +.fill 9180 +.fill 10d0 +.fill 11fe +.fill 6000 +.fill 1dff +.fill 9180 +.fill 4601 +.fill ae01 +.fill 090d +.fill c300 +.fill 1d81 +.fill 1dff +.fill 9180 +.fill 4601 +.fill ae01 +.fill 03bd +.fill c300 +.fill 1d83 +.fill 4001 +.fill ae01 +.fill 7e6b +.fill 1dff +.fill 9180 +.fill 10d0 +.fill 11fe +.fill 6000 +.fill 6380 +.fill 1d81 +.fill 1010 +.fill 1dff +.fill 9180 +.fill 2180 +.fill 6380 +.fill 1d81 +.fill 9040 +.fill 4001 +.fill ae01 +.fill 7e73 +.fill 1dff +.fill 9180 +.fill 10d0 +.fill 11fe +.fill 6000 +.fill 6380 +.fill 1d81 +.fill 1010 +.fill 1dff +.fill 9180 +.fill 2180 +.fill 1183 +.fill 6380 +.fill 1d81 +.fill 9040 +.fill 4001 +.fill ae01 +.fill 7e7b +.fill 1dff +.fill 9180 +.fill 10d0 +.fill 11fe +.fill 6000 +.fill 6380 +.fill 1d81 +.fill 1010 +.fill 1dff +.fill 9180 +.fill 2180 +.fill 1181 +.fill 6380 +.fill 1d81 +.fill 9040 +.fill 10d0 +.fill 11fe +.fill 6000 .fill ae01 .fill 2180 .fill 1cd0 @@ -2936,7 +3495,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 @@ -2957,7 +3516,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73b9 +.fill 79ff .fill c300 .fill 1d82 .fill 2380 @@ -2973,12 +3532,10 @@ .fill 2180 .fill 1181 .fill 1080 -.fill a406 +.fill a404 .fill 2180 -.fill 1181 -.fill 3100 -.fill 1181 -.fill ae80 +.fill 11ff +.fill ae87 .fill ae00 .fill 10d0 .fill 11ff @@ -2989,7 +3546,10 @@ .fill 6000 .fill 1dff .fill 9180 -.fill ce38 +.fill 4601 +.fill ae01 +.fill 09d5 +.fill c300 .fill 1d81 .fill 6380 .fill 1d81 @@ -3008,16 +3568,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 -.fill a406 +.fill a404 .fill 2180 -.fill 1181 -.fill 3100 -.fill 1181 -.fill ae59 +.fill 11ff +.fill ae5f .fill ae00 .fill 10d0 .fill 1184 @@ -3034,7 +3592,10 @@ .fill 6000 .fill 1dff .fill 9180 -.fill cd67 +.fill 4601 +.fill ae01 +.fill 0934 +.fill c300 .fill 1d81 .fill 1dff .fill 9180 @@ -3048,7 +3609,10 @@ .fill 6000 .fill 1dff .fill 9180 -.fill cd59 +.fill 4601 +.fill ae01 +.fill 0934 +.fill c300 .fill 1d81 .fill 1dff .fill 9180 @@ -3066,7 +3630,7 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 7825 +.fill 7e6b .fill 1dff .fill 9180 .fill 10d0 @@ -3085,7 +3649,7 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 782d +.fill 7e73 .fill 1dff .fill 9180 .fill 10d0 @@ -3150,14 +3714,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 -.fill a474 +.fill a49f .fill 4001 .fill ae01 -.fill 7835 +.fill 7e7b .fill 1dff .fill 9180 .fill 10d0 @@ -3168,13 +3732,16 @@ .fill 1010 .fill 6000 .fill 1080 -.fill a45a +.fill a485 .fill 10d0 .fill 11ff .fill 6000 .fill 1dff .fill 9180 -.fill ccb3 +.fill 4601 +.fill ae01 +.fill 090d +.fill c300 .fill 1d81 .fill 1dff .fill 9180 @@ -3185,7 +3752,7 @@ .fill 1d81 .fill 4001 .fill ae01 -.fill 7977 +.fill 7fbe .fill 1dff .fill 9180 .fill 4601 @@ -3195,7 +3762,7 @@ .fill 1d81 .fill 4001 .fill ae01 -.fill 7825 +.fill 7e6b .fill 1dff .fill 9180 .fill 10d0 @@ -3209,12 +3776,52 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 050e +.fill 050d .fill c300 .fill 1d81 .fill 4001 .fill ae01 -.fill 782d +.fill 7e73 +.fill 1dff +.fill 9180 +.fill 10d0 +.fill 11ff +.fill 6000 +.fill 6380 +.fill 1d81 +.fill 1010 +.fill 6000 +.fill 1dff +.fill 9180 +.fill 2180 +.fill 1183 +.fill 6380 +.fill 1d81 +.fill 1dff +.fill 9180 +.fill 1dff +.fill 9380 +.fill 4601 +.fill ae01 +.fill 7a29 +.fill c300 +.fill 1d82 +.fill 1080 +.fill a40b +.fill 4001 +.fill ae01 +.fill 7fc1 +.fill 1dff +.fill 9180 +.fill 4601 +.fill ae01 +.fill 0494 +.fill c300 +.fill 1d81 +.fill ae23 +.fill 4001 +.fill ae01 +.fill 7e73 .fill 1dff .fill 9180 .fill 10d0 @@ -3228,7 +3835,7 @@ .fill a40b .fill 4001 .fill ae01 -.fill 797a +.fill 7fdd .fill 1dff .fill 9180 .fill 4601 @@ -3239,7 +3846,7 @@ .fill ae0a .fill 4001 .fill ae01 -.fill 798b +.fill 7fee .fill 1dff .fill 9180 .fill 4601 @@ -3270,7 +3877,7 @@ .fill 1d81 .fill 9040 .fill 10c0 -.fill af78 +.fill af4d .fill 10d0 .fill 11fe .fill 6000 @@ -3287,7 +3894,7 @@ .fill a40b .fill 4001 .fill ae01 -.fill 7999 +.fill 7ffc .fill 1dff .fill 9180 .fill 4601 @@ -3298,7 +3905,7 @@ .fill ae00 .fill 4001 .fill ae01 -.fill 79a3 +.fill 8006 .fill 1dff .fill 9180 .fill 4601 @@ -3313,12 +3920,12 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 050e +.fill 050d .fill c300 .fill 1d81 .fill 4001 .fill ae01 -.fill 79a9 +.fill 800c .fill 1dff .fill 9180 .fill 4601 @@ -3356,7 +3963,7 @@ .fill a410 .fill 4001 .fill ae01 -.fill 79e2 +.fill 8045 .fill 1dff .fill 9180 .fill 4601 @@ -3367,7 +3974,7 @@ .fill 2180 .fill 4601 .fill ae01 -.fill 0f1e +.fill 1167 .fill b600 .fill ae00 .fill 10d0 @@ -3379,7 +3986,10 @@ .fill 6000 .fill 1dff .fill 9180 -.fill cc37 +.fill 4601 +.fill ae01 +.fill 095c +.fill c300 .fill 1d81 .fill 6380 .fill 1d81 @@ -3398,14 +4008,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 .fill a410 .fill 4001 .fill ae01 -.fill 7a15 +.fill 8078 .fill 1dff .fill 9180 .fill 4601 @@ -3416,12 +4026,12 @@ .fill 2180 .fill 4601 .fill ae01 -.fill 0f1e +.fill 1167 .fill b600 .fill ae00 .fill 4001 .fill ae01 -.fill 7a3a +.fill 809d .fill 1dff .fill 9180 .fill 10d0 @@ -3445,14 +4055,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 -.fill a474 +.fill a45b .fill 4001 .fill ae01 -.fill 7835 +.fill 7e7b .fill 1dff .fill 9180 .fill 10d0 @@ -3469,7 +4079,7 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 7825 +.fill 7e6b .fill 1dff .fill 9180 .fill 10d0 @@ -3486,7 +4096,7 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 782d +.fill 7e73 .fill 1dff .fill 9180 .fill 10d0 @@ -3515,7 +4125,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 091b +.fill 090d .fill c300 .fill 1d81 .fill 1dff @@ -3527,32 +4137,7 @@ .fill 1d83 .fill 4001 .fill ae01 -.fill 0200 -.fill 1dff -.fill 9180 -.fill 2180 -.fill 1dff -.fill 9180 -.fill 10d0 -.fill 11ff -.fill 6000 -.fill 1dff -.fill 9180 -.fill 4601 -.fill ae01 -.fill 0943 -.fill c300 -.fill 1d81 -.fill 1dff -.fill 9180 -.fill 4601 -.fill ae01 -.fill 040f -.fill c300 -.fill 1d83 -.fill 4001 -.fill ae01 -.fill 7a41 +.fill 80a4 .fill 1dff .fill 9180 .fill 4601 @@ -3563,7 +4148,7 @@ .fill 2180 .fill 4601 .fill ae01 -.fill 0f1e +.fill 1167 .fill b600 .fill ae00 .fill 10d0 @@ -3603,7 +4188,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73b9 +.fill 79ff .fill c300 .fill 1d82 .fill 2380 @@ -3622,7 +4207,7 @@ .fill a40d .fill 4001 .fill ae01 -.fill 7a4a +.fill 80ad .fill 1dff .fill 9180 .fill 4601 @@ -3640,7 +4225,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 096c +.fill 095c .fill c300 .fill 1d81 .fill 1dff @@ -3654,14 +4239,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73b9 +.fill 79ff .fill c300 .fill 1d82 .fill 1080 .fill a40d .fill 4001 .fill ae01 -.fill 7a6e +.fill 80d1 .fill 1dff .fill 9180 .fill 4601 @@ -3674,7 +4259,7 @@ .fill ae00 .fill 4001 .fill ae01 -.fill 7aaa +.fill 810d .fill 1dff .fill 9180 .fill 10d0 @@ -3698,7 +4283,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -3717,7 +4302,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 091b +.fill 090d .fill c300 .fill 1d81 .fill 1dff @@ -3751,7 +4336,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 091b +.fill 090d .fill c300 .fill 1d81 .fill 1dff @@ -3763,7 +4348,7 @@ .fill 1d83 .fill 4001 .fill ae01 -.fill 7ab1 +.fill 8114 .fill 1dff .fill 9180 .fill 4601 @@ -3780,7 +4365,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 782d +.fill 7e73 .fill 1dff .fill 9180 .fill 10d0 @@ -3794,7 +4379,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7825 +.fill 7e6b .fill 1dff .fill 9180 .fill 10d0 @@ -3813,7 +4398,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 0943 +.fill 0934 .fill c300 .fill 1d81 .fill 1dff @@ -3823,7 +4408,7 @@ .fill 6000 .fill 1dff .fill 9180 -.fill cc74 +.fill cc5a .fill 1d84 .fill 6380 .fill 1d81 @@ -3842,14 +4427,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 .fill a40b .fill 4001 .fill ae01 -.fill 7aba +.fill 811d .fill 1dff .fill 9180 .fill 4601 @@ -3860,7 +4445,7 @@ .fill ae0a .fill 4001 .fill ae01 -.fill 7ae8 +.fill 814b .fill 1dff .fill 9180 .fill 4601 @@ -3880,7 +4465,6 @@ .fill 1dff .fill 9b80 .fill 1ae0 -.fill 1d80 .fill 10d0 .fill 1182 .fill 6000 @@ -3897,7 +4481,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73b9 +.fill 79ff .fill c300 .fill 1d82 .fill 1080 @@ -3918,7 +4502,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 738e +.fill 79d5 .fill c300 .fill 1d82 .fill 2380 @@ -3950,7 +4534,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73b9 +.fill 79ff .fill c300 .fill 1d82 .fill 1080 @@ -3971,7 +4555,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 738e +.fill 79d5 .fill c300 .fill 1d82 .fill 2380 @@ -4015,7 +4599,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -4043,7 +4627,6 @@ .fill 1dff .fill 9b80 .fill 1ae0 -.fill 1d80 .fill 10d0 .fill 1182 .fill 6000 @@ -4059,7 +4642,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73b9 +.fill 79ff .fill c300 .fill 1d82 .fill 1080 @@ -4079,7 +4662,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 738e +.fill 79d5 .fill c300 .fill 1d82 .fill 2380 @@ -4103,13 +4686,9 @@ .fill e000 .fill 1dff .fill 9f80 -.fill 1dff -.fill 9b80 -.fill 1ae0 -.fill 1d80 .fill 4001 .fill ae01 -.fill 7840 +.fill 7e86 .fill 6000 .fill 2380 .fill 3100 @@ -4124,18 +4703,18 @@ .fill a418 .fill 4001 .fill ae01 -.fill 7843 +.fill 7e89 .fill 1dff .fill 9180 .fill 4001 .fill ae01 -.fill 783d +.fill 7e83 .fill 6000 .fill 1dff .fill 9180 .fill 4001 .fill ae01 -.fill 7845 +.fill 7e8b .fill 6000 .fill 6380 .fill 1d81 @@ -4148,7 +4727,7 @@ .fill ae00 .fill 4001 .fill ae01 -.fill 7840 +.fill 7e86 .fill 1dff .fill 9180 .fill 2180 @@ -4156,10 +4735,16 @@ .fill 6380 .fill 1d81 .fill 9040 +.fill 4001 +.fill ae01 +.fill 7e84 +.fill 1dff +.fill 9180 .fill 2180 -.fill 1cd0 -.fill 6b80 +.fill 6380 .fill 1d81 +.fill 9040 +.fill 2180 .fill 6f80 .fill 1d81 .fill e000 @@ -4175,11 +4760,11 @@ .fill aa04 .fill 4601 .fill ae01 -.fill 1252 +.fill 1491 .fill b600 .fill 4001 .fill ae01 -.fill 783d +.fill 7e83 .fill 6000 .fill 6000 .fill 1dff @@ -4194,14 +4779,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill aa1e .fill 4001 .fill ae01 -.fill 783d +.fill 7e83 .fill 6000 .fill 6000 .fill 1dff @@ -4216,7 +4801,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -4235,7 +4820,7 @@ .fill aa1e .fill 4001 .fill ae01 -.fill 783d +.fill 7e83 .fill 6000 .fill 6000 .fill 1dff @@ -4250,7 +4835,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -4269,7 +4854,7 @@ .fill aa1e .fill 4001 .fill ae01 -.fill 783d +.fill 7e83 .fill 6000 .fill 6000 .fill 1dff @@ -4284,7 +4869,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -4303,7 +4888,7 @@ .fill a40d .fill 4001 .fill ae01 -.fill 783d +.fill 7e83 .fill 1dff .fill 9180 .fill 6000 @@ -4316,7 +4901,7 @@ .fill af77 .fill 4001 .fill ae01 -.fill 783d +.fill 7e83 .fill 6000 .fill 1dff .fill 9180 @@ -4337,14 +4922,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a425 .fill 4001 .fill ae01 -.fill 783d +.fill 7e83 .fill 6000 .fill 1dff .fill 9180 @@ -4366,7 +4951,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -4384,14 +4969,14 @@ .fill a436 .fill 4001 .fill ae01 -.fill 783d +.fill 7e83 .fill 6000 .fill 6000 .fill 1080 .fill a41e .fill 4001 .fill ae01 -.fill 783d +.fill 7e83 .fill 6000 .fill 6000 .fill 1dff @@ -4406,7 +4991,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7404 +.fill 7a48 .fill c300 .fill 1d82 .fill 2380 @@ -4424,7 +5009,7 @@ .fill a40d .fill 4001 .fill ae01 -.fill 783d +.fill 7e83 .fill 1dff .fill 9180 .fill 6000 @@ -4435,10 +5020,10 @@ .fill 9040 .fill 10c0 .fill afcb -.fill aef9 +.fill aeef .fill 4001 .fill ae01 -.fill 783d +.fill 7e83 .fill 6000 .fill 1dff .fill 9180 @@ -4459,14 +5044,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a425 .fill 4001 .fill ae01 -.fill 783d +.fill 7e83 .fill 6000 .fill 1dff .fill 9180 @@ -4488,7 +5073,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -4503,15 +5088,15 @@ .fill ae01 .fill 2180 .fill 1080 -.fill a4b4 +.fill a4aa .fill 4001 .fill ae01 -.fill 783d +.fill 7e83 .fill 1dff .fill 9180 .fill 4001 .fill ae01 -.fill 783d +.fill 7e83 .fill 6000 .fill 1dff .fill 9180 @@ -4525,14 +5110,14 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 783d +.fill 7e83 .fill 6000 .fill 6000 .fill 1080 .fill a455 .fill 4001 .fill ae01 -.fill 783d +.fill 7e83 .fill 6000 .fill 1dff .fill 9180 @@ -4553,14 +5138,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a425 .fill 4001 .fill ae01 -.fill 783d +.fill 7e83 .fill 6000 .fill 1dff .fill 9180 @@ -4582,7 +5167,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -4620,7 +5205,7 @@ .fill a40d .fill 4001 .fill ae01 -.fill 783d +.fill 7e83 .fill 1dff .fill 9180 .fill 6000 @@ -4633,7 +5218,7 @@ .fill af94 .fill 4001 .fill ae01 -.fill 783d +.fill 7e83 .fill 6000 .fill 6000 .fill 2380 @@ -4646,32 +5231,22 @@ .fill 2180 .fill 1181 .fill 1080 -.fill a411 -.fill cddd -.fill 1d80 -.fill 4001 -.fill ae01 -.fill 783e -.fill 1dff -.fill 9180 -.fill 2180 -.fill 6380 -.fill 1d81 -.fill 9040 +.fill a407 +.fill cddb .fill 2180 .fill 4601 .fill ae01 -.fill 1b6c +.fill 1f20 .fill b600 .fill ae00 .fill 4001 .fill ae01 -.fill 783d +.fill 7e83 .fill 1dff .fill 9180 .fill 4001 .fill ae01 -.fill 783d +.fill 7e83 .fill 6000 .fill 1dff .fill 9180 @@ -4687,7 +5262,7 @@ .fill ae04 .fill 4601 .fill ae01 -.fill 104a +.fill 1293 .fill b600 .fill 10d0 .fill 11ff @@ -4695,7 +5270,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 783d +.fill 7e83 .fill 6000 .fill 6000 .fill 6380 @@ -4730,14 +5305,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a40f .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 1dff .fill 9180 .fill 2180 @@ -4747,7 +5322,7 @@ .fill 2180 .fill 4601 .fill ae01 -.fill 1b6c +.fill 1f20 .fill b600 .fill ae00 .fill 10d0 @@ -4755,10 +5330,10 @@ .fill 6000 .fill 1dff .fill 9180 -.fill cc8f +.fill cc99 .fill 1d81 .fill 1080 -.fill a497 +.fill a48d .fill 10d0 .fill 11fe .fill 1dff @@ -4769,23 +5344,23 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 783d +.fill 7e83 .fill 6000 .fill 6000 .fill 1dff .fill 9180 -.fill cc7c +.fill cc86 .fill 1d81 .fill 1080 .fill aa13 .fill 4001 .fill ae01 -.fill 783d +.fill 7e83 .fill 6000 .fill 6000 .fill 1dff .fill 9180 -.fill cd14 +.fill cd1d .fill 1d81 .fill 2380 .fill 3100 @@ -4800,7 +5375,7 @@ .fill 2180 .fill 1181 .fill 1080 -.fill a44b +.fill a441 .fill 10d0 .fill 11fe .fill 6000 @@ -4816,26 +5391,16 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 -.fill a411 -.fill cd2f -.fill 1d80 -.fill 4001 -.fill ae01 -.fill 783e -.fill 1dff -.fill 9180 -.fill 2180 -.fill 6380 -.fill 1d81 -.fill 9040 +.fill a407 +.fill cd37 .fill 2180 .fill 4601 .fill ae01 -.fill 1b6c +.fill 1f20 .fill b600 .fill ae00 .fill 4001 @@ -4861,7 +5426,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 783d +.fill 7e83 .fill 1dff .fill 9180 .fill 6000 @@ -4875,7 +5440,7 @@ .fill 6380 .fill 1d81 .fill 9040 -.fill af93 +.fill af9d .fill 4001 .fill ae01 .fill e380 @@ -4895,7 +5460,7 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 1dff .fill 9180 .fill 4001 @@ -4907,7 +5472,7 @@ .fill 2180 .fill 4601 .fill ae01 -.fill 1b6c +.fill 1f20 .fill b600 .fill ae00 .fill 10d0 @@ -4915,17 +5480,17 @@ .fill 6000 .fill 1dff .fill 9180 -.fill cc92 +.fill cca5 .fill 1d81 .fill 1080 .fill aa04 .fill 4601 .fill ae01 -.fill 1627 +.fill 18c2 .fill b600 .fill 4001 .fill ae01 -.fill 783f +.fill 7e85 .fill 1dff .fill 9180 .fill 2180 @@ -4951,7 +5516,7 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 783d +.fill 7e83 .fill 6000 .fill 1dff .fill 9180 @@ -4972,14 +5537,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a450 .fill 4001 .fill ae01 -.fill 783d +.fill 7e83 .fill 6000 .fill 1dff .fill 9180 @@ -5002,14 +5567,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill aa26 .fill 4001 .fill ae01 -.fill 783d +.fill 7e83 .fill 6000 .fill 1dff .fill 9180 @@ -5032,7 +5597,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -5071,12 +5636,12 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 783d +.fill 7e83 .fill 1dff .fill 9180 .fill 4001 .fill ae01 -.fill 783d +.fill 7e83 .fill 6000 .fill 1dff .fill 9180 @@ -5088,6 +5653,36 @@ .fill 6380 .fill 1d81 .fill 9040 +.fill ae1e +.fill 10d0 +.fill 11ff +.fill 6000 +.fill 1dff +.fill 9180 +.fill 2180 +.fill 11b0 +.fill 6380 +.fill 1d81 +.fill 1dff +.fill 9180 +.fill 1dff +.fill 9380 +.fill 4601 +.fill ae01 +.fill 7a29 +.fill c300 +.fill 1d82 +.fill 1080 +.fill a40a +.fill 10d0 +.fill 11fc +.fill 1dff +.fill 9180 +.fill 2180 +.fill 1188 +.fill 6380 +.fill 1d81 +.fill 9040 .fill ae00 .fill 2180 .fill 1181 @@ -5095,7 +5690,7 @@ .fill aa04 .fill 4601 .fill ae01 -.fill 1602 +.fill 189e .fill b600 .fill 10d0 .fill 11fd @@ -5103,7 +5698,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 783d +.fill 7e83 .fill 6000 .fill 6000 .fill 6380 @@ -5116,7 +5711,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 0fc7 +.fill 120f .fill c300 .fill 1d81 .fill 1080 @@ -5156,7 +5751,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -5177,7 +5772,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73b9 +.fill 79ff .fill c300 .fill 1d82 .fill 2380 @@ -5209,7 +5804,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 738e +.fill 79d5 .fill c300 .fill 1d82 .fill 2380 @@ -5268,7 +5863,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -5289,7 +5884,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73b9 +.fill 79ff .fill c300 .fill 1d82 .fill 2380 @@ -5321,7 +5916,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 738e +.fill 79d5 .fill c300 .fill 1d82 .fill 2380 @@ -5367,9 +5962,35 @@ .fill ae04 .fill 4601 .fill ae01 -.fill 1602 +.fill 189e .fill b600 .fill 10d0 +.fill 11fd +.fill 6000 +.fill 1dff +.fill 9180 +.fill 10d0 +.fill 11fc +.fill 6000 +.fill 6380 +.fill 1d81 +.fill 1dff +.fill 9180 +.fill 1dff +.fill 9380 +.fill 4601 +.fill ae01 +.fill 79ff +.fill c300 +.fill 1d82 +.fill 1080 +.fill a405 +.fill 4601 +.fill ae01 +.fill 124d +.fill c300 +.fill ae00 +.fill 10d0 .fill 11fc .fill 6000 .fill 1dff @@ -5384,14 +6005,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a45f .fill 4001 .fill ae01 -.fill 783f +.fill 7e85 .fill 6000 .fill 1dff .fill 9180 @@ -5406,14 +6027,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7363 +.fill 79ab .fill c300 .fill 1d82 .fill 1080 .fill aa3d .fill 4001 .fill ae01 -.fill 783f +.fill 7e85 .fill 6000 .fill 1dff .fill 9180 @@ -5428,7 +6049,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -5448,7 +6069,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7363 +.fill 79ab .fill c300 .fill 1d82 .fill 2380 @@ -5502,7 +6123,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -5522,7 +6143,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -5549,35 +6170,82 @@ .fill 2180 .fill 1181 .fill 1080 -.fill a414 -.fill 4601 -.fill ae01 -.fill 1006 -.fill c300 -.fill 1d80 -.fill 4001 -.fill ae01 -.fill 783e +.fill aa35 +.fill 10d0 +.fill 11fc +.fill 6000 .fill 1dff .fill 9180 .fill 2180 +.fill 1188 .fill 6380 .fill 1d81 -.fill 9040 +.fill 1dff +.fill 9180 +.fill 1dff +.fill 9380 +.fill 4601 +.fill ae01 +.fill 7a29 +.fill c300 +.fill 1d82 +.fill 1080 +.fill a416 +.fill 4001 +.fill ae01 +.fill 7e85 +.fill 6000 +.fill 1dff +.fill 9180 +.fill 4001 +.fill ae01 +.fill e000 +.fill 6380 +.fill 1d81 +.fill 2010 +.fill 2380 +.fill 3100 +.fill 1181 +.fill 1010 +.fill aa02 +.fill 2180 +.fill ae02 +.fill 2180 +.fill 1181 +.fill ae01 +.fill 2180 +.fill 2380 +.fill 3100 +.fill 1181 +.fill 1010 +.fill aa02 +.fill 2180 +.fill ae02 +.fill 2180 +.fill 1181 +.fill ae02 +.fill 2180 +.fill 1181 +.fill 1080 +.fill a40a +.fill 4601 +.fill ae01 +.fill 124d +.fill c300 .fill 2180 .fill 4601 .fill ae01 -.fill 1b6c +.fill 1f20 .fill b600 .fill ae00 .fill 4001 .fill ae01 -.fill 783f +.fill 7e85 .fill 1dff .fill 9180 .fill 4001 .fill ae01 -.fill 783f +.fill 7e85 .fill 6000 .fill 1dff .fill 9180 @@ -5592,7 +6260,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7424 +.fill 7a67 .fill c300 .fill 1d82 .fill 1dff @@ -5608,7 +6276,7 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 783d +.fill 7e83 .fill 1dff .fill 9180 .fill 6000 @@ -5631,7 +6299,7 @@ .fill 10c0 .fill 4601 .fill ae01 -.fill 13e2 +.fill 1635 .fill b600 .fill 10d0 .fill 11fe @@ -5646,16 +6314,15 @@ .fill 2180 .fill 1181 .fill 1080 -.fill a406 +.fill a405 .fill 4601 .fill ae01 -.fill 1006 +.fill 124d .fill c300 -.fill 1d80 .fill ae00 .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 1dff .fill 9180 .fill 4001 @@ -5667,7 +6334,7 @@ .fill 2180 .fill 4601 .fill ae01 -.fill 1b6c +.fill 1f20 .fill b600 .fill ae00 .fill 10d0 @@ -5685,7 +6352,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -5705,7 +6372,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -5724,11 +6391,11 @@ .fill aa04 .fill 4601 .fill ae01 -.fill 1880 +.fill 1c13 .fill b600 .fill 4001 .fill ae01 -.fill 783d +.fill 7e83 .fill 1dff .fill 9180 .fill 6000 @@ -5748,14 +6415,14 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 783d +.fill 7e83 .fill 6000 .fill 6000 .fill 1080 .fill a41f .fill 4001 .fill ae01 -.fill 783d +.fill 7e83 .fill 6000 .fill 6000 .fill 1dff @@ -5771,7 +6438,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7404 +.fill 7a48 .fill c300 .fill 1d82 .fill 2380 @@ -5789,7 +6456,7 @@ .fill aa04 .fill 4601 .fill ae01 -.fill 17e9 +.fill 1b7e .fill b600 .fill 10d0 .fill 11fd @@ -5797,7 +6464,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 783d +.fill 7e83 .fill 1dff .fill 9180 .fill 6000 @@ -5816,6 +6483,63 @@ .fill 6000 .fill 1dff .fill 9180 +.fill 2180 +.fill 118a +.fill 6380 +.fill 1d81 +.fill 1dff +.fill 9180 +.fill 1dff +.fill 9380 +.fill 4601 +.fill ae01 +.fill 7a29 +.fill c300 +.fill 1d82 +.fill 1080 +.fill aa1c +.fill 10d0 +.fill 11fd +.fill 6000 +.fill 1dff +.fill 9180 +.fill 2180 +.fill 118d +.fill 6380 +.fill 1d81 +.fill 1dff +.fill 9180 +.fill 1dff +.fill 9380 +.fill 4601 +.fill ae01 +.fill 7a29 +.fill c300 +.fill 1d82 +.fill 2380 +.fill 3100 +.fill 1181 +.fill 1010 +.fill aa02 +.fill 2180 +.fill ae02 +.fill 2180 +.fill 1181 +.fill ae02 +.fill 2180 +.fill 1181 +.fill 1080 +.fill a405 +.fill 4601 +.fill ae01 +.fill 124d +.fill c300 +.fill ae00 +.fill 10d0 +.fill 11fd +.fill 6000 +.fill 1dff +.fill 9180 .fill 4001 .fill ae01 .fill 005c @@ -5827,14 +6551,18 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 -.fill a4c7 +.fill aa04 +.fill 4601 +.fill ae01 +.fill 1b26 +.fill b600 .fill 4001 .fill ae01 -.fill 783d +.fill 7e83 .fill 6000 .fill 6000 .fill 2380 @@ -5847,15 +6575,14 @@ .fill 2180 .fill 1181 .fill 1080 -.fill a40a +.fill a409 .fill 4601 .fill ae01 -.fill 1006 +.fill 124d .fill c300 -.fill 1d80 .fill 4601 .fill ae01 -.fill 17e9 +.fill 1b7e .fill b600 .fill ae00 .fill 10d0 @@ -5864,7 +6591,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 783d +.fill 7e83 .fill 1dff .fill 9180 .fill 6000 @@ -5894,11 +6621,11 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 -.fill a40a +.fill a40d .fill 10d0 .fill 11fd .fill 1dff @@ -5908,7 +6635,10 @@ .fill 6380 .fill 1d81 .fill 9040 -.fill ae79 +.fill 4601 +.fill ae01 +.fill 1b25 +.fill b600 .fill 10d0 .fill 11fd .fill 6000 @@ -5925,11 +6655,11 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 -.fill a40a +.fill a40d .fill 10d0 .fill 11fd .fill 1dff @@ -5939,7 +6669,165 @@ .fill 6380 .fill 1d81 .fill 9040 -.fill ae5a +.fill 4601 +.fill ae01 +.fill 1b25 +.fill b600 +.fill 10d0 +.fill 11fd +.fill 6000 +.fill 1dff +.fill 9180 +.fill 4001 +.fill ae01 +.fill 0072 +.fill 6380 +.fill 1d81 +.fill 1dff +.fill 9180 +.fill 1dff +.fill 9380 +.fill 4601 +.fill ae01 +.fill 7a29 +.fill c300 +.fill 1d82 +.fill 1080 +.fill a40a +.fill 10d0 +.fill 11fd +.fill 1dff +.fill 9180 +.fill 2180 +.fill 118d +.fill 6380 +.fill 1d81 +.fill 9040 +.fill aef4 +.fill 10d0 +.fill 11fd +.fill 6000 +.fill 1dff +.fill 9180 +.fill 4001 +.fill ae01 +.fill 0062 +.fill 6380 +.fill 1d81 +.fill 1dff +.fill 9180 +.fill 1dff +.fill 9380 +.fill 4601 +.fill ae01 +.fill 7a29 +.fill c300 +.fill 1d82 +.fill 1080 +.fill a40a +.fill 10d0 +.fill 11fd +.fill 1dff +.fill 9180 +.fill 2180 +.fill 1188 +.fill 6380 +.fill 1d81 +.fill 9040 +.fill aed5 +.fill 10d0 +.fill 11fd +.fill 6000 +.fill 1dff +.fill 9180 +.fill 4001 +.fill ae01 +.fill 0061 +.fill 6380 +.fill 1d81 +.fill 1dff +.fill 9180 +.fill 1dff +.fill 9380 +.fill 4601 +.fill ae01 +.fill 7a29 +.fill c300 +.fill 1d82 +.fill 1080 +.fill a40a +.fill 10d0 +.fill 11fd +.fill 1dff +.fill 9180 +.fill 2180 +.fill 1187 +.fill 6380 +.fill 1d81 +.fill 9040 +.fill aeb6 +.fill 10d0 +.fill 11fd +.fill 6000 +.fill 1dff +.fill 9180 +.fill 4001 +.fill ae01 +.fill 0066 +.fill 6380 +.fill 1d81 +.fill 1dff +.fill 9180 +.fill 1dff +.fill 9380 +.fill 4601 +.fill ae01 +.fill 7a29 +.fill c300 +.fill 1d82 +.fill 1080 +.fill a40a +.fill 10d0 +.fill 11fd +.fill 1dff +.fill 9180 +.fill 2180 +.fill 118c +.fill 6380 +.fill 1d81 +.fill 9040 +.fill ae97 +.fill 10d0 +.fill 11fd +.fill 6000 +.fill 1dff +.fill 9180 +.fill 4001 +.fill ae01 +.fill 0076 +.fill 6380 +.fill 1d81 +.fill 1dff +.fill 9180 +.fill 1dff +.fill 9380 +.fill 4601 +.fill ae01 +.fill 7a29 +.fill c300 +.fill 1d82 +.fill 1080 +.fill a40a +.fill 10d0 +.fill 11fd +.fill 1dff +.fill 9180 +.fill 2180 +.fill 118b +.fill 6380 +.fill 1d81 +.fill 9040 +.fill ae78 .fill 10d0 .fill 11fd .fill 6000 @@ -5956,7 +6844,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7404 +.fill 7a48 .fill c300 .fill 1d82 .fill 1080 @@ -5976,7 +6864,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7404 +.fill 7a48 .fill c300 .fill 1d82 .fill 2380 @@ -6007,7 +6895,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7404 +.fill 7a48 .fill c300 .fill 1d82 .fill 2380 @@ -6022,13 +6910,43 @@ .fill ae01 .fill 2180 .fill 1080 -.fill a407 +.fill a41c +.fill 10d0 +.fill 11fd +.fill 6000 +.fill 1dff +.fill 9180 +.fill 2180 +.fill 11bf +.fill 6380 +.fill 1d81 +.fill 1dff +.fill 9180 +.fill 1dff +.fill 9380 .fill 4601 .fill ae01 -.fill 1006 +.fill 7a48 .fill c300 -.fill 1d80 -.fill ae5b +.fill 1d82 +.fill 2380 +.fill 3100 +.fill 1181 +.fill 1010 +.fill aa02 +.fill 2180 +.fill ae02 +.fill 2180 +.fill 1181 +.fill ae01 +.fill 2180 +.fill 1080 +.fill a406 +.fill 4601 +.fill ae01 +.fill 124d +.fill c300 +.fill ae5a .fill ae00 .fill ae00 .fill 10d0 @@ -6046,7 +6964,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -6065,7 +6983,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -6081,12 +6999,11 @@ .fill 2180 .fill 1181 .fill 1080 -.fill a407 +.fill a406 .fill 4601 .fill ae01 -.fill 1006 +.fill 124d .fill c300 -.fill 1d80 .fill ae20 .fill ae00 .fill 4001 @@ -6118,11 +7035,11 @@ .fill 9040 .fill 4601 .fill ae01 -.fill 1673 +.fill 190e .fill b600 .fill 4001 .fill ae01 -.fill 783d +.fill 7e83 .fill 6000 .fill 6000 .fill 1dff @@ -6138,20 +7055,19 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7404 +.fill 7a48 .fill c300 .fill 1d82 .fill 1080 -.fill a406 +.fill a405 .fill 4601 .fill ae01 -.fill 1006 +.fill 124d .fill c300 -.fill 1d80 .fill ae0c .fill 4001 .fill ae01 -.fill 783d +.fill 7e83 .fill 1dff .fill 9180 .fill 6000 @@ -6193,11 +7109,11 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 -.fill a438 +.fill a437 .fill 10d0 .fill 11fe .fill 6000 @@ -6213,20 +7129,19 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7404 +.fill 7a48 .fill c300 .fill 1d82 .fill 1080 -.fill a406 +.fill a405 .fill 4601 .fill ae01 -.fill 1006 +.fill 124d .fill c300 -.fill 1d80 .fill ae00 .fill 4001 .fill ae01 -.fill 783f +.fill 7e85 .fill 1dff .fill 9180 .fill 4001 @@ -6244,7 +7159,7 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 1dff .fill 9180 .fill 4001 @@ -6256,7 +7171,7 @@ .fill ae0b .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 1dff .fill 9180 .fill 4001 @@ -6268,12 +7183,45 @@ .fill 2180 .fill 4601 .fill ae01 -.fill 1b6c +.fill 1f20 .fill b600 .fill ae00 .fill 4001 .fill ae01 -.fill 783d +.fill e380 +.fill 1dff +.fill 9180 +.fill 2180 +.fill 6380 +.fill 1d81 +.fill 1010 +.fill 1dff +.fill 9180 +.fill 10d0 +.fill 11ff +.fill 6000 +.fill 6380 +.fill 1d81 +.fill 9040 +.fill 4001 +.fill ae01 +.fill e380 +.fill 1dff +.fill 9180 +.fill 2180 +.fill 1181 +.fill 6380 +.fill 1d81 +.fill 1010 +.fill 1dff +.fill 9180 +.fill 2180 +.fill 6380 +.fill 1d81 +.fill 9040 +.fill 4001 +.fill ae01 +.fill 7e83 .fill 1dff .fill 9180 .fill 6000 @@ -6285,7 +7233,7 @@ .fill 10c0 .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 1dff .fill 9180 .fill 10d0 @@ -6296,7 +7244,7 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 783d +.fill 7e83 .fill 6000 .fill 6000 .fill 1dff @@ -6312,14 +7260,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill aa04 .fill 4601 .fill ae01 -.fill 19b4 +.fill 1d68 .fill b600 .fill 10d0 .fill 11ff @@ -6336,14 +7284,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a40c .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 1dff .fill 9180 .fill 4001 @@ -6369,14 +7317,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a40c .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 1dff .fill 9180 .fill 4001 @@ -6401,14 +7349,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a40c .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 1dff .fill 9180 .fill 4001 @@ -6433,14 +7381,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a40c .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 1dff .fill 9180 .fill 4001 @@ -6465,14 +7413,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a40c .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 1dff .fill 9180 .fill 4001 @@ -6497,14 +7445,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a40c .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 1dff .fill 9180 .fill 4001 @@ -6529,7 +7477,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7404 +.fill 7a48 .fill c300 .fill 1d82 .fill 1080 @@ -6537,7 +7485,7 @@ .fill 2180 .fill 4601 .fill ae01 -.fill 1b6c +.fill 1f20 .fill b600 .fill ae00 .fill 10d0 @@ -6555,14 +7503,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7404 +.fill 7a48 .fill c300 .fill 1d82 .fill 1080 .fill a412 .fill 4001 .fill ae01 -.fill 783d +.fill 7e83 .fill 1dff .fill 9180 .fill 6000 @@ -6575,13 +7523,13 @@ .fill 2180 .fill 4601 .fill ae01 -.fill 1b6c +.fill 1f20 .fill b600 .fill ae00 .fill ae00 .fill 4001 .fill ae01 -.fill 783d +.fill 7e83 .fill 6000 .fill 6000 .fill 1dff @@ -6596,14 +7544,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill aa04 .fill 4601 .fill ae01 -.fill 1b6b +.fill 1f1f .fill b600 .fill 10d0 .fill 11ff @@ -6620,14 +7568,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a40f .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 1dff .fill 9180 .fill 4001 @@ -6638,7 +7586,7 @@ .fill 9040 .fill 4601 .fill ae01 -.fill 1b5e +.fill 1f12 .fill b600 .fill 10d0 .fill 11ff @@ -6655,14 +7603,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a40f .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 1dff .fill 9180 .fill 4001 @@ -6673,7 +7621,7 @@ .fill 9040 .fill 4601 .fill ae01 -.fill 1b5e +.fill 1f12 .fill b600 .fill 10d0 .fill 11ff @@ -6690,14 +7638,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a40f .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 1dff .fill 9180 .fill 4001 @@ -6708,7 +7656,7 @@ .fill 9040 .fill 4601 .fill ae01 -.fill 1b5e +.fill 1f12 .fill b600 .fill 10d0 .fill 11ff @@ -6725,14 +7673,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a40f .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 1dff .fill 9180 .fill 4001 @@ -6743,7 +7691,7 @@ .fill 9040 .fill 4601 .fill ae01 -.fill 1b5e +.fill 1f12 .fill b600 .fill 10d0 .fill 11ff @@ -6760,14 +7708,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a40c .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 1dff .fill 9180 .fill 4001 @@ -6792,14 +7740,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a40c .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 1dff .fill 9180 .fill 4001 @@ -6824,14 +7772,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a40c .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 1dff .fill 9180 .fill 4001 @@ -6856,14 +7804,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a40c .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 1dff .fill 9180 .fill 4001 @@ -6888,14 +7836,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a40c .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 1dff .fill 9180 .fill 4001 @@ -6920,14 +7868,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a40c .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 1dff .fill 9180 .fill 4001 @@ -6953,14 +7901,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a40c .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 1dff .fill 9180 .fill 4001 @@ -6986,14 +7934,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a40c .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 1dff .fill 9180 .fill 4001 @@ -7007,7 +7955,7 @@ .fill ae0e .fill 4001 .fill ae01 -.fill 783d +.fill 7e83 .fill 1dff .fill 9180 .fill 6000 @@ -7030,10 +7978,9 @@ .fill 1dff .fill 9b80 .fill 1ae0 -.fill 1d80 .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 6000 .fill 1dff .fill 9180 @@ -7048,7 +7995,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -7079,7 +8026,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -7106,10 +8053,9 @@ .fill 1dff .fill 9b80 .fill 1ae0 -.fill 1d80 .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 6000 .fill 1dff .fill 9180 @@ -7124,24 +8070,22 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7404 +.fill 7a48 .fill c300 .fill 1d82 .fill 1080 -.fill a408 +.fill a407 .fill 4601 .fill ae01 -.fill 1006 +.fill 124d .fill c300 -.fill 1d80 .fill 2180 -.fill ae07 +.fill ae06 .fill ae00 .fill 4601 .fill ae01 -.fill 1044 +.fill 128d .fill c300 -.fill 1d80 .fill 2180 .fill 1cd0 .fill 6b80 @@ -7154,10 +8098,18 @@ .fill 1dff .fill 9b80 .fill 1ae0 -.fill 1d80 .fill 4001 .fill ae01 -.fill 7841 +.fill 7e86 +.fill 6000 +.fill 1080 +.fill a403 +.fill 2180 +.fill ae3b +.fill ae00 +.fill 4001 +.fill ae01 +.fill 7e87 .fill 6000 .fill 1dff .fill 9180 @@ -7172,16 +8124,15 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73b9 +.fill 79ff .fill c300 .fill 1d82 .fill 1080 -.fill a408 +.fill a407 .fill 4601 .fill ae01 -.fill 1006 +.fill 124d .fill c300 -.fill 1d80 .fill 2180 .fill ae1e .fill ae00 @@ -7192,7 +8143,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7841 +.fill 7e87 .fill 1dff .fill 9180 .fill 6000 @@ -7225,7 +8176,6 @@ .fill 1dff .fill 9b80 .fill 1ae0 -.fill 1d80 .fill 4001 .fill ae01 .fill 4001 @@ -7247,7 +8197,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7424 +.fill 7a67 .fill c300 .fill 1d82 .fill 6380 @@ -7255,21 +8205,21 @@ .fill 1010 .fill 1dff .fill 9180 -.fill cf95 +.fill cf8f .fill 1d81 .fill 4001 .fill ae01 .fill ae01 .fill 1dff .fill 9180 -.fill cf8e +.fill cf88 .fill 1d81 .fill 10d0 .fill 1183 .fill 6000 .fill 1dff .fill 9180 -.fill cf87 +.fill cf81 .fill 1d81 .fill 2180 .fill 1cd0 @@ -7280,55 +8230,41 @@ .fill e000 .fill 1dff .fill 9f80 -.fill 1dff -.fill 9b80 -.fill 1ae0 -.fill 1d80 .fill 4001 .fill ae01 .fill 1dff .fill 1dff .fill 9180 -.fill cf73 +.fill cf71 .fill 1d81 .fill 4001 .fill ae01 .fill 9180 .fill 1dff .fill 9180 -.fill cf6c +.fill cf6a .fill 1d81 .fill 2180 -.fill 1cd0 -.fill 6b80 -.fill 1d81 .fill 6f80 .fill 1d81 .fill e000 .fill 1dff .fill 9f80 -.fill 1dff -.fill 9b80 -.fill 1ae0 -.fill 1d80 .fill 4001 .fill ae01 .fill 6380 .fill 1dff .fill 9180 -.fill cf58 +.fill cf5d .fill 1d81 .fill 4001 .fill ae01 .fill 1d81 .fill 1dff .fill 9180 -.fill cf51 +.fill cf56 .fill 1d81 .fill 2180 -.fill 1cd0 -.fill 6b80 -.fill 1d81 .fill 6f80 .fill 1d81 .fill e000 @@ -7344,7 +8280,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7841 +.fill 7e87 .fill 6000 .fill 1dff .fill 9180 @@ -7358,7 +8294,7 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 9000 +.fill a000 .fill 1dff .fill 9180 .fill 10d0 @@ -7373,14 +8309,14 @@ .fill 1183 .fill 1dff .fill 9180 -.fill cf66 +.fill cf75 .fill 1d82 .fill 4001 .fill ae01 .fill b600 .fill 1dff .fill 9180 -.fill cf18 +.fill cf20 .fill 1d81 .fill 10d0 .fill 11ff @@ -7398,10 +8334,9 @@ .fill 1dff .fill 9b80 .fill 1ae0 -.fill 1d80 .fill 4001 .fill ae01 -.fill 7840 +.fill 7e86 .fill 6000 .fill 2380 .fill 3100 @@ -7429,12 +8364,12 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 9000 +.fill a000 .fill 1dff .fill 9180 .fill 4001 .fill ae01 -.fill 7841 +.fill 7e87 .fill 6000 .fill 6380 .fill 1d81 @@ -7455,7 +8390,6 @@ .fill 1dff .fill 9b80 .fill 1ae0 -.fill 1d80 .fill 10d0 .fill 1182 .fill 6000 @@ -7465,14 +8399,14 @@ .fill 1183 .fill 1dff .fill 9180 -.fill cf0a +.fill cf1b .fill 1d82 .fill 4001 .fill ae01 .fill c300 .fill 1dff .fill 9180 -.fill cebc +.fill cec6 .fill 1d81 .fill 4001 .fill ae01 @@ -7487,7 +8421,7 @@ .fill 1010 .fill 1dff .fill 9180 -.fill cead +.fill ceb7 .fill 1d81 .fill 2180 .fill 1cd0 @@ -7498,34 +8432,27 @@ .fill e000 .fill 1dff .fill 9f80 -.fill 1dff -.fill 9b80 -.fill 1ae0 -.fill 1d80 .fill 4001 .fill ae01 .fill 1080 .fill 1dff .fill 9180 -.fill ce99 +.fill cea7 .fill 1d81 .fill 4001 .fill ae01 .fill aa04 .fill 1dff .fill 9180 -.fill ce92 +.fill cea0 .fill 1d81 .fill 2180 .fill 1dff .fill 9180 -.fill cf44 +.fill cf4a .fill 1d81 .fill ae01 .fill 2180 -.fill 1cd0 -.fill 6b80 -.fill 1d81 .fill 6f80 .fill 1d81 .fill e000 @@ -7550,7 +8477,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7842 +.fill 7e88 .fill 6000 .fill 6380 .fill 1d81 @@ -7560,7 +8487,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 @@ -7590,7 +8517,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7424 +.fill 7a67 .fill c300 .fill 1d82 .fill 6380 @@ -7614,7 +8541,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -7622,7 +8549,7 @@ .fill 10d0 .fill 11ff .fill 6000 -.fill ae13 +.fill ae11 .fill ae00 .fill 10d0 .fill 11ff @@ -7637,10 +8564,83 @@ .fill 10c0 .fill afa3 .fill 2180 +.fill 11ff +.fill ae01 +.fill 2180 +.fill 1cd0 +.fill 6b80 +.fill 1d81 +.fill 6f80 +.fill 1d81 +.fill e000 +.fill 1dff +.fill 9f80 +.fill 1dff +.fill 9b80 +.fill 1ae0 +.fill 4001 +.fill ae01 +.fill 9800 +.fill 1dff +.fill 9180 +.fill 10d0 +.fill 1182 +.fill 6000 +.fill 6380 +.fill 1d81 +.fill 1010 +.fill 1dff +.fill 9180 +.fill 2180 +.fill 1dff +.fill 9180 +.fill ce58 +.fill 1d82 +.fill 4001 +.fill ae01 +.fill 6000 +.fill 1dff +.fill 9180 +.fill ce03 +.fill 1d81 +.fill 2180 +.fill 1cd0 +.fill 6b80 +.fill 1d81 +.fill 6f80 +.fill 1d81 +.fill e000 +.fill 1dff +.fill 9f80 +.fill 1dff +.fill 9b80 +.fill 1ae0 +.fill 4001 +.fill ae01 +.fill 9800 +.fill 1dff +.fill 9180 +.fill 10d0 +.fill 1182 +.fill 6000 +.fill 6380 +.fill 1d81 +.fill 1010 +.fill 1dff +.fill 9180 +.fill 2180 .fill 1181 -.fill 3100 -.fill 1181 +.fill 1dff +.fill 9180 +.fill ce32 +.fill 1d82 +.fill 4001 .fill ae01 +.fill 9040 +.fill 1dff +.fill 9180 +.fill cddd +.fill 1d81 .fill 2180 .fill 1cd0 .fill 6b80 @@ -7653,7 +8653,6 @@ .fill 1dff .fill 9b80 .fill 1ae0 -.fill 1d80 .fill 10d0 .fill 1182 .fill 6000 @@ -7670,7 +8669,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill ae01 @@ -7686,7 +8685,6 @@ .fill 1dff .fill 9b80 .fill 1ae0 -.fill 1d80 .fill 10d0 .fill 1182 .fill 6000 @@ -7703,7 +8701,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7363 +.fill 79ab .fill c300 .fill 1d82 .fill ae01 @@ -7719,7 +8717,6 @@ .fill 1dff .fill 9b80 .fill 1ae0 -.fill 1d80 .fill 10d0 .fill 1182 .fill 6000 @@ -7736,7 +8733,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 738e +.fill 79d5 .fill c300 .fill 1d82 .fill ae01 @@ -7752,7 +8749,6 @@ .fill 1dff .fill 9b80 .fill 1ae0 -.fill 1d80 .fill 10d0 .fill 1182 .fill 6000 @@ -7769,7 +8765,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73b9 +.fill 79ff .fill c300 .fill 1d82 .fill ae01 @@ -7785,7 +8781,6 @@ .fill 1dff .fill 9b80 .fill 1ae0 -.fill 1d80 .fill 10d0 .fill 1182 .fill 6000 @@ -7802,7 +8797,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill ae01 @@ -7818,7 +8813,6 @@ .fill 1dff .fill 9b80 .fill 1ae0 -.fill 1d80 .fill 10d0 .fill 1182 .fill 6000 @@ -7835,7 +8829,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7404 +.fill 7a48 .fill c300 .fill 1d82 .fill ae01 @@ -7851,7 +8845,6 @@ .fill 1dff .fill 9b80 .fill 1ae0 -.fill 1d80 .fill 10d0 .fill 1182 .fill 6000 @@ -7868,7 +8861,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7424 +.fill 7a67 .fill c300 .fill 1d82 .fill ae01 @@ -7884,7 +8877,6 @@ .fill 1dff .fill 9b80 .fill 1ae0 -.fill 1d80 .fill 10d0 .fill 1182 .fill 6000 @@ -7901,7 +8893,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 74df +.fill 7b36 .fill c300 .fill 1d82 .fill ae01 @@ -7917,7 +8909,6 @@ .fill 1dff .fill 9b80 .fill 1ae0 -.fill 1d80 .fill 10d0 .fill 1182 .fill 6000 @@ -7934,7 +8925,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7589 +.fill 7bd5 .fill c300 .fill 1d82 .fill ae01 @@ -7950,7 +8941,6 @@ .fill 1dff .fill 9b80 .fill 1ae0 -.fill 1d80 .fill 10d0 .fill 1182 .fill 6000 @@ -7969,7 +8959,6 @@ .fill 1dff .fill 9b80 .fill 1ae0 -.fill 1d80 .fill 10d0 .fill 1182 .fill 6000 @@ -7995,7 +8984,6 @@ .fill 1dff .fill 9b80 .fill 1ae0 -.fill 1d80 .fill 10d0 .fill 1182 .fill 6000 @@ -8012,7 +9000,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 75c9 +.fill 7c14 .fill c300 .fill 1d82 .fill ae01 @@ -8028,7 +9016,6 @@ .fill 1dff .fill 9b80 .fill 1ae0 -.fill 1d80 .fill 10d0 .fill 1182 .fill 6000 @@ -8045,7 +9032,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 75e5 +.fill 7c2f .fill c300 .fill 1d82 .fill ae01 @@ -8061,7 +9048,6 @@ .fill 1dff .fill 9b80 .fill 1ae0 -.fill 1d80 .fill 10d0 .fill 1182 .fill 6000 @@ -8078,7 +9064,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7610 +.fill 7c59 .fill c300 .fill 1d82 .fill ae01 @@ -8094,7 +9080,6 @@ .fill 1dff .fill 9b80 .fill 1ae0 -.fill 1d80 .fill 10d0 .fill 1182 .fill 6000 @@ -8111,7 +9096,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 767f +.fill 7cc7 .fill c300 .fill 1d82 .fill ae01 @@ -8127,7 +9112,6 @@ .fill 1dff .fill 9b80 .fill 1ae0 -.fill 1d80 .fill 10d0 .fill 1182 .fill 6000 @@ -8135,16 +9119,7 @@ .fill 3100 .fill 1181 .fill 1010 -.fill a402 -.fill 2180 -.fill ae02 -.fill 2180 -.fill 1181 -.fill 2380 -.fill 3100 -.fill 1181 -.fill 1010 -.fill a402 +.fill aa02 .fill 2180 .fill ae02 .fill 2180 @@ -8162,7 +9137,21 @@ .fill 1dff .fill 9b80 .fill 1ae0 -.fill 1d80 +.fill 10d0 +.fill 1182 +.fill 6000 +.fill 2180 +.fill 1cd0 +.fill 6b80 +.fill 1d81 +.fill 6f80 +.fill 1d81 +.fill e000 +.fill 1dff +.fill 9f80 +.fill 1dff +.fill 9b80 +.fill 1ae0 .fill 10d0 .fill 1182 .fill 6000 @@ -8179,7 +9168,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -8188,7 +9177,7 @@ .fill 1181 .fill 4601 .fill ae01 -.fill 21f3 +.fill 25d0 .fill b600 .fill ae00 .fill 10d0 @@ -8207,7 +9196,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -8216,7 +9205,7 @@ .fill 1182 .fill 4601 .fill ae01 -.fill 21f3 +.fill 25d0 .fill b600 .fill ae00 .fill 10d0 @@ -8235,7 +9224,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -8244,7 +9233,7 @@ .fill 1183 .fill 4601 .fill ae01 -.fill 21f3 +.fill 25d0 .fill b600 .fill ae00 .fill 10d0 @@ -8263,7 +9252,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -8272,7 +9261,7 @@ .fill 1184 .fill 4601 .fill ae01 -.fill 21f3 +.fill 25d0 .fill b600 .fill ae00 .fill 10d0 @@ -8290,7 +9279,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -8299,7 +9288,7 @@ .fill 1185 .fill 4601 .fill ae01 -.fill 21f3 +.fill 25d0 .fill b600 .fill ae00 .fill 10d0 @@ -8318,7 +9307,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -8339,7 +9328,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -8360,7 +9349,7 @@ .fill 1186 .fill 4601 .fill ae01 -.fill 21f3 +.fill 25d0 .fill b600 .fill ae00 .fill 10d0 @@ -8378,7 +9367,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -8398,7 +9387,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -8431,7 +9420,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -8464,7 +9453,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -8501,7 +9490,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -8522,7 +9511,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -8558,7 +9547,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -8578,7 +9567,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -8614,7 +9603,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -8634,7 +9623,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -8666,7 +9655,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -8717,7 +9706,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -8737,7 +9726,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -8769,7 +9758,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -8781,7 +9770,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1bee +.fill 1f9e .fill c300 .fill 1d81 .fill 4001 @@ -8791,7 +9780,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1bee +.fill 1f9e .fill c300 .fill 1d81 .fill ae00 @@ -8802,13 +9791,13 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1bee +.fill 1f9e .fill c300 .fill 1d81 .fill 2180 .fill 4601 .fill ae01 -.fill 2449 +.fill 2825 .fill b600 .fill ae00 .fill 10d0 @@ -8826,7 +9815,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -8838,20 +9827,19 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1bee +.fill 1f9e .fill c300 .fill 1d81 .fill 2180 .fill 4601 .fill ae01 -.fill 2449 +.fill 2825 .fill b600 .fill ae00 .fill 4601 .fill ae01 -.fill 1c6f +.fill 2025 .fill c300 -.fill 1d80 .fill 4001 .fill ae01 .fill 1dff @@ -8859,7 +9847,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1bee +.fill 1f9e .fill c300 .fill 1d81 .fill 4001 @@ -8869,7 +9857,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1bee +.fill 1f9e .fill c300 .fill 1d81 .fill 10d0 @@ -8887,7 +9875,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -8898,13 +9886,13 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 1ea7 +.fill 2289 .fill 6380 .fill 1d81 .fill 9040 .fill 4601 .fill ae01 -.fill 243a +.fill 2816 .fill b600 .fill 10d0 .fill 1182 @@ -8921,7 +9909,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -8932,13 +9920,13 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 1ec8 +.fill 22a9 .fill 6380 .fill 1d81 .fill 9040 .fill 4601 .fill ae01 -.fill 243a +.fill 2816 .fill b600 .fill 10d0 .fill 1182 @@ -8955,7 +9943,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -8966,13 +9954,13 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 1ee9 +.fill 22c9 .fill 6380 .fill 1d81 .fill 9040 .fill 4601 .fill ae01 -.fill 243a +.fill 2816 .fill b600 .fill 10d0 .fill 1182 @@ -8990,7 +9978,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -9001,13 +9989,13 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 1f37 +.fill 2314 .fill 6380 .fill 1d81 .fill 9040 .fill 4601 .fill ae01 -.fill 243a +.fill 2816 .fill b600 .fill 10d0 .fill 1182 @@ -9025,7 +10013,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -9036,7 +10024,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 1f58 +.fill 2334 .fill 6380 .fill 1d81 .fill 9040 @@ -9057,7 +10045,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -9068,7 +10056,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 1f79 +.fill 2354 .fill 6380 .fill 1d81 .fill 9040 @@ -9089,7 +10077,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -9100,7 +10088,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 1f9a +.fill 2374 .fill 6380 .fill 1d81 .fill 9040 @@ -9121,7 +10109,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -9132,7 +10120,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 1e65 +.fill 2249 .fill 6380 .fill 1d81 .fill 9040 @@ -9153,7 +10141,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -9164,7 +10152,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 1e86 +.fill 2269 .fill 6380 .fill 1d81 .fill 9040 @@ -9184,7 +10172,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -9195,7 +10183,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 1de1 +.fill 21c9 .fill 6380 .fill 1d81 .fill 9040 @@ -9215,7 +10203,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -9226,7 +10214,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 1e02 +.fill 21e9 .fill 6380 .fill 1d81 .fill 9040 @@ -9247,7 +10235,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -9258,7 +10246,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 1e23 +.fill 2209 .fill 6380 .fill 1d81 .fill 9040 @@ -9269,7 +10257,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 1e44 +.fill 2229 .fill 6380 .fill 1d81 .fill 9040 @@ -9284,7 +10272,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1d1b +.fill 20c2 .fill c300 .fill 1d82 .fill 2180 @@ -9299,22 +10287,22 @@ .fill 1dff .fill 9b80 .fill 1ae0 -.fill 1dfb +.fill 1dfa .fill 4001 .fill ae01 -.fill 7840 +.fill 7e86 .fill 6000 .fill 1080 .fill a406 .fill 2180 .fill 4601 .fill ae01 -.fill 28c9 +.fill 2d72 .fill b600 .fill ae00 .fill 4001 .fill ae01 -.fill 7844 +.fill 7e8a .fill 1dff .fill 9180 .fill 6000 @@ -9326,7 +10314,7 @@ .fill 10c0 .fill 4001 .fill ae01 -.fill 7844 +.fill 7e8a .fill 6000 .fill 1dff .fill 9180 @@ -9340,25 +10328,33 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7363 +.fill 79ab .fill c300 .fill 1d82 .fill 1080 -.fill a40b +.fill a40a .fill 4601 .fill ae01 -.fill 1006 +.fill 124d .fill c300 -.fill 1d80 .fill 2180 .fill 4601 .fill ae01 -.fill 28c9 +.fill 2d72 .fill b600 .fill ae00 .fill 4001 .fill ae01 -.fill 783e +.fill 7e8d +.fill 1dff +.fill 9180 +.fill 2180 +.fill 6380 +.fill 1d81 +.fill 9040 +.fill 4001 +.fill ae01 +.fill 7e84 .fill 6000 .fill 1dff .fill 9180 @@ -9373,14 +10369,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 -.fill a417 +.fill a416 .fill 4001 .fill ae01 -.fill 783f +.fill 7e85 .fill 6000 .fill 1dff .fill 9180 @@ -9389,21 +10385,20 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1c35 +.fill 1fec .fill c300 .fill 1d82 .fill 4601 .fill ae01 -.fill 1044 +.fill 128d .fill c300 -.fill 1d80 .fill 4601 .fill ae01 -.fill 28bc +.fill 2d65 .fill b600 .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 6000 .fill 1dff .fill 9180 @@ -9418,11 +10413,37 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 -.fill a48f +.fill a4ac +.fill 10d0 +.fill 11fe +.fill 1dff +.fill 9180 +.fill 2180 +.fill 1dff +.fill 9180 +.fill 4601 +.fill ae01 +.fill 204d +.fill c300 +.fill 1d81 +.fill 6380 +.fill 1d81 +.fill 9040 +.fill 10d0 +.fill 11fd +.fill 1dff +.fill 9180 +.fill 4001 +.fill ae01 +.fill 7e87 +.fill 6000 +.fill 6380 +.fill 1d81 +.fill 9040 .fill 10d0 .fill 11fc .fill 1dff @@ -9441,32 +10462,6 @@ .fill 1d81 .fill 9040 .fill 10d0 -.fill 11fe -.fill 1dff -.fill 9180 -.fill 2180 -.fill 1dff -.fill 9180 -.fill 4601 -.fill ae01 -.fill 1ca5 -.fill c300 -.fill 1d81 -.fill 6380 -.fill 1d81 -.fill 9040 -.fill 10d0 -.fill 11fd -.fill 1dff -.fill 9180 -.fill 4001 -.fill ae01 -.fill 7841 -.fill 6000 -.fill 6380 -.fill 1d81 -.fill 9040 -.fill 10d0 .fill 11ff .fill 1dff .fill 9180 @@ -9490,7 +10485,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 738e +.fill 7981 .fill c300 .fill 1d82 .fill 1080 @@ -9511,7 +10506,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1bee +.fill 1f9e .fill c300 .fill 1d81 .fill 10d0 @@ -9526,6 +10521,40 @@ .fill 9040 .fill 10c0 .fill afcc +.fill 4601 +.fill ae01 +.fill 128d +.fill c300 +.fill 4001 +.fill ae01 +.fill 7e84 +.fill 6000 +.fill 1dff +.fill 9180 +.fill 4001 +.fill ae01 +.fill 0102 +.fill 6380 +.fill 1d81 +.fill 1dff +.fill 9180 +.fill 1dff +.fill 9380 +.fill 4601 +.fill ae01 +.fill 7a29 +.fill c300 +.fill 1d82 +.fill 1080 +.fill ab99 +.fill 2180 +.fill 1dff +.fill 9180 +.fill 4601 +.fill ae01 +.fill 1f9e +.fill c300 +.fill 1d81 .fill 10d0 .fill 11fe .fill 6000 @@ -9533,12 +10562,12 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1ce2 +.fill 208a .fill c300 .fill 1d81 .fill 4001 .fill ae01 -.fill 9000 +.fill a000 .fill 1dff .fill 9180 .fill 10d0 @@ -9554,21 +10583,16 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1c35 +.fill 1fec .fill c300 .fill 1d82 .fill 4601 .fill ae01 -.fill 1044 -.fill c300 -.fill 1d80 -.fill 4601 -.fill ae01 -.fill 28bc +.fill 2d65 .fill b600 .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 6000 .fill 1dff .fill 9180 @@ -9582,37 +10606,35 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 -.fill a417 +.fill a415 .fill 4601 .fill ae01 -.fill 1044 +.fill 128d .fill c300 -.fill 1d80 .fill 4601 .fill ae01 -.fill 2a59 +.fill 2f06 .fill c300 -.fill 1d80 .fill 2180 .fill 11a9 .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 1bbe +.fill 1f71 .fill c300 .fill 1d81 .fill 4601 .fill ae01 -.fill 28bc +.fill 2d65 .fill b600 .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 6000 .fill 1dff .fill 9180 @@ -9626,14 +10648,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill aa1d .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 6000 .fill 1dff .fill 9180 @@ -9647,7 +10669,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -9666,7 +10688,7 @@ .fill aa1d .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 6000 .fill 1dff .fill 9180 @@ -9680,7 +10702,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -9699,7 +10721,7 @@ .fill aa1e .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 6000 .fill 1dff .fill 9180 @@ -9714,7 +10736,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -9730,30 +10752,27 @@ .fill 2180 .fill 1181 .fill 1080 -.fill a495 +.fill a49b .fill 10d0 .fill 11fb .fill 1dff .fill 9180 .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 6000 .fill 6380 .fill 1d81 .fill 9040 .fill 4601 .fill ae01 -.fill 1044 +.fill 128d .fill c300 -.fill 1d80 -.fill ce3a -.fill 1d80 +.fill ce19 .fill 4601 .fill ae01 -.fill 1c6f +.fill 2025 .fill c300 -.fill 1d80 .fill 10d0 .fill 11fb .fill 6000 @@ -9769,7 +10788,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -9780,12 +10799,12 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 1f0a +.fill 22e9 .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 1d1b +.fill 20c2 .fill c300 .fill 1d82 .fill ae57 @@ -9804,7 +10823,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -9815,12 +10834,12 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 1f1d +.fill 22fb .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 1d1b +.fill 20c2 .fill c300 .fill 1d82 .fill ae34 @@ -9831,7 +10850,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1bee +.fill 1f9e .fill c300 .fill 1d81 .fill 4001 @@ -9841,7 +10860,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1bee +.fill 1f9e .fill c300 .fill 1d81 .fill 10d0 @@ -9860,7 +10879,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -9872,17 +10891,26 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1bee +.fill 1f9e .fill c300 .fill 1d81 .fill ae00 +.fill 4001 +.fill ae01 +.fill 7e8d +.fill 1dff +.fill 9180 +.fill 2180 +.fill 6380 +.fill 1d81 +.fill 9040 .fill 4601 .fill ae01 -.fill 28bc +.fill 2d65 .fill b600 .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 6000 .fill 1dff .fill 9180 @@ -9897,14 +10925,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill aa1e .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 6000 .fill 1dff .fill 9180 @@ -9919,7 +10947,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -9935,23 +10963,22 @@ .fill 2180 .fill 1181 .fill 1080 -.fill a4d3 +.fill a4a5 .fill 10d0 .fill 11fb .fill 1dff .fill 9180 .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 6000 .fill 6380 .fill 1d81 .fill 9040 .fill 4601 .fill ae01 -.fill 1044 +.fill 128d .fill c300 -.fill 1d80 .fill 10d0 .fill 11ff .fill 1dff @@ -9963,7 +10990,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1d6a +.fill 2109 .fill c300 .fill 1d81 .fill 6380 @@ -9971,7 +10998,7 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 6000 .fill 1dff .fill 9180 @@ -9986,7 +11013,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7404 +.fill 7a48 .fill c300 .fill 1d82 .fill 1080 @@ -10005,7 +11032,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 2380 @@ -10021,52 +11048,29 @@ .fill 2180 .fill 1181 .fill 1080 -.fill a40b +.fill a40a .fill 4601 .fill ae01 -.fill 1006 +.fill 124d .fill c300 -.fill 1d80 .fill 2180 .fill 4601 .fill ae01 -.fill 28c9 +.fill 2d72 .fill b600 .fill ae00 .fill 4601 .fill ae01 -.fill 1044 +.fill 128d .fill c300 -.fill 1d80 -.fill 4001 -.fill ae01 -.fill 9800 -.fill 1dff -.fill 9180 .fill 10d0 .fill 11ff .fill 6000 -.fill 6380 -.fill 1d81 -.fill 1010 -.fill 1dff -.fill 9180 -.fill 2180 .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 1c35 -.fill c300 -.fill 1d82 -.fill 4001 -.fill ae01 -.fill 6000 -.fill 1dff -.fill 9180 -.fill 4601 -.fill ae01 -.fill 1bee +.fill 217e .fill c300 .fill 1d81 .fill 10d0 @@ -10085,7 +11089,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -10097,7 +11101,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1bee +.fill 1f9e .fill c300 .fill 1d81 .fill ae0a @@ -10108,48 +11112,26 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1bee +.fill 1f9e .fill c300 .fill 1d81 -.fill 4001 -.fill ae01 -.fill 9800 -.fill 1dff -.fill 9180 .fill 10d0 .fill 11ff .fill 6000 -.fill 6380 -.fill 1d81 -.fill 1010 -.fill 1dff -.fill 9180 -.fill 2180 -.fill 1181 .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 1c35 -.fill c300 -.fill 1d82 -.fill 4001 -.fill ae01 -.fill 9040 -.fill 1dff -.fill 9180 -.fill 4601 -.fill ae01 -.fill 1bee +.fill 21a3 .fill c300 .fill 1d81 .fill 4601 .fill ae01 -.fill 28bc +.fill 2d65 .fill b600 .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 6000 .fill 1dff .fill 9180 @@ -10164,11 +11146,15 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 -.fill a4fd +.fill aa04 +.fill 4601 +.fill ae01 +.fill 2d61 +.fill b600 .fill 10d0 .fill 11ff .fill 1dff @@ -10180,7 +11166,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1d6a +.fill 2109 .fill c300 .fill 1d81 .fill 6380 @@ -10200,58 +11186,71 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 79ff .fill c300 .fill 1d82 .fill 1080 -.fill a408 +.fill aa04 .fill 4601 .fill ae01 -.fill 1006 -.fill c300 -.fill 1d80 -.fill 2180 -.fill aee4 -.fill ae00 -.fill 4001 -.fill ae01 -.fill 9800 +.fill 2d5c +.fill b600 +.fill 10d0 +.fill 11fa .fill 1dff .fill 9180 +.fill 2180 +.fill 6380 +.fill 1d81 +.fill 9040 +.fill 4601 +.fill ae01 +.fill 128d +.fill c300 .fill 10d0 .fill 11ff .fill 6000 -.fill 6380 -.fill 1d81 -.fill 1010 -.fill 1dff -.fill 9180 -.fill 2180 .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 1c35 +.fill 217e .fill c300 -.fill 1d82 +.fill 1d81 .fill 4001 .fill ae01 +.fill 7e86 .fill 6000 -.fill 1dff -.fill 9180 -.fill 4601 +.fill 2380 +.fill 3100 +.fill 1181 +.fill 1010 +.fill a402 +.fill 2180 +.fill ae02 +.fill 2180 +.fill 1181 +.fill 1080 +.fill a40d +.fill 10d0 +.fill 11fa +.fill 6000 +.fill 2380 +.fill 3100 +.fill 1181 +.fill 1010 +.fill aa02 +.fill 2180 +.fill ae02 +.fill 2180 +.fill 1181 .fill ae01 -.fill 1bee -.fill c300 -.fill 1d81 -.fill 4601 -.fill ae01 -.fill 1044 -.fill c300 -.fill 1d80 +.fill 2180 +.fill 1080 +.fill a440 .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 6000 .fill 1dff .fill 9180 @@ -10266,14 +11265,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill aa1e .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 6000 .fill 1dff .fill 9180 @@ -10288,7 +11287,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -10303,29 +11302,38 @@ .fill ae02 .fill 2180 .fill 1181 +.fill 2380 +.fill 3100 +.fill 1181 +.fill 1010 +.fill aa02 +.fill 2180 +.fill ae02 +.fill 2180 +.fill 1181 +.fill ae01 +.fill 2180 .fill 1080 -.fill a474 +.fill a460 .fill 10d0 .fill 11fb .fill 1dff .fill 9180 .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 6000 .fill 6380 .fill 1d81 .fill 9040 .fill 4601 .fill ae01 -.fill 1044 +.fill 128d .fill c300 -.fill 1d80 .fill 4601 .fill ae01 -.fill 1c6f +.fill 2025 .fill c300 -.fill 1d80 .fill 10d0 .fill 11fb .fill 6000 @@ -10342,7 +11350,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -10354,7 +11362,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1bee +.fill 1f9e .fill c300 .fill 1d81 .fill ae0a @@ -10365,39 +11373,220 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1bee +.fill 1f9e .fill c300 .fill 1d81 .fill 4001 .fill ae01 -.fill 9800 +.fill 9080 .fill 1dff .fill 9180 +.fill 4601 +.fill ae01 +.fill 1f9e +.fill c300 +.fill 1d81 +.fill 4601 +.fill ae01 +.fill 2039 +.fill c300 +.fill 4001 +.fill ae01 +.fill 5020 +.fill 1dff +.fill 9180 +.fill 4601 +.fill ae01 +.fill 1f9e +.fill c300 +.fill 1d81 +.fill 4001 +.fill ae01 +.fill 1002 +.fill 1dff +.fill 9180 +.fill 4601 +.fill ae01 +.fill 1f9e +.fill c300 +.fill 1d81 +.fill ae00 +.fill 4001 +.fill ae01 +.fill 7e86 +.fill 6000 +.fill 2380 +.fill 3100 +.fill 1181 +.fill 1010 +.fill a402 +.fill 2180 +.fill ae02 +.fill 2180 +.fill 1181 +.fill 1080 +.fill a416 .fill 10d0 -.fill 11ff +.fill 11fa +.fill 6000 +.fill 2380 +.fill 3100 +.fill 1181 +.fill 1010 +.fill a402 +.fill 2180 +.fill ae02 +.fill 2180 +.fill 1181 +.fill 2380 +.fill 3100 +.fill 1181 +.fill 1010 +.fill aa02 +.fill 2180 +.fill ae02 +.fill 2180 +.fill 1181 +.fill ae01 +.fill 2180 +.fill 1080 +.fill a440 +.fill 4001 +.fill ae01 +.fill 7e84 +.fill 6000 +.fill 1dff +.fill 9180 +.fill 4001 +.fill ae01 +.fill 0109 +.fill 6380 +.fill 1d81 +.fill 1dff +.fill 9180 +.fill 1dff +.fill 9380 +.fill 4601 +.fill ae01 +.fill 7a29 +.fill c300 +.fill 1d82 +.fill 1080 +.fill aa1e +.fill 4001 +.fill ae01 +.fill 7e84 +.fill 6000 +.fill 1dff +.fill 9180 +.fill 4001 +.fill ae01 +.fill 010a +.fill 6380 +.fill 1d81 +.fill 1dff +.fill 9180 +.fill 1dff +.fill 9380 +.fill 4601 +.fill ae01 +.fill 7a29 +.fill c300 +.fill 1d82 +.fill 2380 +.fill 3100 +.fill 1181 +.fill 1010 +.fill aa02 +.fill 2180 +.fill ae02 +.fill 2180 +.fill 1181 +.fill ae02 +.fill 2180 +.fill 1181 +.fill 2380 +.fill 3100 +.fill 1181 +.fill 1010 +.fill aa02 +.fill 2180 +.fill ae02 +.fill 2180 +.fill 1181 +.fill ae01 +.fill 2180 +.fill 1080 +.fill a45c +.fill 10d0 +.fill 11fb +.fill 1dff +.fill 9180 +.fill 4001 +.fill ae01 +.fill 7e84 .fill 6000 .fill 6380 .fill 1d81 -.fill 1010 +.fill 9040 +.fill 4601 +.fill ae01 +.fill 128d +.fill c300 +.fill 4601 +.fill ae01 +.fill 2025 +.fill c300 +.fill 10d0 +.fill 11fb +.fill 6000 .fill 1dff .fill 9180 -.fill 2180 +.fill 4001 +.fill ae01 +.fill 0109 +.fill 6380 +.fill 1d81 +.fill 1dff +.fill 9180 +.fill 1dff +.fill 9380 +.fill 4601 +.fill ae01 +.fill 7a29 +.fill c300 +.fill 1d82 +.fill 1080 +.fill a40b +.fill 4001 +.fill ae01 .fill 1181 .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 1c35 +.fill 1f9e .fill c300 -.fill 1d82 +.fill 1d81 +.fill ae0a .fill 4001 .fill ae01 -.fill 9040 +.fill 11ff .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 1bee +.fill 1f9e +.fill c300 +.fill 1d81 +.fill 10d0 +.fill 11ff +.fill 6000 +.fill 1dff +.fill 9180 +.fill 4601 +.fill ae01 +.fill 21a3 .fill c300 .fill 1d81 .fill 4001 @@ -10407,7 +11596,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1bee +.fill 1f9e .fill c300 .fill 1d81 .fill 4001 @@ -10417,19 +11606,23 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1bee +.fill 1f9e .fill c300 .fill 1d81 .fill ae00 -.fill ae05 +.fill ae04 .fill 4601 .fill ae01 -.fill 1006 +.fill 124d +.fill c300 +.fill ae04 +.fill 4601 +.fill ae01 +.fill 124d .fill c300 -.fill 1d80 .fill 4001 .fill ae01 -.fill 7844 +.fill 7e8a .fill 1dff .fill 9180 .fill 6000 @@ -10454,22 +11647,21 @@ .fill 1dfc .fill 4601 .fill ae01 -.fill 244f +.fill 282b .fill c300 -.fill 1d80 .fill 10d0 .fill 11fe .fill 1dff .fill 9180 .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 6000 .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 1fde +.fill 23bc .fill c300 .fill 1d81 .fill 6380 @@ -10477,7 +11669,7 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 7840 +.fill 7e86 .fill 6000 .fill 2380 .fill 3100 @@ -10506,7 +11698,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73b9 +.fill 79ff .fill c300 .fill 1d82 .fill 2380 @@ -10540,7 +11732,7 @@ .fill aa04 .fill 4601 .fill ae01 -.fill 2a52 +.fill 2eff .fill b600 .fill 10d0 .fill 11ff @@ -10548,16 +11740,24 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 6000 .fill 6380 .fill 1d81 .fill 9040 .fill 4601 .fill ae01 -.fill 1044 +.fill 128d .fill c300 -.fill 1d80 +.fill 4001 +.fill ae01 +.fill 7e8d +.fill 1dff +.fill 9180 +.fill 2180 +.fill 6380 +.fill 1d81 +.fill 9040 .fill 10d0 .fill 11ff .fill 6000 @@ -10574,7 +11774,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -10595,7 +11795,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -10611,7 +11811,7 @@ .fill 2180 .fill 1181 .fill 1080 -.fill a4a5 +.fill a4a4 .fill 4001 .fill ae01 .fill 1080 @@ -10619,7 +11819,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1bee +.fill 1f9e .fill c300 .fill 1d81 .fill 10d0 @@ -10638,7 +11838,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -10650,7 +11850,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1bee +.fill 1f9e .fill c300 .fill 1d81 .fill ae0a @@ -10661,7 +11861,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1bee +.fill 1f9e .fill c300 .fill 1d81 .fill 10d0 @@ -10673,7 +11873,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1ca5 +.fill 204d .fill c300 .fill 1d81 .fill 6380 @@ -10691,25 +11891,24 @@ .fill 1010 .fill 1dff .fill 9180 -.fill cf0a +.fill cf03 .fill 1d81 .fill 4601 .fill ae01 -.fill 1c6f +.fill 2025 .fill c300 -.fill 1d80 .fill 2180 .fill 1181 .fill 1dff .fill 9180 .fill 4001 .fill ae01 -.fill 1fbb +.fill 2394 .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 1d1b +.fill 20c2 .fill c300 .fill 1d82 .fill 10d0 @@ -10721,7 +11920,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1ca5 +.fill 204d .fill c300 .fill 1d81 .fill 6380 @@ -10734,7 +11933,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1ce2 +.fill 208a .fill c300 .fill 1d81 .fill 10d0 @@ -10753,7 +11952,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1dff @@ -10763,7 +11962,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1c35 +.fill 1fec .fill c300 .fill 1d82 .fill 10d0 @@ -10773,15 +11972,14 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1ce2 +.fill 208a .fill c300 .fill 1d81 -.fill ae22 +.fill ae20 .fill 4601 .fill ae01 -.fill 1c6f +.fill 2025 .fill c300 -.fill 1d80 .fill 10d0 .fill 11fe .fill 6000 @@ -10794,13 +11992,12 @@ .fill 1010 .fill 1dff .fill 9180 -.fill cea3 +.fill ce9e .fill 1d81 .fill 4601 .fill ae01 -.fill 1c8a +.fill 2039 .fill c300 -.fill 1d80 .fill 10d0 .fill 11ff .fill 6000 @@ -10808,7 +12005,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 21f9 +.fill 25d6 .fill c300 .fill 1d81 .fill 10d0 @@ -10817,13 +12014,13 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 6000 .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 1fde +.fill 23bc .fill c300 .fill 1d81 .fill 6380 @@ -10831,7 +12028,7 @@ .fill 9040 .fill 4601 .fill ae01 -.fill 28ec +.fill 2d94 .fill b600 .fill 2180 .fill 1cd0 @@ -10842,10 +12039,6 @@ .fill e000 .fill 1dff .fill 9f80 -.fill 1dff -.fill 9b80 -.fill 1ae0 -.fill 1d80 .fill 2180 .fill 1181 .fill 1dff @@ -10853,9 +12046,6 @@ .fill ce6b .fill 1d81 .fill 2180 -.fill 1cd0 -.fill 6b80 -.fill 1d81 .fill 6f80 .fill 1d81 .fill e000 @@ -10879,14 +12069,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73b9 +.fill 79ff .fill c300 .fill 1d82 .fill 1080 .fill a417 .fill 4001 .fill ae01 -.fill 7840 +.fill 7e86 .fill 6000 .fill 2380 .fill 3100 @@ -10944,7 +12134,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 9000 +.fill a000 .fill 1dff .fill 9180 .fill 10d0 @@ -10982,7 +12172,7 @@ .fill 1de5 .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 6000 .fill 1dff .fill 9180 @@ -10997,14 +12187,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill aa1e .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 6000 .fill 1dff .fill 9180 @@ -11019,7 +12209,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -11035,21 +12225,20 @@ .fill 2180 .fill 1181 .fill 1080 -.fill a40b +.fill a40a .fill 4601 .fill ae01 -.fill 244f +.fill 282b .fill c300 -.fill 1d80 .fill 2180 .fill 4601 .fill ae01 -.fill 2fb8 +.fill 33f9 .fill b600 .fill ae00 .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 6000 .fill 1dff .fill 9180 @@ -11064,7 +12253,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7404 +.fill 7a48 .fill c300 .fill 1d82 .fill 1080 @@ -11091,7 +12280,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73b9 +.fill 79ff .fill c300 .fill 1d82 .fill 2380 @@ -11107,16 +12296,15 @@ .fill 2180 .fill 1181 .fill 1080 -.fill a40b +.fill a40a .fill 4601 .fill ae01 -.fill 1006 +.fill 124d .fill c300 -.fill 1d80 .fill 2180 .fill 4601 .fill ae01 -.fill 2fb8 +.fill 33f9 .fill b600 .fill ae00 .fill 4001 @@ -11154,16 +12342,15 @@ .fill 1d83 .fill 4601 .fill ae01 -.fill 1044 +.fill 128d .fill c300 -.fill 1d80 .fill 10d0 .fill 11e5 .fill 1dff .fill 9180 .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 6000 .fill 6380 .fill 1d81 @@ -11184,7 +12371,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -11205,7 +12392,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -11221,7 +12408,7 @@ .fill 2180 .fill 1181 .fill 1080 -.fill a4a0 +.fill a473 .fill 10d0 .fill 11e7 .fill 1dff @@ -11232,7 +12419,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1d6a +.fill 2109 .fill c300 .fill 1d81 .fill 6380 @@ -11252,56 +12439,33 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 -.fill a40b +.fill a40a .fill 4601 .fill ae01 -.fill 1006 +.fill 124d .fill c300 -.fill 1d80 .fill 2180 .fill 4601 .fill ae01 -.fill 2fb8 +.fill 33f9 .fill b600 .fill ae00 .fill 4601 .fill ae01 -.fill 1044 +.fill 128d .fill c300 -.fill 1d80 -.fill 4001 -.fill ae01 -.fill 9800 -.fill 1dff -.fill 9180 .fill 10d0 .fill 11e7 .fill 6000 -.fill 6380 -.fill 1d81 -.fill 1010 -.fill 1dff -.fill 9180 -.fill 2180 .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 1c35 -.fill c300 -.fill 1d82 -.fill 4001 -.fill ae01 -.fill 6000 -.fill 1dff -.fill 9180 -.fill 4601 -.fill ae01 -.fill 1bee +.fill 217e .fill c300 .fill 1d81 .fill 10d0 @@ -11320,7 +12484,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -11332,7 +12496,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1bee +.fill 1f9e .fill c300 .fill 1d81 .fill ae0a @@ -11343,44 +12507,22 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1bee +.fill 1f9e .fill c300 .fill 1d81 -.fill 4001 -.fill ae01 -.fill 9800 -.fill 1dff -.fill 9180 .fill 10d0 .fill 11e7 .fill 6000 -.fill 6380 -.fill 1d81 -.fill 1010 -.fill 1dff -.fill 9180 -.fill 2180 -.fill 1181 .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 1c35 -.fill c300 -.fill 1d82 -.fill 4001 -.fill ae01 -.fill 9040 -.fill 1dff -.fill 9180 -.fill 4601 -.fill ae01 -.fill 1bee +.fill 21a3 .fill c300 .fill 1d81 .fill 4601 .fill ae01 -.fill 2fb7 +.fill 33f8 .fill b600 .fill 10d0 .fill 11e5 @@ -11397,7 +12539,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -11418,7 +12560,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73b9 +.fill 79ff .fill c300 .fill 1d82 .fill 1080 @@ -11439,7 +12581,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 738e +.fill 79d5 .fill c300 .fill 1d82 .fill 2380 @@ -11469,7 +12611,7 @@ .fill aa04 .fill 4601 .fill ae01 -.fill 2e6a +.fill 32b0 .fill b600 .fill 10d0 .fill 11e7 @@ -11481,7 +12623,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1d6a +.fill 2109 .fill c300 .fill 1d81 .fill 6380 @@ -11501,20 +12643,19 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 -.fill a40b +.fill a40a .fill 4601 .fill ae01 -.fill 1006 +.fill 124d .fill c300 -.fill 1d80 .fill 2180 .fill 4601 .fill ae01 -.fill 2fb8 +.fill 33f9 .fill b600 .fill ae00 .fill 10d0 @@ -11532,55 +12673,31 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7404 +.fill 7a48 .fill c300 .fill 1d82 .fill 1080 -.fill a425 -.fill 4001 -.fill ae01 -.fill 9800 -.fill 1dff -.fill 9180 +.fill a40f .fill 10d0 .fill 11e7 .fill 6000 -.fill 6380 -.fill 1d81 -.fill 1010 -.fill 1dff -.fill 9180 -.fill 2180 .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 1c35 -.fill c300 -.fill 1d82 -.fill 4001 -.fill ae01 -.fill 6000 -.fill 1dff -.fill 9180 -.fill 4601 -.fill ae01 -.fill 1bee +.fill 217e .fill c300 .fill 1d81 .fill 4601 .fill ae01 -.fill 1c6f +.fill 2025 .fill c300 -.fill 1d80 .fill ae00 .fill 4601 .fill ae01 -.fill 1044 +.fill 128d .fill c300 -.fill 1d80 -.fill cd1c -.fill 1d80 +.fill cd6b .fill 10d0 .fill 11e5 .fill 6000 @@ -11596,16 +12713,15 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7404 +.fill 7a48 .fill c300 .fill 1d82 .fill 1080 -.fill a4f4 +.fill a4f3 .fill 4601 .fill ae01 -.fill 1c8a +.fill 2039 .fill c300 -.fill 1d80 .fill 10d0 .fill 11e5 .fill 6000 @@ -11622,7 +12738,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -11653,7 +12769,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -11684,7 +12800,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -11715,7 +12831,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -11746,7 +12862,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -11777,7 +12893,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -11808,7 +12924,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -11841,45 +12957,23 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 21f9 +.fill 25d6 .fill c300 .fill 1d81 .fill ae00 -.fill 4001 -.fill ae01 -.fill 9800 -.fill 1dff -.fill 9180 .fill 10d0 .fill 11e7 .fill 6000 -.fill 6380 -.fill 1d81 -.fill 1010 -.fill 1dff -.fill 9180 -.fill 2180 -.fill 1181 .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 1c35 -.fill c300 -.fill 1d82 -.fill 4001 -.fill ae01 -.fill 9040 -.fill 1dff -.fill 9180 -.fill 4601 -.fill ae01 -.fill 1bee +.fill 21a3 .fill c300 .fill 1d81 .fill 4601 .fill ae01 -.fill 2fb7 +.fill 33f8 .fill b600 .fill 10d0 .fill 11e5 @@ -11896,14 +12990,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill aa04 .fill 4601 .fill ae01 -.fill 2fb2 +.fill 33f4 .fill b600 .fill 10d0 .fill 11e6 @@ -11915,7 +13009,7 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 7af0 +.fill 8153 .fill 1dff .fill 9180 .fill 10d0 @@ -11938,7 +13032,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -11956,7 +13050,7 @@ .fill aea3 .fill 4001 .fill ae01 -.fill 7af6 +.fill 8159 .fill 1dff .fill 9180 .fill 10d0 @@ -11979,7 +13073,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -11997,7 +13091,7 @@ .fill ae7a .fill 4001 .fill ae01 -.fill 7afe +.fill 8161 .fill 1dff .fill 9180 .fill 10d0 @@ -12020,7 +13114,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -12031,14 +13125,14 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 050e +.fill 050d .fill 6380 .fill 1d81 .fill 9040 .fill ae51 .fill 4001 .fill ae01 -.fill 7b08 +.fill 816b .fill 1dff .fill 9180 .fill 10d0 @@ -12061,7 +13155,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -12072,14 +13166,14 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 0545 +.fill 0543 .fill 6380 .fill 1d81 .fill 9040 .fill ae28 .fill 4001 .fill ae01 -.fill 7b12 +.fill 8175 .fill 1dff .fill 9180 .fill 10d0 @@ -12102,7 +13196,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -12130,32 +13224,29 @@ .fill 2180 .fill 1181 .fill 1080 -.fill a408 +.fill a407 .fill 4601 .fill ae01 -.fill 1006 +.fill 124d .fill c300 -.fill 1d80 .fill 2180 -.fill ae4d +.fill ae49 .fill ae00 .fill 4601 .fill ae01 -.fill 1044 +.fill 128d .fill c300 -.fill 1d80 .fill 4601 .fill ae01 -.fill 2a59 +.fill 2f06 .fill c300 -.fill 1d80 .fill 2180 .fill 11a9 .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 1bbe +.fill 1f71 .fill c300 .fill 1d81 .fill 10d0 @@ -12173,7 +13264,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -12185,15 +13276,14 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1bee +.fill 1f9e .fill c300 .fill 1d81 -.fill ae13 +.fill ae12 .fill 4601 .fill ae01 -.fill 1c6f +.fill 2025 .fill c300 -.fill 1d80 .fill 2180 .fill 1181 .fill 1dff @@ -12205,15 +13295,14 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1d1b +.fill 20c2 .fill c300 .fill 1d82 -.fill ae05 +.fill ae04 .fill 4601 .fill ae01 -.fill 1006 +.fill 124d .fill c300 -.fill 1d80 .fill 2180 .fill 1cd0 .fill 6b80 @@ -12226,22 +13315,22 @@ .fill 1dff .fill 9b80 .fill 1ae0 -.fill 1dfa +.fill 1de2 .fill 4001 .fill ae01 -.fill 7840 +.fill 7e86 .fill 6000 .fill 1080 .fill a406 .fill 2180 .fill 4601 .fill ae01 -.fill 36b9 +.fill 3b08 .fill b600 .fill ae00 .fill 4001 .fill ae01 -.fill 7844 +.fill 7e8a .fill 1dff .fill 9180 .fill 6000 @@ -12253,7 +13342,7 @@ .fill 10c0 .fill 4001 .fill ae01 -.fill 7844 +.fill 7e8a .fill 6000 .fill 1dff .fill 9180 @@ -12267,25 +13356,24 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7363 +.fill 79ab .fill c300 .fill 1d82 .fill 1080 -.fill a40b +.fill a40a .fill 4601 .fill ae01 -.fill 1006 +.fill 124d .fill c300 -.fill 1d80 .fill 2180 .fill 4601 .fill ae01 -.fill 36b9 +.fill 3b08 .fill b600 .fill ae00 .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 6000 .fill 1dff .fill 9180 @@ -12300,19 +13388,18 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 -.fill a457 +.fill a455 .fill 4601 .fill ae01 -.fill 1044 +.fill 128d .fill c300 -.fill 1d80 .fill 4001 .fill ae01 -.fill 7840 +.fill 7e86 .fill 6000 .fill 2380 .fill 3100 @@ -12327,7 +13414,7 @@ .fill a40e .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 6000 .fill 2380 .fill 3100 @@ -12344,7 +13431,7 @@ .fill a41e .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 6000 .fill 1dff .fill 9180 @@ -12359,7 +13446,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7404 +.fill 7a48 .fill c300 .fill 1d82 .fill 2380 @@ -12374,10 +13461,9 @@ .fill ae01 .fill 2180 .fill 1080 -.fill a403 -.fill cf65 -.fill 1d80 -.fill afbc +.fill a402 +.fill cf67 +.fill afbd .fill 4001 .fill ae01 .fill 007d @@ -12385,37 +13471,36 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1bbe +.fill 1f71 .fill c300 .fill 1d81 .fill 4601 .fill ae01 -.fill 36ac +.fill 3afb .fill b600 .fill 4001 .fill ae01 -.fill 7b1b +.fill 817e .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 1b72 +.fill 1f26 .fill c300 .fill 1d81 .fill 1080 .fill aa04 .fill 4601 .fill ae01 -.fill 31b6 +.fill 3623 .fill b600 .fill 4601 .fill ae01 -.fill 1044 +.fill 128d .fill c300 -.fill 1d80 .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 6000 .fill 1dff .fill 9180 @@ -12430,7 +13515,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7404 +.fill 7a48 .fill c300 .fill 1d82 .fill 1080 @@ -12457,7 +13542,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73b9 +.fill 79ff .fill c300 .fill 1d82 .fill 2380 @@ -12473,108 +13558,17 @@ .fill 2180 .fill 1181 .fill 1080 -.fill aa1d -.fill 4001 -.fill ae01 -.fill 7842 -.fill 6000 -.fill 1dff -.fill 9180 -.fill 2180 -.fill 1190 -.fill 6380 -.fill 1d81 -.fill 1dff -.fill 9180 -.fill 1dff -.fill 9380 +.fill a40a .fill 4601 .fill ae01 -.fill 73e4 +.fill 124d .fill c300 -.fill 1d82 -.fill 2380 -.fill 3100 -.fill 1181 -.fill 1010 -.fill aa02 -.fill 2180 -.fill ae02 -.fill 2180 -.fill 1181 -.fill ae02 -.fill 2180 -.fill 1181 -.fill 1080 -.fill aa22 -.fill 4001 -.fill ae01 -.fill e380 -.fill 1dff -.fill 9180 -.fill 4601 -.fill ae01 -.fill 1d6a -.fill c300 -.fill 1d81 -.fill 1dff -.fill 9180 -.fill 2180 -.fill 6380 -.fill 1d81 -.fill 1dff -.fill 9180 -.fill 1dff -.fill 9380 -.fill 4601 -.fill ae01 -.fill 73b9 -.fill c300 -.fill 1d82 -.fill 2380 -.fill 3100 -.fill 1181 -.fill 1010 -.fill aa02 -.fill 2180 -.fill ae02 -.fill 2180 -.fill 1181 -.fill ae02 -.fill 2180 -.fill 1181 -.fill 1080 -.fill a40b -.fill 4601 -.fill ae01 -.fill 1006 -.fill c300 -.fill 1d80 .fill 2180 .fill 4601 .fill ae01 -.fill 36b9 +.fill 3b08 .fill b600 .fill ae00 -.fill 10d0 -.fill 11ff -.fill 1dff -.fill 9180 -.fill 4001 -.fill ae01 -.fill 7842 -.fill 1dff -.fill 9180 -.fill 6000 -.fill 1880 -.fill 1181 -.fill 6380 -.fill 1d81 -.fill 9040 -.fill 10c0 -.fill 6380 -.fill 1d81 -.fill 9040 .fill 4001 .fill ae01 .fill e380 @@ -12599,6 +13593,128 @@ .fill e380 .fill 1dff .fill 9180 +.fill 10d0 +.fill 11e2 +.fill 1dff +.fill 9180 +.fill 4601 +.fill ae01 +.fill 03bd +.fill c300 +.fill 1d83 +.fill 4601 +.fill ae01 +.fill 128d +.fill c300 +.fill 4001 +.fill ae01 +.fill 7e88 +.fill 6000 +.fill 1dff +.fill 9180 +.fill 2180 +.fill 1190 +.fill 6380 +.fill 1d81 +.fill 1dff +.fill 9180 +.fill 1dff +.fill 9380 +.fill 4601 +.fill ae01 +.fill 7a29 +.fill c300 +.fill 1d82 +.fill 1080 +.fill aa21 +.fill 10d0 +.fill 11e2 +.fill 1dff +.fill 9180 +.fill 4601 +.fill ae01 +.fill 2109 +.fill c300 +.fill 1d81 +.fill 1dff +.fill 9180 +.fill 2180 +.fill 6380 +.fill 1d81 +.fill 1dff +.fill 9180 +.fill 1dff +.fill 9380 +.fill 4601 +.fill ae01 +.fill 79ff +.fill c300 +.fill 1d82 +.fill 2380 +.fill 3100 +.fill 1181 +.fill 1010 +.fill aa02 +.fill 2180 +.fill ae02 +.fill 2180 +.fill 1181 +.fill ae02 +.fill 2180 +.fill 1181 +.fill 1080 +.fill a40a +.fill 4601 +.fill ae01 +.fill 124d +.fill c300 +.fill 2180 +.fill 4601 +.fill ae01 +.fill 3b08 +.fill b600 +.fill ae00 +.fill 10d0 +.fill 11ff +.fill 1dff +.fill 9180 +.fill 4001 +.fill ae01 +.fill 7e88 +.fill 1dff +.fill 9180 +.fill 6000 +.fill 1880 +.fill 1181 +.fill 6380 +.fill 1d81 +.fill 9040 +.fill 10c0 +.fill 6380 +.fill 1d81 +.fill 9040 +.fill 10d0 +.fill 11e2 +.fill 1dff +.fill 9180 +.fill 4601 +.fill ae01 +.fill 0309 +.fill c300 +.fill 1d81 +.fill 1dff +.fill 9180 +.fill 2180 +.fill 1181 +.fill 6380 +.fill 1d81 +.fill 1010 +.fill 1dff +.fill 9180 +.fill 10d0 +.fill 11e2 +.fill 1dff +.fill 9180 .fill 4001 .fill ae01 .fill e200 @@ -12619,7 +13735,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7424 +.fill 7a67 .fill c300 .fill 1d82 .fill 6380 @@ -12632,14 +13748,9 @@ .fill 03bd .fill c300 .fill 1d83 -.fill 4601 -.fill ae01 -.fill 1044 -.fill c300 -.fill 1d80 .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 6000 .fill 1dff .fill 9180 @@ -12653,21 +13764,19 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 -.fill a40b +.fill a409 .fill 4601 .fill ae01 -.fill 1044 +.fill 128d .fill c300 -.fill 1d80 .fill 4601 .fill ae01 -.fill 2a59 +.fill 2f06 .fill c300 -.fill 1d80 .fill ae0b .fill 2180 .fill 1dff @@ -12677,74 +13786,97 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1c35 +.fill 1fec .fill c300 .fill 1d82 -.fill 4001 -.fill ae01 -.fill 9800 -.fill 1dff -.fill 9180 .fill 10d0 .fill 11ff .fill 6000 -.fill 6380 +.fill 1dff +.fill 9180 +.fill 4601 +.fill ae01 +.fill 21a3 +.fill c300 .fill 1d81 -.fill 1010 +.fill 4001 +.fill ae01 +.fill 7e84 +.fill 6000 .fill 1dff .fill 9180 .fill 2180 -.fill 1181 +.fill 11ac +.fill 6380 +.fill 1d81 .fill 1dff .fill 9180 +.fill 1dff +.fill 9380 .fill 4601 .fill ae01 -.fill 1c35 +.fill 7a48 .fill c300 .fill 1d82 -.fill 4001 -.fill ae01 -.fill 9040 -.fill 1dff -.fill 9180 +.fill 1080 +.fill a402 +.fill ae18 +.fill ae00 .fill 4601 .fill ae01 -.fill 1bee +.fill 128d .fill c300 -.fill 1d81 +.fill 4001 +.fill ae01 +.fill 7e86 +.fill 6000 +.fill 2380 +.fill 3100 +.fill 1181 +.fill 1010 +.fill a402 +.fill 2180 +.fill ae02 +.fill 2180 +.fill 1181 +.fill 1080 +.fill a404 +.fill 4601 +.fill ae01 +.fill 34bb +.fill b600 .fill 2180 .fill 11bb .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 1bbe +.fill 1f71 .fill c300 .fill 1d81 .fill 4601 .fill ae01 -.fill 36ac +.fill 3afb .fill b600 .fill 4001 .fill ae01 -.fill 7b1f +.fill 8182 .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 1b72 +.fill 1f26 .fill c300 .fill 1d81 .fill 1080 -.fill a474 +.fill a472 .fill 4601 .fill ae01 -.fill 1044 +.fill 128d .fill c300 -.fill 1d80 .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 6000 .fill 1dff .fill 9180 @@ -12758,7 +13890,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -12771,15 +13903,14 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1c35 +.fill 1fec .fill c300 .fill 1d82 -.fill ae05 +.fill ae04 .fill 4601 .fill ae01 -.fill 2a59 +.fill 2f06 .fill c300 -.fill 1d80 .fill 4001 .fill ae01 .fill 1cd0 @@ -12787,7 +13918,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1bee +.fill 1f9e .fill c300 .fill 1d81 .fill 4001 @@ -12797,7 +13928,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1bee +.fill 1f9e .fill c300 .fill 1d81 .fill 4001 @@ -12807,7 +13938,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1bee +.fill 1f9e .fill c300 .fill 1d81 .fill 4001 @@ -12817,7 +13948,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1bee +.fill 1f9e .fill c300 .fill 1d81 .fill 4001 @@ -12827,7 +13958,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1bee +.fill 1f9e .fill c300 .fill 1d81 .fill 4001 @@ -12837,7 +13968,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1bee +.fill 1f9e .fill c300 .fill 1d81 .fill 2180 @@ -12846,33 +13977,33 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1bbe +.fill 1f71 .fill c300 .fill 1d81 .fill 4601 .fill ae01 -.fill 36ac +.fill 3afb .fill b600 .fill 4001 .fill ae01 -.fill 7b26 +.fill 8189 .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 1b72 +.fill 1f26 .fill c300 .fill 1d81 .fill 1080 .fill aa14 .fill 4001 .fill ae01 -.fill 7b2c +.fill 818f .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 1b72 +.fill 1f26 .fill c300 .fill 1d81 .fill 2380 @@ -12888,19 +14019,19 @@ .fill 2180 .fill 1181 .fill 1080 -.fill a4d8 +.fill a4d6 .fill 10d0 .fill 11ff .fill 1dff .fill 9180 .fill 4001 .fill ae01 -.fill 7b2c +.fill 818f .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 1b72 +.fill 1f26 .fill c300 .fill 1d81 .fill 6380 @@ -12908,7 +14039,7 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 7846 +.fill 7e8c .fill 6000 .fill 2380 .fill 3100 @@ -12920,23 +14051,21 @@ .fill 2180 .fill 1181 .fill 1080 -.fill a40b +.fill a40a .fill 4601 .fill ae01 -.fill 1006 +.fill 124d .fill c300 -.fill 1d80 .fill 2180 .fill 4601 .fill ae01 -.fill 36b9 +.fill 3b08 .fill b600 .fill ae00 .fill 4601 .fill ae01 -.fill 1044 +.fill 128d .fill c300 -.fill 1d80 .fill 10d0 .fill 11fd .fill 1dff @@ -12946,7 +14075,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1ca5 +.fill 204d .fill c300 .fill 1d81 .fill 6380 @@ -12977,7 +14106,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7846 +.fill 7e8c .fill 6000 .fill 1dff .fill 9180 @@ -13002,7 +14131,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7846 +.fill 7e8c .fill 6000 .fill 1dff .fill 9180 @@ -13045,7 +14174,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7846 +.fill 7e8c .fill 6000 .fill 1dff .fill 9180 @@ -13070,7 +14199,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7846 +.fill 7e8c .fill 6000 .fill 1dff .fill 9180 @@ -13098,32 +14227,32 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1bbe +.fill 1f71 .fill c300 .fill 1d81 .fill 4601 .fill ae01 -.fill 36ac +.fill 3afb .fill b600 .fill 4001 .fill ae01 -.fill 7b35 +.fill 8198 .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 1b72 +.fill 1f26 .fill c300 .fill 1d81 .fill 1080 .fill aa04 .fill 4601 .fill ae01 -.fill 34b8 +.fill 3915 .fill b600 .fill 4001 .fill ae01 -.fill 7846 +.fill 7e8c .fill 6000 .fill 1dff .fill 9180 @@ -13137,39 +14266,37 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 -.fill a40b +.fill a40a .fill 4601 .fill ae01 -.fill 1006 +.fill 124d .fill c300 -.fill 1d80 .fill 2180 .fill 4601 .fill ae01 -.fill 36b9 +.fill 3b08 .fill b600 .fill ae00 .fill 4601 .fill ae01 -.fill 1044 +.fill 128d .fill c300 -.fill 1d80 .fill 2180 .fill 11a8 .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 1bbe +.fill 1f71 .fill c300 .fill 1d81 .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 6000 .fill 1dff .fill 9180 @@ -13183,33 +14310,31 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 -.fill a406 +.fill a405 .fill 4601 .fill ae01 -.fill 1044 +.fill 128d .fill c300 -.fill 1d80 -.fill ae02 -.fill cc32 -.fill 1d80 +.fill ae01 +.fill cc0d .fill 10d0 .fill 11fe .fill 1dff .fill 9180 .fill 4001 .fill ae01 -.fill 7841 +.fill 7e87 .fill 6000 .fill 6380 .fill 1d81 .fill 9040 .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 6000 .fill 1dff .fill 9180 @@ -13223,7 +14348,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -13237,22 +14362,21 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1c35 +.fill 1fec .fill c300 .fill 1d82 -.fill ae05 +.fill ae04 .fill 4601 .fill ae01 -.fill 2a59 +.fill 2f06 .fill c300 -.fill 1d80 .fill 2180 .fill 11bb .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 1bbe +.fill 1f71 .fill c300 .fill 1d81 .fill 10d0 @@ -13261,9 +14385,8 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1d49 +.fill 20ef .fill c300 -.fill 1d80 .fill 6380 .fill 1d81 .fill 9040 @@ -13276,7 +14399,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1ca5 +.fill 204d .fill c300 .fill 1d81 .fill 6380 @@ -13288,14 +14411,14 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7841 +.fill 7e87 .fill 6000 .fill 6380 .fill 1d81 .fill 9040 .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 6000 .fill 1dff .fill 9180 @@ -13309,16 +14432,15 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7404 +.fill 7a48 .fill c300 .fill 1d82 .fill 1080 -.fill a406 +.fill a405 .fill 4601 .fill ae01 -.fill 2adf +.fill 2f85 .fill c300 -.fill 1d80 .fill ae00 .fill 2180 .fill 11a9 @@ -13326,7 +14448,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1bbe +.fill 1f71 .fill c300 .fill 1d81 .fill 10d0 @@ -13336,7 +14458,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1ca5 +.fill 204d .fill c300 .fill 1d81 .fill 10d0 @@ -13346,7 +14468,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1ce2 +.fill 208a .fill c300 .fill 1d81 .fill 4001 @@ -13356,7 +14478,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7846 +.fill 7e8c .fill 6000 .fill 6380 .fill 1d81 @@ -13364,9 +14486,7 @@ .fill 1dff .fill 9180 .fill 2180 -.fill 1181 -.fill 3100 -.fill 1181 +.fill 11ff .fill 6380 .fill 1d81 .fill 9040 @@ -13377,7 +14497,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7846 +.fill 7e8c .fill 6000 .fill 6380 .fill 1d81 @@ -13385,15 +14505,13 @@ .fill 1dff .fill 9180 .fill 2180 -.fill 1181 -.fill 3100 -.fill 1181 +.fill 11ff .fill 6380 .fill 1d81 .fill 9040 .fill 4001 .fill ae01 -.fill 7846 +.fill 7e8c .fill 1dff .fill 9180 .fill 6000 @@ -13405,12 +14523,11 @@ .fill 10c0 .fill 4601 .fill ae01 -.fill 2fbe +.fill 33ff .fill c300 -.fill 1d80 .fill 4001 .fill ae01 -.fill 7846 +.fill 7e8c .fill 1dff .fill 9180 .fill 6000 @@ -13427,7 +14544,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1ca5 +.fill 204d .fill c300 .fill 1d81 .fill 10d0 @@ -13437,12 +14554,12 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1ce2 +.fill 208a .fill c300 .fill 1d81 .fill 4001 .fill ae01 -.fill 7841 +.fill 7e87 .fill 6000 .fill 1dff .fill 9180 @@ -13453,7 +14570,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7846 +.fill 7e8c .fill 6000 .fill 6380 .fill 1d81 @@ -13463,7 +14580,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 2a6c +.fill 2f12 .fill c300 .fill 1d82 .fill 10d0 @@ -13478,7 +14595,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7846 +.fill 7e8c .fill 6000 .fill 6380 .fill 1d81 @@ -13488,33 +14605,33 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 2a6c +.fill 2f12 .fill c300 .fill 1d82 .fill 4601 .fill ae01 -.fill 36ac +.fill 3afb .fill b600 .fill 4001 .fill ae01 -.fill 7b39 +.fill 819c .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 1b72 +.fill 1f26 .fill c300 .fill 1d81 .fill 1080 .fill aa14 .fill 4001 .fill ae01 -.fill 7b3c +.fill 819f .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 1b72 +.fill 1f26 .fill c300 .fill 1d81 .fill 2380 @@ -13533,7 +14650,7 @@ .fill aa04 .fill 4601 .fill ae01 -.fill 3623 +.fill 3a75 .fill b600 .fill 10d0 .fill 11ff @@ -13541,12 +14658,12 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7b3c +.fill 819f .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 1b72 +.fill 1f26 .fill c300 .fill 1d81 .fill 6380 @@ -13554,16 +14671,15 @@ .fill 9040 .fill 4601 .fill ae01 -.fill 1044 +.fill 128d .fill c300 -.fill 1d80 .fill 2180 .fill 11a8 .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 1bbe +.fill 1f71 .fill c300 .fill 1d81 .fill 10d0 @@ -13572,23 +14688,22 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7841 +.fill 7e87 .fill 6000 .fill 6380 .fill 1d81 .fill 9040 .fill 4601 .fill ae01 -.fill 2a59 +.fill 2f06 .fill c300 -.fill 1d80 .fill 2180 .fill 11a9 .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 1bbe +.fill 1f71 .fill c300 .fill 1d81 .fill 10d0 @@ -13597,9 +14712,8 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1d49 +.fill 20ef .fill c300 -.fill 1d80 .fill 6380 .fill 1d81 .fill 9040 @@ -13607,10 +14721,10 @@ .fill 11ff .fill 6000 .fill 1080 -.fill a457 +.fill a452 .fill 4001 .fill ae01 -.fill 7846 +.fill 7e8c .fill 6000 .fill 1dff .fill 9180 @@ -13624,20 +14738,19 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 -.fill a40b +.fill a40a .fill 4601 .fill ae01 -.fill 1006 +.fill 124d .fill c300 -.fill 1d80 .fill 2180 .fill 4601 .fill ae01 -.fill 36b9 +.fill 3b08 .fill b600 .fill ae00 .fill 4001 @@ -13647,7 +14760,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7846 +.fill 7e8c .fill 6000 .fill 6380 .fill 1d81 @@ -13655,9 +14768,7 @@ .fill 1dff .fill 9180 .fill 2180 -.fill 1181 -.fill 3100 -.fill 1181 +.fill 11ff .fill 6380 .fill 1d81 .fill 9040 @@ -13668,7 +14779,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7846 +.fill 7e8c .fill 6000 .fill 6380 .fill 1d81 @@ -13676,15 +14787,13 @@ .fill 1dff .fill 9180 .fill 2180 -.fill 1181 -.fill 3100 -.fill 1181 +.fill 11ff .fill 6380 .fill 1d81 .fill 9040 .fill 4001 .fill ae01 -.fill 7846 +.fill 7e8c .fill 1dff .fill 9180 .fill 6000 @@ -13697,9 +14806,8 @@ .fill ae00 .fill 4601 .fill ae01 -.fill 2fbe +.fill 33ff .fill c300 -.fill 1d80 .fill 10d0 .fill 11ff .fill 6000 @@ -13707,7 +14815,7 @@ .fill a454 .fill 4001 .fill ae01 -.fill 7846 +.fill 7e8c .fill 1dff .fill 9180 .fill 6000 @@ -13724,7 +14832,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1ca5 +.fill 204d .fill c300 .fill 1d81 .fill 10d0 @@ -13734,12 +14842,12 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1ce2 +.fill 208a .fill c300 .fill 1d81 .fill 4001 .fill ae01 -.fill 7841 +.fill 7e87 .fill 6000 .fill 1dff .fill 9180 @@ -13750,7 +14858,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7846 +.fill 7e8c .fill 6000 .fill 6380 .fill 1d81 @@ -13760,7 +14868,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 2a6c +.fill 2f12 .fill c300 .fill 1d82 .fill 10d0 @@ -13775,7 +14883,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7846 +.fill 7e8c .fill 6000 .fill 6380 .fill 1d81 @@ -13785,22 +14893,22 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 2a6c +.fill 2f12 .fill c300 .fill 1d82 -.fill ae44 +.fill ae42 .fill 4001 .fill ae01 -.fill 7b42 +.fill 81a5 .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 1b72 +.fill 1f26 .fill c300 .fill 1d81 .fill 1080 -.fill a42e +.fill a42c .fill 10d0 .fill 11fc .fill 1dff @@ -13810,7 +14918,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1ca5 +.fill 204d .fill c300 .fill 1d81 .fill 6380 @@ -13823,19 +14931,17 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1ce2 +.fill 208a .fill c300 .fill 1d81 .fill 4601 .fill ae01 -.fill 1044 +.fill 128d .fill c300 -.fill 1d80 .fill 4601 .fill ae01 -.fill 2fbe +.fill 33ff .fill c300 -.fill 1d80 .fill 10d0 .fill 11fc .fill 6000 @@ -13843,7 +14949,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1ce2 +.fill 208a .fill c300 .fill 1d81 .fill ae0a @@ -13854,13 +14960,13 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1ce2 +.fill 208a .fill c300 .fill 1d81 -.fill ae89 +.fill ae86 .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 6000 .fill 1dff .fill 9180 @@ -13875,14 +14981,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill aa1e .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 6000 .fill 1dff .fill 9180 @@ -13897,7 +15003,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -13916,7 +15022,7 @@ .fill aa1e .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 6000 .fill 1dff .fill 9180 @@ -13931,7 +15037,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -13947,25 +15053,24 @@ .fill 2180 .fill 1181 .fill 1080 -.fill a40f +.fill a40e .fill 4601 .fill ae01 -.fill 2adf +.fill 2f85 .fill c300 -.fill 1d80 .fill 2180 .fill 11bb .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 1bbe +.fill 1f71 .fill c300 .fill 1d81 -.fill ae20 +.fill ae1e .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 6000 .fill 1dff .fill 9180 @@ -13979,25 +15084,23 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 -.fill a406 +.fill a405 .fill 4601 .fill ae01 -.fill 1044 +.fill 128d .fill c300 -.fill 1d80 -.fill ae05 +.fill ae04 .fill 4601 .fill ae01 -.fill 1006 +.fill 124d .fill c300 -.fill 1d80 .fill 4001 .fill ae01 -.fill 7844 +.fill 7e8a .fill 1dff .fill 9180 .fill 6000 @@ -14031,7 +15134,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 096c +.fill 095c .fill c300 .fill 1d81 .fill 6380 @@ -14051,14 +15154,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 .fill aa16 .fill 4001 .fill ae01 -.fill 782d +.fill 7e73 .fill 1dff .fill 9180 .fill 10d0 @@ -14084,7 +15187,7 @@ .fill a410 .fill 4001 .fill ae01 -.fill 7b47 +.fill 81aa .fill 1dff .fill 9180 .fill 4601 @@ -14095,7 +15198,7 @@ .fill 2180 .fill 4601 .fill ae01 -.fill 3a4b +.fill 3eb9 .fill b600 .fill ae00 .fill 10d0 @@ -14135,7 +15238,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73b9 +.fill 79ff .fill c300 .fill 1d82 .fill 2380 @@ -14154,7 +15257,7 @@ .fill a410 .fill 4001 .fill ae01 -.fill 7b60 +.fill 81c3 .fill 1dff .fill 9180 .fill 4601 @@ -14165,7 +15268,7 @@ .fill 2180 .fill 4601 .fill ae01 -.fill 3a4b +.fill 3eb9 .fill b600 .fill ae00 .fill 10d0 @@ -14194,14 +15297,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a410 .fill 4001 .fill ae01 -.fill 7b78 +.fill 81db .fill 1dff .fill 9180 .fill 4601 @@ -14212,12 +15315,12 @@ .fill 2180 .fill 4601 .fill ae01 -.fill 3a4b +.fill 3eb9 .fill b600 .fill ae00 .fill 4001 .fill ae01 -.fill 783d +.fill 7e83 .fill 1dff .fill 9180 .fill 10d0 @@ -14227,7 +15330,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 0943 +.fill 0934 .fill c300 .fill 1d81 .fill 6380 @@ -14235,19 +15338,19 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 7845 +.fill 7e8b .fill 1dff .fill 9180 .fill 4001 .fill ae01 -.fill 783d +.fill 7e83 .fill 6000 .fill 6380 .fill 1d81 .fill 9040 .fill 4001 .fill ae01 -.fill 7840 +.fill 7e86 .fill 1dff .fill 9180 .fill 2180 @@ -14256,7 +15359,7 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 7841 +.fill 7e87 .fill 1dff .fill 9180 .fill 2180 @@ -14265,7 +15368,7 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 7842 +.fill 7e88 .fill 1dff .fill 9180 .fill 2180 @@ -14274,7 +15377,7 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 7843 +.fill 7e89 .fill 1dff .fill 9180 .fill 2180 @@ -14283,7 +15386,7 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 7844 +.fill 7e8a .fill 1dff .fill 9180 .fill 2180 @@ -14292,7 +15395,7 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 7846 +.fill 7e8c .fill 1dff .fill 9180 .fill 2180 @@ -14319,17 +15422,16 @@ .fill 1d83 .fill 4601 .fill ae01 -.fill 1044 +.fill 128d .fill c300 -.fill 1d80 .fill 4001 .fill ae01 -.fill 7b1b +.fill 817e .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 1b72 +.fill 1f26 .fill c300 .fill 1d81 .fill 2380 @@ -14342,26 +15444,24 @@ .fill 2180 .fill 1181 .fill 1080 -.fill a406 +.fill a405 .fill 4601 .fill ae01 -.fill 1006 +.fill 124d .fill c300 -.fill 1d80 -.fill ae05 +.fill ae04 .fill 4601 .fill ae01 -.fill 1044 +.fill 128d .fill c300 -.fill 1d80 .fill 4001 .fill ae01 -.fill 7bad +.fill 8210 .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 1b72 +.fill 1f26 .fill c300 .fill 1d81 .fill 2380 @@ -14374,44 +15474,41 @@ .fill 2180 .fill 1181 .fill 1080 -.fill a406 +.fill a405 .fill 4601 .fill ae01 -.fill 1006 +.fill 124d .fill c300 -.fill 1d80 -.fill ae05 +.fill ae04 .fill 4601 .fill ae01 -.fill 1044 +.fill 128d .fill c300 -.fill 1d80 .fill 2180 .fill 11a8 .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 1bbe +.fill 1f71 .fill c300 .fill 1d81 .fill 4001 .fill ae01 -.fill 7bb2 +.fill 8215 .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 1b72 +.fill 1f26 .fill c300 .fill 1d81 .fill 1080 -.fill a406 +.fill a405 .fill 4601 .fill ae01 -.fill 1044 +.fill 128d .fill c300 -.fill 1d80 .fill ae00 .fill 2180 .fill 11a9 @@ -14419,12 +15516,12 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1bbe +.fill 1f71 .fill c300 .fill 1d81 .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 6000 .fill 1dff .fill 9180 @@ -14439,16 +15536,15 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7404 +.fill 7a48 .fill c300 .fill 1d82 .fill 1080 -.fill a406 +.fill a405 .fill 4601 .fill ae01 -.fill 1006 +.fill 124d .fill c300 -.fill 1d80 .fill ae00 .fill 4001 .fill ae01 @@ -14457,7 +15553,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1bee +.fill 1f9e .fill c300 .fill 1d81 .fill 4001 @@ -14467,7 +15563,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1bee +.fill 1f9e .fill c300 .fill 1d81 .fill 4001 @@ -14477,7 +15573,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1bee +.fill 1f9e .fill c300 .fill 1d81 .fill 4001 @@ -14487,7 +15583,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1bee +.fill 1f9e .fill c300 .fill 1d81 .fill 4001 @@ -14497,25 +15593,23 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1bee +.fill 1f9e .fill c300 .fill 1d81 .fill 4601 .fill ae01 -.fill 2fbe +.fill 33ff .fill c300 -.fill 1d80 .fill 4001 .fill ae01 -.fill 783e +.fill 7e84 .fill 6000 .fill 1080 -.fill a406 +.fill a405 .fill 4601 .fill ae01 -.fill 1006 +.fill 124d .fill c300 -.fill 1d80 .fill ae00 .fill 2180 .fill 1dff @@ -14525,7 +15619,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1c35 +.fill 1fec .fill c300 .fill 1d82 .fill 4001 @@ -14535,7 +15629,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1bee +.fill 1f9e .fill c300 .fill 1d81 .fill 4001 @@ -14545,7 +15639,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1bee +.fill 1f9e .fill c300 .fill 1d81 .fill 4001 @@ -14555,7 +15649,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1bee +.fill 1f9e .fill c300 .fill 1d81 .fill 4001 @@ -14565,7 +15659,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1bee +.fill 1f9e .fill c300 .fill 1d81 .fill 4001 @@ -14575,7 +15669,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1bee +.fill 1f9e .fill c300 .fill 1d81 .fill 4001 @@ -14585,18 +15679,18 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 1bee +.fill 1f9e .fill c300 .fill 1d81 .fill 4001 .fill ae01 -.fill 7840 +.fill 7e86 .fill 6000 .fill 1080 -.fill a4d8 +.fill a4ec .fill 4001 .fill ae01 -.fill 7bb7 +.fill 821a .fill 1dff .fill 9180 .fill 4601 @@ -14606,18 +15700,38 @@ .fill 1d81 .fill 4001 .fill ae01 -.fill 7843 +.fill 7e89 .fill 6000 .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 050e +.fill 050d .fill c300 .fill 1d81 .fill 4001 .fill ae01 -.fill 7bd7 +.fill 823a +.fill 1dff +.fill 9180 +.fill 4601 +.fill ae01 +.fill 0458 +.fill c300 +.fill 1d81 +.fill 4001 +.fill ae01 +.fill e380 +.fill 1dff +.fill 9180 +.fill 4601 +.fill ae01 +.fill 0458 +.fill c300 +.fill 1d81 +.fill 4001 +.fill ae01 +.fill 8277 .fill 1dff .fill 9180 .fill 4601 @@ -14658,7 +15772,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7843 +.fill 7e89 .fill 6000 .fill 6380 .fill 1d81 @@ -14668,14 +15782,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 .fill a44a .fill 4001 .fill ae01 -.fill 7845 +.fill 7e8b .fill 6000 .fill 1dff .fill 9180 @@ -14698,7 +15812,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -14759,7 +15873,7 @@ .fill 1d81 .fill 4001 .fill ae01 -.fill 7c13 +.fill 827a .fill 1dff .fill 9180 .fill 4601 @@ -14774,12 +15888,12 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 050e +.fill 050d .fill c300 .fill 1d81 .fill 4001 .fill ae01 -.fill 7c1b +.fill 8282 .fill 1dff .fill 9180 .fill 4601 @@ -14794,12 +15908,12 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 050e +.fill 050d .fill c300 .fill 1d81 .fill 4001 .fill ae01 -.fill 7c25 +.fill 828c .fill 1dff .fill 9180 .fill 4601 @@ -14808,7 +15922,7 @@ .fill c300 .fill 1d81 .fill 2180 -.fill ae71 +.fill ae85 .fill ae00 .fill 10d0 .fill 11fe @@ -14820,7 +15934,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7841 +.fill 7e87 .fill 6000 .fill 1dff .fill 9180 @@ -14836,7 +15950,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 0b65 +.fill 0d94 .fill c300 .fill 1d84 .fill 6380 @@ -14856,46 +15970,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 .fill a40b .fill 4001 .fill ae01 -.fill 7c43 -.fill 1dff -.fill 9180 -.fill 4601 -.fill ae01 -.fill 0494 -.fill c300 -.fill 1d81 -.fill ae1f -.fill 4001 -.fill ae01 -.fill 7c71 -.fill 1dff -.fill 9180 -.fill 4601 -.fill ae01 -.fill 0458 -.fill c300 -.fill 1d81 -.fill 4001 -.fill ae01 -.fill 7841 -.fill 6000 -.fill 1dff -.fill 9180 -.fill 4601 -.fill ae01 -.fill 050e -.fill c300 -.fill 1d81 -.fill 4001 -.fill ae01 -.fill 7c7b +.fill 82aa .fill 1dff .fill 9180 .fill 4601 @@ -14903,6 +15985,7 @@ .fill 0494 .fill c300 .fill 1d81 +.fill ae00 .fill 10d0 .fill 11fe .fill 6000 @@ -14917,7 +16000,58 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73b9 +.fill 79ff +.fill c300 +.fill 1d82 +.fill 1080 +.fill a420 +.fill 4001 +.fill ae01 +.fill 82d8 +.fill 1dff +.fill 9180 +.fill 4601 +.fill ae01 +.fill 0458 +.fill c300 +.fill 1d81 +.fill 4001 +.fill ae01 +.fill 7e87 +.fill 6000 +.fill 1dff +.fill 9180 +.fill 4601 +.fill ae01 +.fill 050d +.fill c300 +.fill 1d81 +.fill 4001 +.fill ae01 +.fill 82e2 +.fill 1dff +.fill 9180 +.fill 4601 +.fill ae01 +.fill 0494 +.fill c300 +.fill 1d81 +.fill ae00 +.fill 10d0 +.fill 11fe +.fill 6000 +.fill 1dff +.fill 9180 +.fill 2180 +.fill 6380 +.fill 1d81 +.fill 1dff +.fill 9180 +.fill 1dff +.fill 9380 +.fill 4601 +.fill ae01 +.fill 79ff .fill c300 .fill 1d82 .fill ae01 @@ -14936,7 +16070,7 @@ .fill 1dff .fill 4001 .fill ae01 -.fill 784a +.fill 7e91 .fill 6000 .fill 6000 .fill 1dff @@ -14951,14 +16085,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a40d .fill 4001 .fill ae01 -.fill 784a +.fill 7e91 .fill 1dff .fill 9180 .fill 6000 @@ -14975,21 +16109,21 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 784a +.fill 7e91 .fill 6000 .fill 6380 .fill 1d81 .fill 9040 .fill 4001 .fill ae01 -.fill 784a +.fill 7e91 .fill 6000 .fill 6000 .fill 1080 .fill a41e .fill 4001 .fill ae01 -.fill 784a +.fill 7e91 .fill 6000 .fill 6000 .fill 1dff @@ -15004,7 +16138,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7404 +.fill 7a48 .fill c300 .fill 1d82 .fill 2380 @@ -15022,7 +16156,7 @@ .fill a40d .fill 4001 .fill ae01 -.fill 784a +.fill 7e91 .fill 1dff .fill 9180 .fill 6000 @@ -15035,14 +16169,14 @@ .fill afcb .fill 4001 .fill ae01 -.fill 784a +.fill 7e91 .fill 6000 .fill 6000 .fill 1080 .fill a417 .fill 4001 .fill ae01 -.fill 784a +.fill 7e91 .fill 6000 .fill 1dff .fill 9180 @@ -15052,7 +16186,7 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 784a +.fill 7e91 .fill 1dff .fill 9180 .fill 6000 @@ -15076,13 +16210,9 @@ .fill e000 .fill 1dff .fill 9f80 -.fill 1dff -.fill 9b80 -.fill 1ae0 -.fill 1d80 .fill 4001 .fill ae01 -.fill 784a +.fill 7e91 .fill 6000 .fill 6000 .fill 1dff @@ -15097,14 +16227,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a40d .fill 4001 .fill ae01 -.fill 784a +.fill 7e91 .fill 1dff .fill 9180 .fill 6000 @@ -15117,13 +16247,10 @@ .fill afdd .fill 4001 .fill ae01 -.fill 784a +.fill 7e91 .fill 6000 .fill ae01 .fill 2180 -.fill 1cd0 -.fill 6b80 -.fill 1d81 .fill 6f80 .fill 1d81 .fill e000 @@ -15135,7 +16262,7 @@ .fill 1dfa .fill 4001 .fill ae01 -.fill 784b +.fill 7e92 .fill 1dff .fill 9180 .fill 2180 @@ -15191,7 +16318,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -15239,7 +16366,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -15268,7 +16395,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -15297,7 +16424,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -15360,7 +16487,7 @@ .fill aa04 .fill 4601 .fill ae01 -.fill 3ec6 +.fill 4329 .fill b600 .fill 10d0 .fill 11fd @@ -15388,7 +16515,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73b9 +.fill 79ff .fill c300 .fill 1d82 .fill 1080 @@ -15408,7 +16535,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 738e +.fill 79d5 .fill c300 .fill 1d82 .fill 2380 @@ -15460,7 +16587,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73b9 +.fill 79ff .fill c300 .fill 1d82 .fill 1080 @@ -15481,7 +16608,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 738e +.fill 79d5 .fill c300 .fill 1d82 .fill 2380 @@ -15541,7 +16668,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73b9 +.fill 79ff .fill c300 .fill 1d82 .fill 1080 @@ -15562,7 +16689,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 738e +.fill 79d5 .fill c300 .fill 1d82 .fill 2380 @@ -15609,7 +16736,7 @@ .fill 2180 .fill 4601 .fill ae01 -.fill 3f15 +.fill 4378 .fill b600 .fill 10d0 .fill 11fd @@ -15627,7 +16754,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73b9 +.fill 79ff .fill c300 .fill 1d82 .fill 1080 @@ -15635,7 +16762,7 @@ .fill 2180 .fill 4601 .fill ae01 -.fill 3f15 +.fill 4378 .fill b600 .fill ae00 .fill 10d0 @@ -15653,7 +16780,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -15673,7 +16800,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -15681,7 +16808,7 @@ .fill 2180 .fill 4601 .fill ae01 -.fill 3f15 +.fill 4378 .fill b600 .fill ae00 .fill 10d0 @@ -15703,7 +16830,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7424 +.fill 7a67 .fill c300 .fill 1d82 .fill 1dff @@ -15719,7 +16846,7 @@ .fill 9040 .fill 4601 .fill ae01 -.fill 3eac +.fill 430f .fill b600 .fill 10d0 .fill 11ff @@ -15749,7 +16876,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 @@ -15770,7 +16897,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7363 +.fill 79ab .fill c300 .fill 1d82 .fill 2380 @@ -15803,7 +16930,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -15823,7 +16950,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7363 +.fill 79ab .fill c300 .fill 1d82 .fill 2380 @@ -15854,7 +16981,7 @@ .fill 2180 .fill 4601 .fill ae01 -.fill 3f15 +.fill 4378 .fill b600 .fill ae00 .fill 10d0 @@ -15876,7 +17003,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7424 +.fill 7a67 .fill c300 .fill 1d82 .fill 1dff @@ -15890,7 +17017,7 @@ .fill 6380 .fill 1d81 .fill 9040 -.fill ae98 +.fill ae94 .fill 10d0 .fill 11fa .fill 1dff @@ -15922,9 +17049,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 0ccc -.fill 3100 -.fill 1181 +.fill f334 .fill 6380 .fill 1d81 .fill 1dff @@ -15933,11 +17058,11 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 -.fill aa3f +.fill aa3d .fill 10d0 .fill 11fc .fill 6000 @@ -15945,9 +17070,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 0ccc -.fill 3100 -.fill 1181 +.fill f334 .fill 6380 .fill 1d81 .fill 1dff @@ -15956,7 +17079,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -15977,7 +17100,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7363 +.fill 79ab .fill c300 .fill 1d82 .fill 2380 @@ -16027,7 +17150,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7424 +.fill 7a67 .fill c300 .fill 1d82 .fill 1dff @@ -16067,7 +17190,7 @@ .fill 10c0 .fill 4601 .fill ae01 -.fill 3bf9 +.fill 4060 .fill b600 .fill 10d0 .fill 11fb @@ -16088,7 +17211,7 @@ .fill ae00 .fill 4001 .fill ae01 -.fill 784b +.fill 7e92 .fill 1dff .fill 9180 .fill 2180 @@ -16111,7 +17234,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -16175,16 +17298,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 -.fill a406 +.fill a404 .fill 2180 -.fill 1181 -.fill 3100 -.fill 1181 -.fill ae9d +.fill 11ff +.fill ae9b .fill ae00 .fill 10d0 .fill 11fe @@ -16210,7 +17331,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7847 +.fill 7e8e .fill 6000 .fill 6380 .fill 1d81 @@ -16220,7 +17341,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 @@ -16241,7 +17362,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 2380 @@ -16281,7 +17402,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -16326,7 +17447,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -16334,12 +17455,10 @@ .fill 10d0 .fill 11ff .fill 6000 -.fill ae07 +.fill ae05 .fill ae00 .fill 2180 -.fill 1181 -.fill 3100 -.fill 1181 +.fill 11ff .fill ae01 .fill 2180 .fill 1cd0 @@ -16353,7 +17472,6 @@ .fill 1dff .fill 9b80 .fill 1ae0 -.fill 1d80 .fill 10d0 .fill 1182 .fill 6000 @@ -16361,7 +17479,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7847 +.fill 7e8e .fill 6000 .fill 6380 .fill 1d81 @@ -16371,7 +17489,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 @@ -16400,7 +17518,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7404 +.fill 7a48 .fill c300 .fill 1d82 .fill 2380 @@ -16435,7 +17553,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7847 +.fill 7e8e .fill 6000 .fill 6380 .fill 1d81 @@ -16445,7 +17563,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 @@ -16503,7 +17621,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7847 +.fill 7e8e .fill 6000 .fill 6380 .fill 1d81 @@ -16513,7 +17631,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 @@ -16525,12 +17643,12 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 050e +.fill 050d .fill c300 .fill 1d81 .fill 4001 .fill ae01 -.fill 7c83 +.fill 82ea .fill 1dff .fill 9180 .fill 4601 @@ -16545,7 +17663,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7847 +.fill 7e8e .fill 6000 .fill 6380 .fill 1d81 @@ -16555,7 +17673,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 @@ -16584,7 +17702,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7404 +.fill 7a48 .fill c300 .fill 1d82 .fill 2380 @@ -16629,7 +17747,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7847 +.fill 7e8e .fill 6000 .fill 6380 .fill 1d81 @@ -16639,7 +17757,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 @@ -16673,7 +17791,7 @@ .fill af51 .fill 4001 .fill ae01 -.fill 7847 +.fill 7e8e .fill 6000 .fill 2380 .fill 3100 @@ -16688,7 +17806,7 @@ .fill a40b .fill 4001 .fill ae01 -.fill 7c86 +.fill 82ed .fill 1dff .fill 9180 .fill 4601 @@ -16721,7 +17839,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 096c +.fill 095c .fill c300 .fill 1d81 .fill 6380 @@ -16741,14 +17859,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 .fill a414 .fill 4001 .fill ae01 -.fill 7847 +.fill 7e8e .fill 6000 .fill 1dff .fill 9180 @@ -16761,7 +17879,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7404 +.fill 7a48 .fill c300 .fill 1d82 .fill ae27 @@ -16773,7 +17891,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 0943 +.fill 0934 .fill c300 .fill 1d81 .fill 1dff @@ -16799,7 +17917,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7404 +.fill 7a48 .fill c300 .fill 1d82 .fill ae01 @@ -16873,7 +17991,7 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 7847 +.fill 7e8e .fill 6000 .fill 1dff .fill 9180 @@ -16896,14 +18014,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73b9 +.fill 79ff .fill c300 .fill 1d82 .fill 1080 .fill a410 .fill 4001 .fill ae01 -.fill 7c8e +.fill 82f5 .fill 1dff .fill 9180 .fill 4601 @@ -16914,12 +18032,12 @@ .fill 2180 .fill 4601 .fill ae01 -.fill 4363 +.fill 47c1 .fill b600 .fill ae00 .fill 4001 .fill ae01 -.fill 7847 +.fill 7e8e .fill 6000 .fill 1dff .fill 9180 @@ -16947,19 +18065,19 @@ .fill 1d83 .fill 4001 .fill ae01 -.fill 7848 +.fill 7e8f .fill 1dff .fill 9180 .fill 4001 .fill ae01 -.fill 7847 +.fill 7e8e .fill 6000 .fill 6380 .fill 1d81 .fill 9040 .fill 4001 .fill ae01 -.fill 7849 +.fill 7e90 .fill 1dff .fill 9180 .fill 2180 @@ -16981,7 +18099,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7363 +.fill 79ab .fill c300 .fill 1d82 .fill 1080 @@ -16992,7 +18110,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7847 +.fill 7e8e .fill 6000 .fill 6380 .fill 1d81 @@ -17013,7 +18131,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73b9 +.fill 79ff .fill c300 .fill 1d82 .fill 1080 @@ -17084,7 +18202,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7847 +.fill 7e8e .fill 6000 .fill 6380 .fill 1d81 @@ -17094,7 +18212,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 738e +.fill 79d5 .fill c300 .fill 1d82 .fill 1080 @@ -17228,12 +18346,12 @@ .fill ae00 .fill 4001 .fill ae01 -.fill 7847 +.fill 7e8e .fill 1dff .fill 9180 .fill 4001 .fill ae01 -.fill 7847 +.fill 7e8e .fill 6000 .fill 1dff .fill 9180 @@ -17261,13 +18379,12 @@ .fill 1dff .fill 9b80 .fill 1ae0 -.fill 1d80 .fill 2180 .fill 1dff .fill 9180 .fill 4001 .fill ae01 -.fill 7847 +.fill 7e8e .fill 6000 .fill 1dff .fill 9180 @@ -17283,7 +18400,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 0b65 +.fill 0d94 .fill c300 .fill 1d84 .fill 1dff @@ -17297,14 +18414,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 .fill a40d .fill 4001 .fill ae01 -.fill 7caf +.fill 8316 .fill 1dff .fill 9180 .fill 4601 @@ -17317,7 +18434,7 @@ .fill ae00 .fill 4001 .fill ae01 -.fill 7cc1 +.fill 8328 .fill 1dff .fill 9180 .fill 4601 @@ -17366,7 +18483,7 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 7847 +.fill 7e8e .fill 6000 .fill 1080 .fill a42f @@ -17377,7 +18494,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7847 +.fill 7e8e .fill 6000 .fill 1dff .fill 9180 @@ -17404,7 +18521,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7404 +.fill 7a48 .fill c300 .fill 1d82 .fill 2380 @@ -17490,17 +18607,17 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7847 +.fill 7e8e .fill 6000 .fill 1dff .fill 9180 .fill 4001 .fill ae01 -.fill 7847 +.fill 7e8e .fill 6000 .fill 1dff .fill 9180 -.fill cd4d +.fill cd4e .fill 1d84 .fill ae17 .fill 2180 @@ -17514,17 +18631,17 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7847 +.fill 7e8e .fill 6000 .fill 1dff .fill 9180 .fill 4001 .fill ae01 -.fill 7847 +.fill 7e8e .fill 6000 .fill 1dff .fill 9180 -.fill cd35 +.fill cd36 .fill 1d84 .fill 2180 .fill 1cd0 @@ -17576,7 +18693,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73b9 +.fill 79ff .fill c300 .fill 1d82 .fill 2380 @@ -17595,7 +18712,7 @@ .fill a410 .fill 4001 .fill ae01 -.fill 7cc8 +.fill 832f .fill 1dff .fill 9180 .fill 4601 @@ -17606,7 +18723,7 @@ .fill 2180 .fill 4601 .fill ae01 -.fill 4b8e +.fill 4fe1 .fill b600 .fill ae00 .fill 10d0 @@ -17620,7 +18737,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 096c +.fill 095c .fill c300 .fill 1d81 .fill 6380 @@ -17640,14 +18757,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73b9 +.fill 79ff .fill c300 .fill 1d82 .fill 1080 .fill a416 .fill 4001 .fill ae01 -.fill 782d +.fill 7e73 .fill 1dff .fill 9180 .fill 10d0 @@ -17672,7 +18789,7 @@ .fill a410 .fill 4001 .fill ae01 -.fill 7cdb +.fill 8342 .fill 1dff .fill 9180 .fill 4601 @@ -17683,12 +18800,12 @@ .fill 2180 .fill 4601 .fill ae01 -.fill 4b8e +.fill 4fe1 .fill b600 .fill ae00 .fill 4001 .fill ae01 -.fill 7847 +.fill 7e8e .fill 1dff .fill 9180 .fill 2180 @@ -17697,7 +18814,7 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 7849 +.fill 7e90 .fill 1dff .fill 9180 .fill 2180 @@ -17718,19 +18835,19 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73b9 +.fill 79ff .fill c300 .fill 1d82 .fill 1080 .fill a431 .fill 4001 .fill ae01 -.fill 7847 +.fill 7e8e .fill 1dff .fill 9180 .fill 4001 .fill ae01 -.fill 7825 +.fill 7e6b .fill 1dff .fill 9180 .fill 10d0 @@ -17745,7 +18862,7 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 7847 +.fill 7e8e .fill 6000 .fill 1dff .fill 9180 @@ -17756,7 +18873,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 0943 +.fill 0934 .fill c300 .fill 1d81 .fill 1dff @@ -17779,7 +18896,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7847 +.fill 7e8e .fill 6000 .fill 6380 .fill 1d81 @@ -17800,18 +18917,18 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 6c3e +.fill 728e .fill c300 .fill 1d81 .fill 2180 .fill 4601 .fill ae01 -.fill 4b8e +.fill 4fe1 .fill b600 .fill ae00 .fill 4001 .fill ae01 -.fill 7cf9 +.fill 8360 .fill 1dff .fill 9180 .fill 4601 @@ -17821,7 +18938,7 @@ .fill 1d81 .fill 4001 .fill ae01 -.fill 7d40 +.fill 83a7 .fill 1dff .fill 9180 .fill 4601 @@ -17831,7 +18948,7 @@ .fill 1d81 .fill 4001 .fill ae01 -.fill 7d8d +.fill 83f4 .fill 1dff .fill 9180 .fill 4601 @@ -17841,20 +18958,19 @@ .fill 1d81 .fill 4601 .fill ae01 -.fill 405a +.fill 44b8 .fill c300 -.fill 1d80 .fill 2180 .fill 1181 .fill 1080 .fill aa04 .fill 4601 .fill ae01 -.fill 4b8d +.fill 4fe0 .fill b600 .fill 4001 .fill ae01 -.fill 7dd3 +.fill 843a .fill 1dff .fill 9180 .fill 4601 @@ -17878,7 +18994,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 062f +.fill 062d .fill c300 .fill 1d82 .fill 6380 @@ -17890,9 +19006,7 @@ .fill 1dff .fill 9180 .fill 2180 -.fill 1182 -.fill 3100 -.fill 1181 +.fill 11fe .fill 6380 .fill 1d81 .fill 1dff @@ -17901,14 +19015,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a410 .fill 4001 .fill ae01 -.fill 7dda +.fill 8441 .fill 1dff .fill 9180 .fill 4601 @@ -17919,7 +19033,7 @@ .fill 2180 .fill 4601 .fill ae01 -.fill 4b8e +.fill 4fe1 .fill b600 .fill ae00 .fill 10d0 @@ -17936,14 +19050,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 .fill a40f .fill 4001 .fill ae01 -.fill 7df1 +.fill 8458 .fill 1dff .fill 9180 .fill 4601 @@ -17953,12 +19067,12 @@ .fill 1d81 .fill 4601 .fill ae01 -.fill 4b89 +.fill 4fdc .fill b600 .fill ae00 .fill 4001 .fill ae01 -.fill 7e11 +.fill 8478 .fill 1dff .fill 9180 .fill 4001 @@ -17982,14 +19096,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill aa27 .fill 4001 .fill ae01 -.fill 7e13 +.fill 847a .fill 1dff .fill 9180 .fill 4001 @@ -18013,7 +19127,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -18035,23 +19149,23 @@ .fill 6000 .fill 1dff .fill 9180 -.fill ccf4 +.fill ccf8 .fill 1d81 .fill 1080 .fill a406 .fill 2180 .fill 4601 .fill ae01 -.fill 4b8e +.fill 4fe1 .fill b600 .fill ae00 .fill 4601 .fill ae01 -.fill 4b89 +.fill 4fdc .fill b600 .fill 4001 .fill ae01 -.fill 7e17 +.fill 847e .fill 1dff .fill 9180 .fill 4001 @@ -18075,14 +19189,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a413 .fill 4001 .fill ae01 -.fill 7e1b +.fill 8482 .fill 1dff .fill 9180 .fill 4601 @@ -18093,15 +19207,15 @@ .fill 2180 .fill 4601 .fill ae01 -.fill 4b8e +.fill 4fe1 .fill b600 .fill 4601 .fill ae01 -.fill 4b89 +.fill 4fdc .fill b600 .fill 4001 .fill ae01 -.fill 7e36 +.fill 849d .fill 1dff .fill 9180 .fill 4001 @@ -18125,7 +19239,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -18137,14 +19251,14 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 4141 +.fill 459f .fill c300 .fill 1d81 .fill 1080 .fill a40b .fill 4001 .fill ae01 -.fill 7e39 +.fill 84a0 .fill 1dff .fill 9180 .fill 4601 @@ -18156,15 +19270,15 @@ .fill 2180 .fill 4601 .fill ae01 -.fill 4b8e +.fill 4fe1 .fill b600 .fill 4601 .fill ae01 -.fill 4b89 +.fill 4fdc .fill b600 .fill 4001 .fill ae01 -.fill 7e6d +.fill 84d4 .fill 1dff .fill 9180 .fill 4001 @@ -18188,23 +19302,22 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 -.fill a409 +.fill a408 .fill 4601 .fill ae01 -.fill 405a +.fill 44b8 .fill c300 -.fill 1d80 .fill 4601 .fill ae01 -.fill 4b89 +.fill 4fdc .fill b600 .fill 4001 .fill ae01 -.fill 7e70 +.fill 84d7 .fill 1dff .fill 9180 .fill 4001 @@ -18228,7 +19341,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -18238,15 +19351,15 @@ .fill 6000 .fill 1dff .fill 9180 -.fill cc29 +.fill cc2e .fill 1d81 .fill 4601 .fill ae01 -.fill 4b89 +.fill 4fdc .fill b600 .fill 4001 .fill ae01 -.fill 7e73 +.fill 84da .fill 1dff .fill 9180 .fill 4001 @@ -18270,14 +19383,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a4e2 .fill 4001 .fill ae01 -.fill 7849 +.fill 7e90 .fill 6000 .fill 2380 .fill 3100 @@ -18292,7 +19405,7 @@ .fill a40b .fill 4001 .fill ae01 -.fill 7e76 +.fill 84dd .fill 1dff .fill 9180 .fill 4601 @@ -18307,14 +19420,14 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7847 +.fill 7e8e .fill 6000 .fill 6380 .fill 1d81 .fill 9040 .fill 4001 .fill ae01 -.fill 7848 +.fill 7e8f .fill 6000 .fill 1dff .fill 9180 @@ -18329,7 +19442,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7363 +.fill 79ab .fill c300 .fill 1d82 .fill 1080 @@ -18340,7 +19453,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7848 +.fill 7e8f .fill 6000 .fill 6380 .fill 1d81 @@ -18370,7 +19483,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 738e +.fill 79d5 .fill c300 .fill 1d82 .fill 1080 @@ -18459,26 +19572,26 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7847 +.fill 7e8e .fill 6000 .fill 6380 .fill 1d81 .fill 9040 .fill 4001 .fill ae01 -.fill 7847 +.fill 7e8e .fill 1dff .fill 9180 .fill 4001 .fill ae01 -.fill 7848 +.fill 7e8f .fill 6000 .fill 6380 .fill 1d81 .fill 9040 .fill 4001 .fill ae01 -.fill 7848 +.fill 7e8f .fill 1dff .fill 9180 .fill 10d0 @@ -18489,7 +19602,7 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 7e87 +.fill 84ee .fill 1dff .fill 9180 .fill 4601 @@ -18499,7 +19612,7 @@ .fill 1d81 .fill 4601 .fill ae01 -.fill 4b89 +.fill 4fdc .fill b600 .fill 4001 .fill ae01 @@ -18523,18 +19636,18 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill aa04 .fill 4601 .fill ae01 -.fill 4b7f +.fill 4fd2 .fill b600 .fill 4001 .fill ae01 -.fill 784a +.fill 7e91 .fill 1dff .fill 9180 .fill 4001 @@ -18549,15 +19662,14 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 3a51 +.fill 3ebf .fill c300 -.fill 1d80 .fill 6380 .fill 1d81 .fill 9040 .fill 4001 .fill ae01 -.fill 7e6d +.fill 84d4 .fill 1dff .fill 9180 .fill 10d0 @@ -18581,14 +19693,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill aa04 .fill 4601 .fill ae01 -.fill 49d2 +.fill 4e28 .fill b600 .fill 10d0 .fill 11fd @@ -18596,14 +19708,13 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 3a51 +.fill 3ebf .fill c300 -.fill 1d80 .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 3b18 +.fill 3f7f .fill c300 .fill 1d81 .fill 6380 @@ -18620,7 +19731,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 3f1b +.fill 437e .fill c300 .fill 1d81 .fill 6380 @@ -18628,7 +19739,7 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 784b +.fill 7e92 .fill 6000 .fill 2380 .fill 3100 @@ -18655,7 +19766,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 2380 @@ -18679,7 +19790,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7847 +.fill 7e8e .fill 6000 .fill 6380 .fill 1d81 @@ -18689,7 +19800,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -18705,12 +19816,11 @@ .fill 2180 .fill 1181 .fill 1080 -.fill aa10 +.fill aa0f .fill 4601 .fill ae01 -.fill 3a51 +.fill 3ebf .fill c300 -.fill 1d80 .fill 6000 .fill 2380 .fill 3100 @@ -18728,7 +19838,7 @@ .fill a40f .fill 4001 .fill ae01 -.fill 7ead +.fill 8514 .fill 1dff .fill 9180 .fill 4601 @@ -18738,7 +19848,7 @@ .fill 1d81 .fill 4601 .fill ae01 -.fill 4b89 +.fill 4fdc .fill b600 .fill ae00 .fill 10d0 @@ -18748,12 +19858,12 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 050e +.fill 050d .fill c300 .fill 1d81 .fill 4001 .fill ae01 -.fill 7c83 +.fill 82ea .fill 1dff .fill 9180 .fill 4601 @@ -18772,7 +19882,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 3fdd +.fill 443c .fill c300 .fill 1d81 .fill 6380 @@ -18804,7 +19914,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 @@ -18872,7 +19982,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7404 +.fill 7a48 .fill c300 .fill 1d82 .fill 2380 @@ -18894,12 +20004,12 @@ .fill ae00 .fill 4601 .fill ae01 -.fill 4b89 +.fill 4fdc .fill b600 .fill ae00 .fill 4001 .fill ae01 -.fill 7ed3 +.fill 853a .fill 1dff .fill 9180 .fill 10d0 @@ -18923,31 +20033,30 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 -.fill a411 +.fill a410 .fill 4601 .fill ae01 -.fill 3ae3 +.fill 3f51 .fill c300 -.fill 1d80 .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 43b8 +.fill 4815 .fill c300 .fill 1d81 .fill 4601 .fill ae01 -.fill 4b89 +.fill 4fdc .fill b600 .fill ae00 .fill 4001 .fill ae01 -.fill 7ed6 +.fill 853d .fill 1dff .fill 9180 .fill 10d0 @@ -18964,7 +20073,7 @@ .fill a419 .fill 4001 .fill ae01 -.fill 7ed9 +.fill 8540 .fill 1dff .fill 9180 .fill 10d0 @@ -18992,7 +20101,7 @@ .fill a419 .fill 4001 .fill ae01 -.fill 7edc +.fill 8543 .fill 1dff .fill 9180 .fill 10d0 @@ -19020,7 +20129,7 @@ .fill a40f .fill 4001 .fill ae01 -.fill 7edf +.fill 8546 .fill 1dff .fill 9180 .fill 4601 @@ -19030,7 +20139,7 @@ .fill 1d81 .fill 4601 .fill ae01 -.fill 4b89 +.fill 4fdc .fill b600 .fill ae00 .fill 10d0 @@ -19039,14 +20148,13 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 3a51 +.fill 3ebf .fill c300 -.fill 1d80 .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 3b18 +.fill 3f7f .fill c300 .fill 1d81 .fill 6380 @@ -19058,9 +20166,8 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 3ae3 +.fill 3f51 .fill c300 -.fill 1d80 .fill 6380 .fill 1d81 .fill 9040 @@ -19075,7 +20182,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 3f1b +.fill 437e .fill c300 .fill 1d81 .fill 6380 @@ -19083,7 +20190,7 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 784b +.fill 7e92 .fill 6000 .fill 2380 .fill 3100 @@ -19110,7 +20217,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 2380 @@ -19134,7 +20241,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7847 +.fill 7e8e .fill 6000 .fill 6380 .fill 1d81 @@ -19144,14 +20251,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a419 .fill 4001 .fill ae01 -.fill 7ed6 +.fill 853d .fill 1dff .fill 9180 .fill 10d0 @@ -19191,7 +20298,7 @@ .fill a40c .fill 4001 .fill ae01 -.fill 7ef7 +.fill 855e .fill 1dff .fill 9180 .fill 4601 @@ -19213,7 +20320,7 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 7ed6 +.fill 853d .fill 1dff .fill 9180 .fill 10d0 @@ -19239,7 +20346,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 3fdd +.fill 443c .fill c300 .fill 1d81 .fill 6380 @@ -19248,7 +20355,7 @@ .fill ae00 .fill 4001 .fill ae01 -.fill 7edc +.fill 8543 .fill 1dff .fill 9180 .fill 10d0 @@ -19272,7 +20379,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -19282,7 +20389,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7f0c +.fill 8573 .fill 1dff .fill 9180 .fill 10d0 @@ -19297,7 +20404,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 41ab +.fill 4609 .fill c300 .fill 1d84 .fill ae18 @@ -19322,7 +20429,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 41ab +.fill 4609 .fill c300 .fill 1d84 .fill ae0a @@ -19333,12 +20440,12 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 43b8 +.fill 4815 .fill c300 .fill 1d81 .fill 4601 .fill ae01 -.fill 45b5 +.fill 4a11 .fill b600 .fill 2180 .fill 1cd0 @@ -19367,7 +20474,7 @@ .fill 2180 .fill 1181 .fill 1080 -.fill a492 +.fill a491 .fill 10d0 .fill 4401 .fill ae01 @@ -19377,9 +20484,8 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 3a51 +.fill 3ebf .fill c300 -.fill 1d80 .fill 6380 .fill 1d81 .fill 9040 @@ -19417,7 +20523,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 3b18 +.fill 3f7f .fill c300 .fill 1d81 .fill 6380 @@ -19425,7 +20531,7 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 784b +.fill 7e92 .fill 6000 .fill 2380 .fill 3100 @@ -19454,7 +20560,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -19473,7 +20579,7 @@ .fill a40d .fill 4001 .fill ae01 -.fill 7f0d +.fill 8574 .fill 1dff .fill 9180 .fill 4601 @@ -19513,7 +20619,7 @@ .fill 6380 .fill 1d81 .fill 9040 -.fill af6a +.fill af6b .fill 10d0 .fill 11fe .fill 6000 @@ -19530,7 +20636,7 @@ .fill a40d .fill 4001 .fill ae01 -.fill 7f24 +.fill 858b .fill 1dff .fill 9180 .fill 4601 @@ -19568,7 +20674,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 0b65 +.fill 0d94 .fill c300 .fill 1d84 .fill 6380 @@ -19588,14 +20694,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 .fill a40b .fill 4001 .fill ae01 -.fill 7f59 +.fill 85c0 .fill 1dff .fill 9180 .fill 4601 @@ -19606,7 +20712,7 @@ .fill ae0a .fill 4001 .fill ae01 -.fill 7f75 +.fill 85dc .fill 1dff .fill 9180 .fill 4601 @@ -19638,7 +20744,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 096c +.fill 095c .fill c300 .fill 1d81 .fill 6380 @@ -19658,14 +20764,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 .fill aa1f .fill 4001 .fill ae01 -.fill 782d +.fill 7e73 .fill 1dff .fill 9180 .fill 10d0 @@ -19700,7 +20806,7 @@ .fill a40d .fill 4001 .fill ae01 -.fill 7f7d +.fill 85e4 .fill 1dff .fill 9180 .fill 4601 @@ -19709,7 +20815,7 @@ .fill c300 .fill 1d81 .fill 2180 -.fill aea6 +.fill aea2 .fill ae00 .fill 10d0 .fill 11fd @@ -19717,13 +20823,13 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 9000 +.fill a000 .fill 6380 .fill 1d81 .fill 9040 .fill 4001 .fill ae01 -.fill 3000 +.fill 2000 .fill 1dff .fill 9180 .fill 2180 @@ -19741,7 +20847,7 @@ .fill 1d83 .fill 4001 .fill ae01 -.fill 7825 +.fill 7e6b .fill 1dff .fill 9180 .fill 10d0 @@ -19760,7 +20866,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 0943 +.fill 0934 .fill c300 .fill 1d81 .fill 1dff @@ -19781,7 +20887,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 9000 +.fill a000 .fill f600 .fill 6380 .fill 1d81 @@ -19792,9 +20898,7 @@ .fill 1dff .fill 9180 .fill 2180 -.fill 1182 -.fill 3100 -.fill 1181 +.fill 11fe .fill 6380 .fill 1d81 .fill 1dff @@ -19803,14 +20907,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a40b .fill 4001 .fill ae01 -.fill 7fa6 +.fill 8618 .fill 1dff .fill 9180 .fill 4601 @@ -19818,16 +20922,14 @@ .fill 0494 .fill c300 .fill 1d81 -.fill ae38 +.fill ae36 .fill 10d0 .fill 11fe .fill 6000 .fill 1dff .fill 9180 .fill 2180 -.fill 1183 -.fill 3100 -.fill 1181 +.fill 11fd .fill 6380 .fill 1d81 .fill 1dff @@ -19836,14 +20938,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a40b .fill 4001 .fill ae01 -.fill 7fc5 +.fill 8637 .fill 1dff .fill 9180 .fill 4601 @@ -19854,7 +20956,7 @@ .fill ae17 .fill 4001 .fill ae01 -.fill 7fe8 +.fill 865a .fill 1dff .fill 9180 .fill 4601 @@ -19869,7 +20971,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 050e +.fill 050d .fill c300 .fill 1d81 .fill 2180 @@ -19887,81 +20989,380 @@ .fill 1dff .fill 9b80 .fill 1ae0 -.fill 1d80 -.fill 4001 -.fill ae01 -.fill 7fee +.fill 1df9 +.fill 10d0 +.fill 11ff +.fill 1dff +.fill 9180 +.fill 10d0 +.fill 1183 +.fill 6000 .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 0458 +.fill 0b4d .fill c300 .fill 1d81 +.fill 6380 +.fill 1d81 +.fill 9040 +.fill 10d0 +.fill 11ff +.fill 6000 +.fill 1dff +.fill 9180 +.fill 2180 +.fill 6380 +.fill 1d81 +.fill 1dff +.fill 9180 +.fill 1dff +.fill 9380 +.fill 4601 +.fill ae01 +.fill 7981 +.fill c300 +.fill 1d82 +.fill 1080 +.fill a410 .fill 4001 .fill ae01 -.fill c000 +.fill 8660 .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 0545 +.fill 0494 .fill c300 .fill 1d81 +.fill 2180 +.fill 4601 +.fill ae01 +.fill 540e +.fill b600 +.fill ae00 +.fill 10d0 +.fill 11f9 +.fill 1dff +.fill 9180 +.fill 2180 +.fill 6380 +.fill 1d81 +.fill 9040 +.fill 10d0 +.fill 11fa +.fill 1dff +.fill 9180 +.fill 2180 +.fill 6380 +.fill 1d81 +.fill 9040 +.fill 10d0 +.fill 11fa +.fill 6000 +.fill 1dff +.fill 9180 +.fill 2180 +.fill 1188 +.fill 6380 +.fill 1d81 +.fill 1dff +.fill 9180 +.fill 1dff +.fill 9380 +.fill 4601 +.fill ae01 +.fill 7981 +.fill c300 +.fill 1d82 +.fill 1080 +.fill a45b .fill 4001 .fill ae01 -.fill 7ff4 +.fill 7e7b +.fill 1dff +.fill 9180 +.fill 10d0 +.fill 11fa +.fill 6000 +.fill 6380 +.fill 1d81 +.fill 1010 +.fill 6000 +.fill 1080 +.fill a41d +.fill 10d0 +.fill 11fa +.fill 6000 +.fill 1dff +.fill 9180 +.fill 10d0 +.fill 11ff +.fill 6000 +.fill 6380 +.fill 1d81 +.fill 1dff +.fill 9180 +.fill 1dff +.fill 9380 +.fill 4601 +.fill ae01 +.fill 7a48 +.fill c300 +.fill 1d82 +.fill 2380 +.fill 3100 +.fill 1181 +.fill 1010 +.fill aa02 +.fill 2180 +.fill ae02 +.fill 2180 +.fill 1181 +.fill ae01 +.fill 2180 +.fill 1080 +.fill a421 +.fill 10d0 +.fill 11f9 +.fill 1dff +.fill 9180 +.fill 6000 +.fill 1dff +.fill 9180 +.fill 4001 +.fill ae01 +.fill 7e6b +.fill 1dff +.fill 9180 +.fill 10d0 +.fill 11fa +.fill 6000 +.fill 6380 +.fill 1d81 +.fill 1010 +.fill 6000 +.fill 1dff +.fill 9180 +.fill 2180 +.fill 1181 +.fill 6380 +.fill 1d81 +.fill 1010 +.fill 6380 +.fill 1d81 +.fill 1010 +.fill 6380 +.fill 1d81 +.fill 9040 +.fill ae00 +.fill 10d0 +.fill 11fa +.fill 1dff +.fill 9180 +.fill 6000 +.fill 1880 +.fill 1181 +.fill 6380 +.fill 1d81 +.fill 9040 +.fill 10c0 +.fill af91 +.fill 10d0 +.fill 11fc +.fill 1dff +.fill 9180 +.fill 2180 +.fill 6380 +.fill 1d81 +.fill 1010 +.fill 1dff +.fill 9180 +.fill 10d0 +.fill 1182 +.fill 6000 +.fill 6380 +.fill 1d81 +.fill 9040 +.fill 10d0 +.fill 11fc +.fill 1dff +.fill 9180 +.fill 2180 +.fill 1181 +.fill 6380 +.fill 1d81 +.fill 1010 +.fill 1dff +.fill 9180 +.fill 10d0 +.fill 11ff +.fill 6000 .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 0458 +.fill 0934 .fill c300 .fill 1d81 -.fill 4001 -.fill ae01 -.fill dfff +.fill 6380 +.fill 1d81 +.fill 9040 +.fill 10d0 +.fill 11fc .fill 1dff .fill 9180 -.fill 4601 -.fill ae01 -.fill 0545 -.fill c300 +.fill 2180 +.fill 1182 +.fill 6380 .fill 1d81 -.fill 4001 -.fill ae01 -.fill 7ff7 -.fill 1dff -.fill 9180 -.fill 4601 -.fill ae01 -.fill 0458 -.fill c300 -.fill 1d81 -.fill 4001 -.fill ae01 -.fill 2000 +.fill 1010 .fill 1dff .fill 9180 .fill 4001 .fill ae01 -.fill 7750 +.fill 0200 +.fill 1dff +.fill 9180 +.fill 10d0 +.fill 11f9 .fill 6000 .fill 6380 .fill 1d81 .fill 3100 .fill 1181 .fill 1010 +.fill 6380 +.fill 1d81 +.fill 9040 +.fill 10d0 +.fill 11fb +.fill 1dff +.fill 9180 +.fill 10d0 +.fill 11fc +.fill fe00 +.fill 6380 +.fill 1d81 +.fill 9040 +.fill 10d0 +.fill 11fb +.fill 6000 +.fill 1dff +.fill 9180 +.fill 2180 +.fill 6380 +.fill 1d81 +.fill 1dff +.fill 9180 +.fill 1dff +.fill 9380 +.fill 4601 +.fill ae01 +.fill 7981 +.fill c300 +.fill 1d82 +.fill 1080 +.fill a496 +.fill 4001 +.fill ae01 +.fill 7e7b +.fill 1dff +.fill 9180 +.fill 10d0 +.fill 11ff +.fill 6000 +.fill 6380 +.fill 1d81 +.fill 1010 +.fill 1dff +.fill 9180 +.fill 2180 +.fill 6380 +.fill 1d81 +.fill 9040 +.fill 4001 +.fill ae01 +.fill 7e6b +.fill 1dff +.fill 9180 +.fill 10d0 +.fill 11ff +.fill 6000 +.fill 6380 +.fill 1d81 +.fill 1010 +.fill 1dff +.fill 9180 +.fill 2180 +.fill 6380 +.fill 1d81 +.fill 9040 +.fill 4001 +.fill ae01 +.fill 7e73 +.fill 1dff +.fill 9180 +.fill 10d0 +.fill 11ff +.fill 6000 +.fill 6380 +.fill 1d81 +.fill 1010 +.fill 1dff +.fill 9180 +.fill 2180 +.fill 6380 +.fill 1d81 +.fill 9040 +.fill 2180 +.fill 1198 +.fill 1dff +.fill 9180 +.fill 2180 +.fill 1dff +.fill 9180 +.fill 10d0 +.fill 11ff +.fill 6000 .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 050e +.fill 090d .fill c300 .fill 1d81 +.fill 1dff +.fill 9180 +.fill 4601 +.fill ae01 +.fill 040f +.fill c300 +.fill 1d83 +.fill 10d0 +.fill 11fb +.fill 6000 +.fill 1dff +.fill 9180 +.fill 2180 +.fill 11ff +.fill 6380 +.fill 1d81 +.fill 1dff +.fill 9180 +.fill 1dff +.fill 9380 +.fill 4601 +.fill ae01 +.fill 7a29 +.fill c300 +.fill 1d82 +.fill 1080 +.fill a40b .fill 4001 .fill ae01 -.fill 7fff +.fill 86a6 .fill 1dff .fill 9180 .fill 4601 @@ -19969,9 +21370,125 @@ .fill 0494 .fill c300 .fill 1d81 +.fill ae29 +.fill 10d0 +.fill 11fb +.fill 6000 +.fill 1dff +.fill 9180 +.fill 2180 +.fill 11fb +.fill 6380 +.fill 1d81 +.fill 1dff +.fill 9180 +.fill 1dff +.fill 9380 +.fill 4601 +.fill ae01 +.fill 7a29 +.fill c300 +.fill 1d82 +.fill 1080 +.fill a40b .fill 4001 .fill ae01 -.fill 8006 +.fill 86c7 +.fill 1dff +.fill 9180 +.fill 4601 +.fill ae01 +.fill 0494 +.fill c300 +.fill 1d81 +.fill ae0a +.fill 4001 +.fill ae01 +.fill 86fb +.fill 1dff +.fill 9180 +.fill 4601 +.fill ae01 +.fill 0494 +.fill c300 +.fill 1d81 +.fill 2180 +.fill ae67 +.fill ae00 +.fill 10d0 +.fill 11ff +.fill 6000 +.fill 1dff +.fill 9180 +.fill 4601 +.fill ae01 +.fill 0934 +.fill c300 +.fill 1d81 +.fill 1dff +.fill 9180 +.fill 10d0 +.fill 11fb +.fill 6000 +.fill 6380 +.fill 1d81 +.fill 1010 +.fill 1dff +.fill 9180 +.fill 2180 +.fill 6380 +.fill 1d81 +.fill 9040 +.fill 4001 +.fill ae01 +.fill 7e6b +.fill 1dff +.fill 9180 +.fill 10d0 +.fill 11ff +.fill 6000 +.fill 6380 +.fill 1d81 +.fill 1010 +.fill 1dff +.fill 9180 +.fill 10d0 +.fill 11fb +.fill 6000 +.fill 6380 +.fill 1d81 +.fill 9040 +.fill 4001 +.fill ae01 +.fill 7e73 +.fill 1dff +.fill 9180 +.fill 10d0 +.fill 11ff +.fill 6000 +.fill 6380 +.fill 1d81 +.fill 1010 +.fill 1dff +.fill 9180 +.fill 2180 +.fill 1183 +.fill 6380 +.fill 1d81 +.fill 9040 +.fill 4001 +.fill ae01 +.fill 8737 +.fill 1dff +.fill 9180 +.fill 4601 +.fill ae01 +.fill 0458 +.fill c300 +.fill 1d81 +.fill 10d0 +.fill 1183 +.fill 6000 .fill 1dff .fill 9180 .fill 4601 @@ -19981,17 +21498,7 @@ .fill 1d81 .fill 4001 .fill ae01 -.fill 9000 -.fill 1dff -.fill 9180 -.fill 4601 -.fill ae01 -.fill 0545 -.fill c300 -.fill 1d81 -.fill 4001 -.fill ae01 -.fill 7ff4 +.fill 874f .fill 1dff .fill 9180 .fill 4601 @@ -19999,29 +21506,9 @@ .fill 0458 .fill c300 .fill 1d81 -.fill 4001 -.fill ae01 -.fill bfff -.fill 1dff -.fill 9180 -.fill 4601 -.fill ae01 -.fill 0545 -.fill c300 -.fill 1d81 -.fill 4001 -.fill ae01 -.fill 7f0c -.fill 1dff -.fill 9180 -.fill 4601 -.fill ae01 -.fill 0494 -.fill c300 -.fill 1d81 -.fill 4001 -.fill ae01 -.fill 8010 +.fill 10d0 +.fill 1183 +.fill 6000 .fill 1dff .fill 9180 .fill 4601 @@ -20038,13 +21525,168 @@ .fill e000 .fill 1dff .fill 9f80 +.fill 4001 +.fill ae01 +.fill 8763 +.fill 1dff +.fill 9180 +.fill 4601 +.fill ae01 +.fill 0458 +.fill c300 +.fill 1d81 +.fill 4001 +.fill ae01 +.fill c000 +.fill 1dff +.fill 9180 +.fill 4601 +.fill ae01 +.fill 0543 +.fill c300 +.fill 1d81 +.fill 4001 +.fill ae01 +.fill 8769 +.fill 1dff +.fill 9180 +.fill 4601 +.fill ae01 +.fill 0458 +.fill c300 +.fill 1d81 +.fill 4001 +.fill ae01 +.fill e000 +.fill 1dff +.fill 9180 +.fill 2180 +.fill 1181 +.fill 6380 +.fill 1d81 +.fill 3100 +.fill 1181 +.fill 1010 +.fill 1dff +.fill 9180 +.fill 4601 +.fill ae01 +.fill 0543 +.fill c300 +.fill 1d81 +.fill 4001 +.fill ae01 +.fill 876c +.fill 1dff +.fill 9180 +.fill 4601 +.fill ae01 +.fill 0458 +.fill c300 +.fill 1d81 +.fill 4001 +.fill ae01 +.fill 2000 +.fill 1dff +.fill 9180 +.fill 4001 +.fill ae01 +.fill 7d96 +.fill 6000 +.fill 6380 +.fill 1d81 +.fill 3100 +.fill 1181 +.fill 1010 +.fill 1dff +.fill 9180 +.fill 4601 +.fill ae01 +.fill 050d +.fill c300 +.fill 1d81 +.fill 4001 +.fill ae01 +.fill 8774 +.fill 1dff +.fill 9180 +.fill 4601 +.fill ae01 +.fill 0494 +.fill c300 +.fill 1d81 +.fill 4001 +.fill ae01 +.fill 877b +.fill 1dff +.fill 9180 +.fill 4601 +.fill ae01 +.fill 0458 +.fill c300 +.fill 1d81 +.fill 4001 +.fill ae01 +.fill a000 +.fill 1dff +.fill 9180 +.fill 4601 +.fill ae01 +.fill 0543 +.fill c300 +.fill 1d81 +.fill 4001 +.fill ae01 +.fill 8769 +.fill 1dff +.fill 9180 +.fill 4601 +.fill ae01 +.fill 0458 +.fill c300 +.fill 1d81 +.fill 4001 +.fill ae01 +.fill bfff +.fill 1dff +.fill 9180 +.fill 4601 +.fill ae01 +.fill 0543 +.fill c300 +.fill 1d81 +.fill 4001 +.fill ae01 +.fill 8573 +.fill 1dff +.fill 9180 +.fill 4601 +.fill ae01 +.fill 0494 +.fill c300 +.fill 1d81 +.fill 4001 +.fill ae01 +.fill 8785 +.fill 1dff +.fill 9180 +.fill 4601 +.fill ae01 +.fill 0494 +.fill c300 +.fill 1d81 +.fill 2180 +.fill 6f80 +.fill 1d81 +.fill e000 +.fill 1dff +.fill 9f80 .fill 1dff .fill 9b80 .fill 1ae0 -.fill 1d80 .fill 4001 .fill ae01 -.fill 8044 +.fill 87b9 .fill 1dff .fill 9180 .fill 10d0 @@ -20068,14 +21710,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill aa27 .fill 4001 .fill ae01 -.fill 8049 +.fill 87be .fill 1dff .fill 9180 .fill 10d0 @@ -20099,7 +21741,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -20118,7 +21760,7 @@ .fill a410 .fill 4001 .fill ae01 -.fill 8051 +.fill 87c6 .fill 1dff .fill 9180 .fill 4601 @@ -20129,12 +21771,12 @@ .fill 2180 .fill 4601 .fill ae01 -.fill 5244 +.fill 58ae .fill b600 .fill ae00 .fill 4001 .fill ae01 -.fill 812b +.fill 88a0 .fill 1dff .fill 9180 .fill 10d0 @@ -20158,14 +21800,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a40e .fill 4001 .fill ae01 -.fill 8130 +.fill 88a5 .fill 1dff .fill 9180 .fill 4601 @@ -20175,11 +21817,11 @@ .fill 1d81 .fill 4601 .fill ae01 -.fill 5243 +.fill 58ad .fill b600 .fill 4001 .fill ae01 -.fill 81c1 +.fill 8936 .fill 1dff .fill 9180 .fill 10d0 @@ -20203,14 +21845,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill aa27 .fill 4001 .fill ae01 -.fill 81c4 +.fill 8939 .fill 1dff .fill 9180 .fill 10d0 @@ -20234,7 +21876,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -20253,7 +21895,7 @@ .fill a40e .fill 4001 .fill ae01 -.fill 81c7 +.fill 893c .fill 1dff .fill 9180 .fill 4601 @@ -20263,11 +21905,11 @@ .fill 1d81 .fill 4601 .fill ae01 -.fill 5243 +.fill 58ad .fill b600 .fill 4001 .fill ae01 -.fill 827a +.fill 89ef .fill 1dff .fill 9180 .fill 10d0 @@ -20291,14 +21933,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a40e .fill 4001 .fill ae01 -.fill 8280 +.fill 89f5 .fill 1dff .fill 9180 .fill 4601 @@ -20308,11 +21950,11 @@ .fill 1d81 .fill 4601 .fill ae01 -.fill 5243 +.fill 58ad .fill b600 .fill 4001 .fill ae01 -.fill 8329 +.fill 8a9e .fill 1dff .fill 9180 .fill 10d0 @@ -20336,14 +21978,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a40e .fill 4001 .fill ae01 -.fill 832e +.fill 8aa3 .fill 1dff .fill 9180 .fill 4601 @@ -20353,11 +21995,11 @@ .fill 1d81 .fill 4601 .fill ae01 -.fill 5243 +.fill 58ad .fill b600 .fill 4001 .fill ae01 -.fill 838b +.fill 8b00 .fill 1dff .fill 9180 .fill 10d0 @@ -20381,14 +22023,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill aa27 .fill 4001 .fill ae01 -.fill 838e +.fill 8b03 .fill 1dff .fill 9180 .fill 10d0 @@ -20412,7 +22054,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -20431,7 +22073,7 @@ .fill aa27 .fill 4001 .fill ae01 -.fill 8392 +.fill 8b07 .fill 1dff .fill 9180 .fill 10d0 @@ -20455,7 +22097,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -20474,7 +22116,7 @@ .fill a40e .fill 4001 .fill ae01 -.fill 8397 +.fill 8b0c .fill 1dff .fill 9180 .fill 4601 @@ -20484,11 +22126,11 @@ .fill 1d81 .fill 4601 .fill ae01 -.fill 5243 +.fill 58ad .fill b600 .fill 4001 .fill ae01 -.fill 8408 +.fill 8b7d .fill 1dff .fill 9180 .fill 10d0 @@ -20512,14 +22154,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill aa27 .fill 4001 .fill ae01 -.fill 7aaa +.fill 810d .fill 1dff .fill 9180 .fill 10d0 @@ -20543,7 +22185,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -20562,7 +22204,7 @@ .fill aa27 .fill 4001 .fill ae01 -.fill 7a3a +.fill 809d .fill 1dff .fill 9180 .fill 10d0 @@ -20586,7 +22228,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -20605,7 +22247,7 @@ .fill a40e .fill 4001 .fill ae01 -.fill 840d +.fill 8b82 .fill 1dff .fill 9180 .fill 4601 @@ -20615,11 +22257,11 @@ .fill 1d81 .fill 4601 .fill ae01 -.fill 5243 +.fill 58ad .fill b600 .fill 4001 .fill ae01 -.fill 84b0 +.fill 8c25 .fill 1dff .fill 9180 .fill 10d0 @@ -20643,14 +22285,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a40e .fill 4001 .fill ae01 -.fill 84b4 +.fill 8c29 .fill 1dff .fill 9180 .fill 4601 @@ -20660,11 +22302,11 @@ .fill 1d81 .fill 4601 .fill ae01 -.fill 5243 +.fill 58ad .fill b600 .fill 4001 .fill ae01 -.fill 8542 +.fill 8cb7 .fill 1dff .fill 9180 .fill 10d0 @@ -20688,14 +22330,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a40e .fill 4001 .fill ae01 -.fill 8547 +.fill 8cbc .fill 1dff .fill 9180 .fill 4601 @@ -20705,11 +22347,11 @@ .fill 1d81 .fill 4601 .fill ae01 -.fill 5243 +.fill 58ad .fill b600 .fill 4001 .fill ae01 -.fill 85ce +.fill 8d43 .fill 1dff .fill 9180 .fill 10d0 @@ -20733,14 +22375,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill aa27 .fill 4001 .fill ae01 -.fill 85d3 +.fill 8d48 .fill 1dff .fill 9180 .fill 10d0 @@ -20764,7 +22406,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -20783,7 +22425,7 @@ .fill a40e .fill 4001 .fill ae01 -.fill 85d8 +.fill 8d4d .fill 1dff .fill 9180 .fill 4601 @@ -20793,11 +22435,11 @@ .fill 1d81 .fill 4601 .fill ae01 -.fill 5243 +.fill 58ad .fill b600 .fill 4001 .fill ae01 -.fill 868f +.fill 8dfe .fill 1dff .fill 9180 .fill 10d0 @@ -20821,14 +22463,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill aa27 .fill 4001 .fill ae01 -.fill 8695 +.fill 8e04 .fill 1dff .fill 9180 .fill 10d0 @@ -20852,7 +22494,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -20871,7 +22513,7 @@ .fill a40b .fill 4001 .fill ae01 -.fill 8699 +.fill 8e08 .fill 1dff .fill 9180 .fill 4601 @@ -20882,7 +22524,7 @@ .fill aeb2 .fill 4001 .fill ae01 -.fill 8726 +.fill 8e8d .fill 1dff .fill 9180 .fill 10d0 @@ -20906,14 +22548,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a40b .fill 4001 .fill ae01 -.fill 872b +.fill 8e92 .fill 1dff .fill 9180 .fill 4601 @@ -20924,7 +22566,7 @@ .fill ae88 .fill 4001 .fill ae01 -.fill 8755 +.fill 8ebc .fill 1dff .fill 9180 .fill 10d0 @@ -20948,14 +22590,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a40b .fill 4001 .fill ae01 -.fill 875b +.fill 8ec2 .fill 1dff .fill 9180 .fill 4601 @@ -20966,7 +22608,7 @@ .fill ae5e .fill 4001 .fill ae01 -.fill 8799 +.fill 8f00 .fill 1dff .fill 9180 .fill 10d0 @@ -20990,14 +22632,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a40b .fill 4001 .fill ae01 -.fill 879e +.fill 8f05 .fill 1dff .fill 9180 .fill 4601 @@ -21008,7 +22650,7 @@ .fill ae34 .fill 4001 .fill ae01 -.fill 87f9 +.fill 8f60 .fill 1dff .fill 9180 .fill 10d0 @@ -21032,14 +22674,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a40b .fill 4001 .fill ae01 -.fill 87fe +.fill 8f65 .fill 1dff .fill 9180 .fill 4601 @@ -21050,7 +22692,7 @@ .fill ae0a .fill 4001 .fill ae01 -.fill 8856 +.fill 8fbd .fill 1dff .fill 9180 .fill 4601 @@ -21073,7 +22715,7 @@ .fill 1dfa .fill 4001 .fill ae01 -.fill 784a +.fill 7e91 .fill 1dff .fill 9180 .fill 10d0 @@ -21088,9 +22730,8 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 3a51 +.fill 3ebf .fill c300 -.fill 1d80 .fill 6380 .fill 1d81 .fill 9040 @@ -21112,12 +22753,12 @@ .fill 2180 .fill 4601 .fill ae01 -.fill 5a96 +.fill 60fa .fill b600 .fill ae00 .fill 4001 .fill ae01 -.fill 87f9 +.fill 8f60 .fill 1dff .fill 9180 .fill 10d0 @@ -21141,20 +22782,19 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 -.fill a48a +.fill a489 .fill 10d0 .fill 11fe .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 3a51 +.fill 3ebf .fill c300 -.fill 1d80 .fill 6380 .fill 1d81 .fill 9040 @@ -21171,18 +22811,18 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 4e45 +.fill 54b0 .fill c300 .fill 1d81 .fill 2180 .fill 4601 .fill ae01 -.fill 5a96 +.fill 60fa .fill b600 .fill ae00 .fill 4001 .fill ae01 -.fill 888f +.fill 8ff6 .fill 1dff .fill 9180 .fill 4601 @@ -21192,7 +22832,7 @@ .fill 1d81 .fill 4001 .fill ae01 -.fill 88b5 +.fill 901c .fill 1dff .fill 9180 .fill 4601 @@ -21202,7 +22842,7 @@ .fill 1d81 .fill 4001 .fill ae01 -.fill 88e5 +.fill 904c .fill 1dff .fill 9180 .fill 4601 @@ -21212,7 +22852,7 @@ .fill 1d81 .fill 4001 .fill ae01 -.fill 891f +.fill 9086 .fill 1dff .fill 9180 .fill 4601 @@ -21222,7 +22862,7 @@ .fill 1d81 .fill 4001 .fill ae01 -.fill 895e +.fill 90c5 .fill 1dff .fill 9180 .fill 4601 @@ -21232,7 +22872,7 @@ .fill 1d81 .fill 4001 .fill ae01 -.fill 89a8 +.fill 910f .fill 1dff .fill 9180 .fill 4601 @@ -21242,7 +22882,7 @@ .fill 1d81 .fill 4001 .fill ae01 -.fill 89ea +.fill 9151 .fill 1dff .fill 9180 .fill 4601 @@ -21252,7 +22892,7 @@ .fill 1d81 .fill 4001 .fill ae01 -.fill 8a1a +.fill 9181 .fill 1dff .fill 9180 .fill 4601 @@ -21262,7 +22902,7 @@ .fill 1d81 .fill 4001 .fill ae01 -.fill 8a5a +.fill 91c1 .fill 1dff .fill 9180 .fill 4601 @@ -21272,7 +22912,7 @@ .fill 1d81 .fill 4001 .fill ae01 -.fill 8aa2 +.fill 9209 .fill 1dff .fill 9180 .fill 4601 @@ -21282,11 +22922,11 @@ .fill 1d81 .fill 4601 .fill ae01 -.fill 5a95 +.fill 60f9 .fill b600 .fill 4001 .fill ae01 -.fill 8044 +.fill 87b9 .fill 1dff .fill 9180 .fill 10d0 @@ -21310,22 +22950,21 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 -.fill a41f +.fill a41e .fill 4601 .fill ae01 -.fill 3a51 +.fill 3ebf .fill c300 -.fill 1d80 .fill 6000 .fill 1080 .fill a40b .fill 4001 .fill ae01 -.fill 8af0 +.fill 9257 .fill 1dff .fill 9180 .fill 4601 @@ -21339,16 +22978,16 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 0834 +.fill 0828 .fill c300 .fill 1d81 .fill 4601 .fill ae01 -.fill 5a95 +.fill 60f9 .fill b600 .fill 4001 .fill ae01 -.fill 8049 +.fill 87be .fill 1dff .fill 9180 .fill 10d0 @@ -21372,21 +23011,20 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 -.fill a43f +.fill a43d .fill 4001 .fill ae01 -.fill 8b0c +.fill 9273 .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 3a51 +.fill 3ebf .fill c300 -.fill 1d80 .fill 1dff .fill 9180 .fill 4601 @@ -21395,12 +23033,11 @@ .fill c300 .fill 1d82 .fill 1080 -.fill aa10 +.fill aa0f .fill 4601 .fill ae01 -.fill 3a51 +.fill 3ebf .fill c300 -.fill 1d80 .fill 6000 .fill 2380 .fill 3100 @@ -21418,7 +23055,7 @@ .fill a40b .fill 4001 .fill ae01 -.fill 8b10 +.fill 9277 .fill 1dff .fill 9180 .fill 4601 @@ -21433,16 +23070,16 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 0834 +.fill 0828 .fill c300 .fill 1d81 .fill 4601 .fill ae01 -.fill 5a95 +.fill 60f9 .fill b600 .fill 4001 .fill ae01 -.fill 8726 +.fill 8e8d .fill 1dff .fill 9180 .fill 10d0 @@ -21466,16 +23103,15 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 -.fill a410 +.fill a40f .fill 4601 .fill ae01 -.fill 3ae3 +.fill 3f51 .fill c300 -.fill 1d80 .fill 1dff .fill 9180 .fill 4601 @@ -21485,11 +23121,11 @@ .fill 1d81 .fill 4601 .fill ae01 -.fill 5a95 +.fill 60f9 .fill b600 .fill 4001 .fill ae01 -.fill 8755 +.fill 8ebc .fill 1dff .fill 9180 .fill 10d0 @@ -21513,14 +23149,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a40e .fill 4001 .fill ae01 -.fill 8b59 +.fill 92c0 .fill 1dff .fill 9180 .fill 4601 @@ -21530,11 +23166,11 @@ .fill 1d81 .fill 4601 .fill ae01 -.fill 5a95 +.fill 60f9 .fill b600 .fill 4001 .fill ae01 -.fill 8695 +.fill 8e04 .fill 1dff .fill 9180 .fill 10d0 @@ -21558,23 +23194,22 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 -.fill a409 +.fill a408 .fill 4601 .fill ae01 -.fill 4dab +.fill 5414 .fill c300 -.fill 1d80 .fill 4601 .fill ae01 -.fill 5a95 +.fill 60f9 .fill b600 .fill 4001 .fill ae01 -.fill 8799 +.fill 8f00 .fill 1dff .fill 9180 .fill 10d0 @@ -21598,7 +23233,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -21606,11 +23241,11 @@ .fill f000 .fill 4601 .fill ae01 -.fill 5a95 +.fill 60f9 .fill b600 .fill 4001 .fill ae01 -.fill 8392 +.fill 8b07 .fill 1dff .fill 9180 .fill 10d0 @@ -21634,14 +23269,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill aa27 .fill 4001 .fill ae01 -.fill 838b +.fill 8b00 .fill 1dff .fill 9180 .fill 10d0 @@ -21665,7 +23300,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -21684,7 +23319,7 @@ .fill aa27 .fill 4001 .fill ae01 -.fill 838e +.fill 8b03 .fill 1dff .fill 9180 .fill 10d0 @@ -21708,7 +23343,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -21724,19 +23359,18 @@ .fill 2180 .fill 1181 .fill 1080 -.fill a409 +.fill a408 .fill 4601 .fill ae01 -.fill 0c2a +.fill 0e5e .fill c300 -.fill 1d80 .fill 4601 .fill ae01 -.fill 5a95 +.fill 60f9 .fill b600 .fill 4001 .fill ae01 -.fill 8408 +.fill 8b7d .fill 1dff .fill 9180 .fill 10d0 @@ -21760,14 +23394,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill aa27 .fill 4001 .fill ae01 -.fill 7aaa +.fill 810d .fill 1dff .fill 9180 .fill 10d0 @@ -21791,7 +23425,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -21810,7 +23444,7 @@ .fill aa27 .fill 4001 .fill ae01 -.fill 7a3a +.fill 809d .fill 1dff .fill 9180 .fill 10d0 @@ -21834,7 +23468,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -21850,16 +23484,15 @@ .fill 2180 .fill 1181 .fill 1080 -.fill a484 +.fill a481 .fill 10d0 .fill 11fe .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 3a51 +.fill 3ebf .fill c300 -.fill 1d80 .fill 6380 .fill 1d81 .fill 9040 @@ -21869,23 +23502,21 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 3a51 +.fill 3ebf .fill c300 -.fill 1d80 .fill 6380 .fill 1d81 .fill 9040 .fill 4601 .fill ae01 -.fill 3a51 +.fill 3ebf .fill c300 -.fill 1d80 .fill 6000 .fill 1080 .fill aa38 .fill 4001 .fill ae01 -.fill 7a3a +.fill 809d .fill 1dff .fill 9180 .fill 10d0 @@ -21909,7 +23540,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -21945,7 +23576,7 @@ .fill a410 .fill 4001 .fill ae01 -.fill 79e2 +.fill 8045 .fill 1dff .fill 9180 .fill 4601 @@ -21956,7 +23587,7 @@ .fill 2180 .fill 4601 .fill ae01 -.fill 5a96 +.fill 60fa .fill b600 .fill ae00 .fill 10d0 @@ -21976,16 +23607,16 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 0d06 +.fill 0f65 .fill c300 .fill 1d83 .fill 4601 .fill ae01 -.fill 5a95 +.fill 60f9 .fill b600 .fill 4001 .fill ae01 -.fill 8329 +.fill 8a9e .fill 1dff .fill 9180 .fill 10d0 @@ -22009,25 +23640,24 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 -.fill a45f +.fill a45e .fill 10d0 .fill 11fc .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 3a51 +.fill 3ebf .fill c300 -.fill 1d80 .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 096c +.fill 095c .fill c300 .fill 1d81 .fill 6380 @@ -22047,14 +23677,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 .fill a40b .fill 4001 .fill ae01 -.fill 8b61 +.fill 92c8 .fill 1dff .fill 9180 .fill 4601 @@ -22065,7 +23695,7 @@ .fill ae2a .fill 4001 .fill ae01 -.fill 782d +.fill 7e73 .fill 1dff .fill 9180 .fill 10d0 @@ -22079,7 +23709,7 @@ .fill a40b .fill 4001 .fill ae01 -.fill 8b71 +.fill 92d8 .fill 1dff .fill 9180 .fill 4601 @@ -22095,7 +23725,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 0943 +.fill 0934 .fill c300 .fill 1d81 .fill 1dff @@ -22107,11 +23737,11 @@ .fill 1d81 .fill 4601 .fill ae01 -.fill 5a95 +.fill 60f9 .fill b600 .fill 4001 .fill ae01 -.fill 827a +.fill 89ef .fill 1dff .fill 9180 .fill 10d0 @@ -22135,20 +23765,19 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 -.fill a45f +.fill a45d .fill 10d0 .fill 11fe .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 3a51 +.fill 3ebf .fill c300 -.fill 1d80 .fill 6380 .fill 1d81 .fill 9040 @@ -22158,9 +23787,8 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 3ae3 +.fill 3f51 .fill c300 -.fill 1d80 .fill 6380 .fill 1d81 .fill 9040 @@ -22191,7 +23819,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 0b65 +.fill 0d94 .fill c300 .fill 1d84 .fill 1dff @@ -22205,14 +23833,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 .fill a40b .fill 4001 .fill ae01 -.fill 8b8a +.fill 92f1 .fill 1dff .fill 9180 .fill 4601 @@ -22223,7 +23851,7 @@ .fill ae0a .fill 4001 .fill ae01 -.fill 7cc1 +.fill 8328 .fill 1dff .fill 9180 .fill 4601 @@ -22233,11 +23861,11 @@ .fill 1d81 .fill 4601 .fill ae01 -.fill 5a95 +.fill 60f9 .fill b600 .fill 4001 .fill ae01 -.fill 812b +.fill 88a0 .fill 1dff .fill 9180 .fill 10d0 @@ -22261,30 +23889,29 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 -.fill a410 +.fill a40f .fill 4601 .fill ae01 -.fill 3a51 +.fill 3ebf .fill c300 -.fill 1d80 .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 447e +.fill 48db .fill c300 .fill 1d81 .fill 4601 .fill ae01 -.fill 5a95 +.fill 60f9 .fill b600 .fill 4001 .fill ae01 -.fill 8542 +.fill 8cb7 .fill 1dff .fill 9180 .fill 10d0 @@ -22308,20 +23935,19 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 -.fill a41a +.fill a419 .fill 10d0 .fill 11fe .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 3a51 +.fill 3ebf .fill c300 -.fill 1d80 .fill 6380 .fill 1d81 .fill 9040 @@ -22332,16 +23958,16 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 4b94 +.fill 4fe7 .fill c300 .fill 1d81 .fill 4601 .fill ae01 -.fill 5a95 +.fill 60f9 .fill b600 .fill 4001 .fill ae01 -.fill 84b0 +.fill 8c25 .fill 1dff .fill 9180 .fill 10d0 @@ -22365,30 +23991,45 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 -.fill a410 -.fill 4601 -.fill ae01 -.fill 3a51 -.fill c300 -.fill 1d80 +.fill a41f +.fill 10d0 +.fill 11fe .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 4ca6 +.fill 3ebf .fill c300 +.fill 6380 .fill 1d81 +.fill 9040 .fill 4601 .fill ae01 -.fill 5a95 +.fill 3f51 +.fill c300 +.fill 1dff +.fill 9180 +.fill 10d0 +.fill 11fe +.fill 6000 +.fill 1dff +.fill 9180 +.fill 4601 +.fill ae01 +.fill 50f8 +.fill c300 +.fill 1d82 +.fill 4601 +.fill ae01 +.fill 60f9 .fill b600 .fill 4001 .fill ae01 -.fill 81c1 +.fill 8936 .fill 1dff .fill 9180 .fill 10d0 @@ -22412,14 +24053,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill aa27 .fill 4001 .fill ae01 -.fill 81c4 +.fill 8939 .fill 1dff .fill 9180 .fill 10d0 @@ -22443,7 +24084,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -22459,16 +24100,15 @@ .fill 2180 .fill 1181 .fill 1080 -.fill a4b9 +.fill a4bb .fill 10d0 .fill 11fe .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 3a51 +.fill 3ebf .fill c300 -.fill 1d80 .fill 6380 .fill 1d81 .fill 9040 @@ -22478,9 +24118,8 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 3a51 +.fill 3ebf .fill c300 -.fill 1d80 .fill 6380 .fill 1d81 .fill 9040 @@ -22498,12 +24137,11 @@ .fill 2180 .fill 1181 .fill 1080 -.fill aa10 +.fill aa0f .fill 4601 .fill ae01 -.fill 3a51 +.fill 3ebf .fill c300 -.fill 1d80 .fill 6000 .fill 2380 .fill 3100 @@ -22521,7 +24159,7 @@ .fill a410 .fill 4001 .fill ae01 -.fill 8bdf +.fill 9346 .fill 1dff .fill 9180 .fill 4601 @@ -22532,7 +24170,7 @@ .fill 2180 .fill 4601 .fill ae01 -.fill 5a96 +.fill 60fa .fill b600 .fill ae00 .fill 10d0 @@ -22556,7 +24194,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 8c0e +.fill 9375 .fill 6380 .fill 1d81 .fill 9040 @@ -22577,7 +24215,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 36bf +.fill 3b0e .fill c300 .fill 1d82 .fill 6380 @@ -22590,7 +24228,7 @@ .fill a427 .fill 4001 .fill ae01 -.fill 81c4 +.fill 8939 .fill 1dff .fill 9180 .fill 10d0 @@ -22614,7 +24252,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -22629,7 +24267,12 @@ .fill ae01 .fill 2180 .fill 1080 -.fill a40b +.fill a410 +.fill 4001 +.fill ae01 +.fill 8573 +.fill 1dff +.fill 9180 .fill 10d0 .fill 11fd .fill 6000 @@ -22637,17 +24280,17 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 4ca6 +.fill 50f8 .fill c300 -.fill 1d81 +.fill 1d82 .fill ae00 .fill 4601 .fill ae01 -.fill 5a95 +.fill 60f9 .fill b600 .fill 4001 .fill ae01 -.fill 868f +.fill 8dfe .fill 1dff .fill 9180 .fill 10d0 @@ -22671,25 +24314,24 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 -.fill a46d +.fill a46c .fill 10d0 .fill 11fc .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 3a51 +.fill 3ebf .fill c300 -.fill 1d80 .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 3b18 +.fill 3f7f .fill c300 .fill 1d81 .fill 6380 @@ -22697,7 +24339,7 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 784b +.fill 7e92 .fill 6000 .fill 2380 .fill 3100 @@ -22712,7 +24354,7 @@ .fill a410 .fill 4001 .fill ae01 -.fill 8c12 +.fill 9379 .fill 1dff .fill 9180 .fill 4601 @@ -22723,7 +24365,7 @@ .fill 2180 .fill 4601 .fill ae01 -.fill 5a96 +.fill 60fa .fill b600 .fill ae00 .fill 10d0 @@ -22737,7 +24379,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 07a7 +.fill 079b .fill c300 .fill 1d81 .fill 6380 @@ -22759,7 +24401,7 @@ .fill a40b .fill 4001 .fill ae01 -.fill 8c59 +.fill 93c8 .fill 1dff .fill 9180 .fill 4601 @@ -22775,7 +24417,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 0545 +.fill 0543 .fill c300 .fill 1d81 .fill 2180 @@ -22783,11 +24425,11 @@ .fill f100 .fill 4601 .fill ae01 -.fill 5a95 +.fill 60f9 .fill b600 .fill 4001 .fill ae01 -.fill 85ce +.fill 8d43 .fill 1dff .fill 9180 .fill 10d0 @@ -22811,14 +24453,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill aa27 .fill 4001 .fill ae01 -.fill 85d3 +.fill 8d48 .fill 1dff .fill 9180 .fill 10d0 @@ -22842,7 +24484,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -22861,7 +24503,7 @@ .fill aa04 .fill 4601 .fill ae01 -.fill 5a8b +.fill 60ef .fill b600 .fill 10d0 .fill 11fb @@ -22869,14 +24511,13 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 3a51 +.fill 3ebf .fill c300 -.fill 1d80 .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 3b18 +.fill 3f7f .fill c300 .fill 1d81 .fill 6380 @@ -22884,7 +24525,7 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 784b +.fill 7e92 .fill 6000 .fill 2380 .fill 3100 @@ -22899,7 +24540,7 @@ .fill a410 .fill 4001 .fill ae01 -.fill 8cad +.fill 941c .fill 1dff .fill 9180 .fill 4601 @@ -22910,7 +24551,7 @@ .fill 2180 .fill 4601 .fill ae01 -.fill 5a96 +.fill 60fa .fill b600 .fill ae00 .fill 10d0 @@ -22925,7 +24566,7 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 85d3 +.fill 8d48 .fill 1dff .fill 9180 .fill 10d0 @@ -22949,25 +24590,24 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 -.fill a4a1 +.fill a49c .fill 10d0 .fill 11fc .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 3a51 +.fill 3ebf .fill c300 -.fill 1d80 .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 3b18 +.fill 3f7f .fill c300 .fill 1d81 .fill 6380 @@ -22975,7 +24615,7 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 784b +.fill 7e92 .fill 6000 .fill 2380 .fill 3100 @@ -22990,7 +24630,7 @@ .fill a40d .fill 4001 .fill ae01 -.fill 8cea +.fill 9459 .fill 1dff .fill 9180 .fill 4601 @@ -22999,7 +24639,7 @@ .fill c300 .fill 1d81 .fill 2180 -.fill aebd +.fill aeb9 .fill ae00 .fill 10d0 .fill 11fb @@ -23015,11 +24655,11 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73b9 +.fill 79ff .fill c300 .fill 1d82 .fill 1080 -.fill aa1f +.fill aa1d .fill 10d0 .fill 11fb .fill 6000 @@ -23027,9 +24667,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 4000 -.fill 3100 -.fill 1181 +.fill c000 .fill 6380 .fill 1d81 .fill 1dff @@ -23038,7 +24676,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 2380 @@ -23054,7 +24692,7 @@ .fill 2180 .fill 1181 .fill 1080 -.fill aa1f +.fill aa1d .fill 10d0 .fill 11fb .fill 6000 @@ -23062,9 +24700,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 2000 -.fill 3100 -.fill 1181 +.fill e000 .fill 6380 .fill 1d81 .fill 1dff @@ -23073,7 +24709,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73b9 +.fill 79ff .fill c300 .fill 1d82 .fill 2380 @@ -23092,7 +24728,7 @@ .fill a40d .fill 4001 .fill ae01 -.fill 8d1e +.fill 948d .fill 1dff .fill 9180 .fill 4601 @@ -23122,12 +24758,12 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 0545 +.fill 0543 .fill c300 .fill 1d81 .fill 4001 .fill ae01 -.fill 7c83 +.fill 82ea .fill 1dff .fill 9180 .fill 4601 @@ -23143,12 +24779,12 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 0545 +.fill 0543 .fill c300 .fill 1d81 .fill 4001 .fill ae01 -.fill 8d41 +.fill 94b0 .fill 1dff .fill 9180 .fill 4601 @@ -23164,12 +24800,12 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 050e +.fill 050d .fill c300 .fill 1d81 .fill 4001 .fill ae01 -.fill 8d44 +.fill 94b3 .fill 1dff .fill 9180 .fill 4601 @@ -23180,7 +24816,7 @@ .fill ae0a .fill 4001 .fill ae01 -.fill 8d46 +.fill 94b5 .fill 1dff .fill 9180 .fill 4601 @@ -23203,7 +24839,7 @@ .fill 1dfc .fill 4001 .fill ae01 -.fill 784f +.fill 7e96 .fill 6000 .fill 2380 .fill 3100 @@ -23219,7 +24855,7 @@ .fill 2180 .fill 4601 .fill ae01 -.fill 5bce +.fill 6232 .fill b600 .fill ae00 .fill 10d0 @@ -23254,7 +24890,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 @@ -23279,7 +24915,7 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 784e +.fill 7e95 .fill 6000 .fill 1dff .fill 9180 @@ -23294,7 +24930,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73b9 +.fill 79ff .fill c300 .fill 1d82 .fill 1080 @@ -23305,7 +24941,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 784e +.fill 7e95 .fill 6000 .fill 1dff .fill 9180 @@ -23353,7 +24989,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 784d +.fill 7e94 .fill 6000 .fill 6380 .fill 1d81 @@ -23363,7 +24999,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7363 +.fill 79ab .fill c300 .fill 1d82 .fill 1080 @@ -23374,7 +25010,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 784d +.fill 7e94 .fill 6000 .fill 6380 .fill 1d81 @@ -23382,7 +25018,7 @@ .fill ae00 .fill 4001 .fill ae01 -.fill 8d62 +.fill 94d1 .fill 1dff .fill 9180 .fill 4601 @@ -23416,7 +25052,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 @@ -23452,7 +25088,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 784e +.fill 7e95 .fill 6000 .fill 6380 .fill 1d81 @@ -23473,14 +25109,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 .fill a416 .fill 4001 .fill ae01 -.fill 8d6d +.fill 94dc .fill 1dff .fill 9180 .fill 4601 @@ -23536,7 +25172,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7404 +.fill 7a48 .fill c300 .fill 1d82 .fill 1080 @@ -23548,7 +25184,7 @@ .fill ae00 .fill 4001 .fill ae01 -.fill 784f +.fill 7e96 .fill 6000 .fill 1080 .fill a403 @@ -23569,7 +25205,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7404 +.fill 7a48 .fill c300 .fill 1d82 .fill 1080 @@ -23601,7 +25237,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -23627,7 +25263,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -23653,7 +25289,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -23679,7 +25315,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -23705,7 +25341,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -23731,7 +25367,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -23756,7 +25392,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -23775,7 +25411,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -23835,7 +25471,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 @@ -23905,7 +25541,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7404 +.fill 7a48 .fill c300 .fill 1d82 .fill 2380 @@ -23959,7 +25595,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 784e +.fill 7e95 .fill 6000 .fill 6380 .fill 1d81 @@ -24002,7 +25638,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7404 +.fill 7a48 .fill c300 .fill 1d82 .fill 2380 @@ -24036,7 +25672,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 784e +.fill 7e95 .fill 6000 .fill 1dff .fill 9180 @@ -24061,13 +25697,13 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 784e +.fill 7e95 .fill 6000 .fill 1dff .fill 9180 .fill 4001 .fill ae01 -.fill 784d +.fill 7e94 .fill 6000 .fill 6380 .fill 1d81 @@ -24077,7 +25713,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7404 +.fill 7a48 .fill c300 .fill 1d82 .fill 1080 @@ -24085,7 +25721,7 @@ .fill 2180 .fill 4601 .fill ae01 -.fill 6082 +.fill 66e5 .fill b600 .fill ae00 .fill 10d0 @@ -24108,7 +25744,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 8d71 +.fill 94e0 .fill 6380 .fill 1d81 .fill 9040 @@ -24148,7 +25784,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7404 +.fill 7a48 .fill c300 .fill 1d82 .fill 2380 @@ -24290,7 +25926,7 @@ .fill 1d83 .fill 4001 .fill ae01 -.fill 784f +.fill 7e96 .fill 6000 .fill 1080 .fill a42c @@ -24309,7 +25945,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -24329,7 +25965,7 @@ .fill 1d81 .fill 4001 .fill ae01 -.fill 7977 +.fill 7fbe .fill 1dff .fill 9180 .fill 4601 @@ -24364,14 +26000,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 .fill a4ac .fill 4001 .fill ae01 -.fill 7835 +.fill 7e7b .fill 1dff .fill 9180 .fill 10d0 @@ -24400,7 +26036,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 091b +.fill 090d .fill c300 .fill 1d81 .fill 1dff @@ -24438,7 +26074,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 091b +.fill 090d .fill c300 .fill 1d81 .fill 1dff @@ -24464,7 +26100,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 091b +.fill 090d .fill c300 .fill 1d81 .fill 1dff @@ -24480,7 +26116,7 @@ .fill 1d83 .fill 4001 .fill ae01 -.fill 784f +.fill 7e96 .fill 6000 .fill 1080 .fill a42c @@ -24499,7 +26135,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -24519,7 +26155,7 @@ .fill 1d81 .fill 4001 .fill ae01 -.fill 7977 +.fill 7fbe .fill 1dff .fill 9180 .fill 4601 @@ -24556,7 +26192,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -24601,7 +26237,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 @@ -24642,7 +26278,7 @@ .fill 1d83 .fill 4001 .fill ae01 -.fill 784d +.fill 7e94 .fill 1dff .fill 9180 .fill 10d0 @@ -24661,12 +26297,12 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 784e +.fill 7e95 .fill 1dff .fill 9180 .fill 4001 .fill ae01 -.fill 784d +.fill 7e94 .fill 6000 .fill 6380 .fill 1d81 @@ -24675,7 +26311,7 @@ .fill ae00 .fill 4001 .fill ae01 -.fill 784f +.fill 7e96 .fill 6000 .fill 1080 .fill a40d @@ -24701,9 +26337,8 @@ .fill ae00 .fill 4601 .fill ae01 -.fill 5a9c +.fill 6100 .fill c300 -.fill 1d80 .fill 2180 .fill 1cd0 .fill 6b80 @@ -24722,7 +26357,7 @@ .fill 1c64 .fill 4001 .fill ae01 -.fill 784d +.fill 7e94 .fill 1dff .fill 9180 .fill 2180 @@ -24731,7 +26366,7 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 784e +.fill 7e95 .fill 1dff .fill 9180 .fill 2180 @@ -24752,14 +26387,14 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 784c +.fill 7e93 .fill 6000 .fill 6380 .fill 1d81 .fill 9040 .fill 4001 .fill ae01 -.fill 784f +.fill 7e96 .fill 1dff .fill 9180 .fill f900 @@ -24804,7 +26439,7 @@ .fill aa04 .fill 4601 .fill ae01 -.fill 6651 +.fill 6cad .fill b600 .fill 10d0 .fill 11ff @@ -24812,9 +26447,8 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 5bd4 +.fill 6238 .fill c300 -.fill 1d80 .fill 6380 .fill 1d81 .fill 9040 @@ -24833,19 +26467,17 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 -.fill a40c +.fill a40a .fill 10d0 .fill 11ff .fill 1dff .fill 9180 .fill 2180 -.fill 1181 -.fill 3100 -.fill 1181 +.fill 11ff .fill 6380 .fill 1d81 .fill 9040 @@ -24856,9 +26488,7 @@ .fill 1dff .fill 9180 .fill 2180 -.fill 1181 -.fill 3100 -.fill 1181 +.fill 11ff .fill 6380 .fill 1d81 .fill 1dff @@ -24867,7 +26497,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -24887,7 +26517,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -24906,7 +26536,7 @@ .fill a405 .fill 4601 .fill ae01 -.fill 6651 +.fill 6cad .fill b600 .fill ae00 .fill 10d0 @@ -24924,7 +26554,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -24943,7 +26573,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -24962,7 +26592,7 @@ .fill a405 .fill 4601 .fill ae01 -.fill 664d +.fill 6ca9 .fill b600 .fill ae00 .fill 10d0 @@ -24981,7 +26611,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -25002,7 +26632,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -25021,7 +26651,7 @@ .fill aa04 .fill 4601 .fill ae01 -.fill 6319 +.fill 6977 .fill b600 .fill 10d0 .fill 11fc @@ -25030,7 +26660,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 784c +.fill 7e93 .fill 6000 .fill 6380 .fill 1d81 @@ -25040,14 +26670,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a41f .fill 4001 .fill ae01 -.fill 784d +.fill 7e94 .fill 6000 .fill 1dff .fill 9180 @@ -25092,7 +26722,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -25141,7 +26771,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -25153,7 +26783,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 784c +.fill 7e93 .fill 6000 .fill 6380 .fill 1d81 @@ -25163,7 +26793,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 2380 @@ -25198,7 +26828,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 784c +.fill 7e93 .fill 6000 .fill 6380 .fill 1d81 @@ -25208,7 +26838,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -25273,7 +26903,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7424 +.fill 7a67 .fill c300 .fill 1d82 .fill 6380 @@ -25316,7 +26946,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7424 +.fill 7a67 .fill c300 .fill 1d82 .fill 6380 @@ -25336,7 +26966,7 @@ .fill 1d83 .fill 4001 .fill ae01 -.fill 784d +.fill 7e94 .fill 1dff .fill 9180 .fill 4001 @@ -25354,19 +26984,19 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 784e +.fill 7e95 .fill 1dff .fill 9180 .fill 4001 .fill ae01 -.fill 784d +.fill 7e94 .fill 6000 .fill 6380 .fill 1d81 .fill 9040 .fill 4601 .fill ae01 -.fill 6648 +.fill 6ca5 .fill b600 .fill 10d0 .fill 11ff @@ -25384,20 +27014,20 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a417 .fill 4001 .fill ae01 -.fill 784e +.fill 7e95 .fill 6000 .fill 1080 .fill a40d .fill 4001 .fill ae01 -.fill 784e +.fill 7e95 .fill 1dff .fill 9180 .fill 6000 @@ -25410,7 +27040,7 @@ .fill ae00 .fill 4601 .fill ae01 -.fill 6648 +.fill 6ca5 .fill b600 .fill 10d0 .fill 11ff @@ -25428,20 +27058,20 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a428 .fill 4001 .fill ae01 -.fill 784e +.fill 7e95 .fill 6000 .fill 1dff .fill 9180 .fill 4001 .fill ae01 -.fill 784d +.fill 7e94 .fill 6000 .fill 6380 .fill 1d81 @@ -25451,14 +27081,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 .fill a40d .fill 4001 .fill ae01 -.fill 784e +.fill 7e95 .fill 1dff .fill 9180 .fill 6000 @@ -25471,7 +27101,7 @@ .fill ae00 .fill 4601 .fill ae01 -.fill 6648 +.fill 6ca5 .fill b600 .fill 10d0 .fill 11ff @@ -25489,7 +27119,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -25509,7 +27139,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -25528,7 +27158,7 @@ .fill a40d .fill 4001 .fill ae01 -.fill 784e +.fill 7e95 .fill 1dff .fill 9180 .fill 2180 @@ -25537,7 +27167,7 @@ .fill 9040 .fill 4601 .fill ae01 -.fill 6648 +.fill 6ca5 .fill b600 .fill 10d0 .fill 11ff @@ -25555,7 +27185,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -25575,7 +27205,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -25594,19 +27224,19 @@ .fill a410 .fill 4001 .fill ae01 -.fill 784e +.fill 7e95 .fill 1dff .fill 9180 .fill 4001 .fill ae01 -.fill 784d +.fill 7e94 .fill 6000 .fill 6380 .fill 1d81 .fill 9040 .fill 4601 .fill ae01 -.fill 6648 +.fill 6ca5 .fill b600 .fill 10d0 .fill 11ff @@ -25623,14 +27253,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a425 .fill 4001 .fill ae01 -.fill 784d +.fill 7e94 .fill 1dff .fill 9180 .fill 2180 @@ -25639,7 +27269,7 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 784e +.fill 7e95 .fill 1dff .fill 9180 .fill 2180 @@ -25663,7 +27293,7 @@ .fill 9040 .fill 4601 .fill ae01 -.fill 6648 +.fill 6ca5 .fill b600 .fill 10d0 .fill 11ff @@ -25680,23 +27310,22 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 -.fill a40d +.fill a40c .fill 4601 .fill ae01 -.fill 5d8c +.fill 63f0 .fill c300 -.fill 1d80 .fill 4601 .fill ae01 -.fill 664d +.fill 6ca9 .fill b600 .fill 4601 .fill ae01 -.fill 6648 +.fill 6ca5 .fill b600 .fill 10d0 .fill 11ff @@ -25714,7 +27343,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -25734,7 +27363,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -25767,7 +27396,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -25800,14 +27429,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7404 +.fill 7a48 .fill c300 .fill 1d82 .fill 1080 .fill a40e .fill 4001 .fill ae01 -.fill 784e +.fill 7e95 .fill 6000 .fill 2380 .fill 3100 @@ -25824,7 +27453,7 @@ .fill a40d .fill 4001 .fill ae01 -.fill 784e +.fill 7e95 .fill 1dff .fill 9180 .fill 6000 @@ -25851,25 +27480,25 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7404 +.fill 7a48 .fill c300 .fill 1d82 .fill 1080 .fill a405 .fill 4601 .fill ae01 -.fill 664d +.fill 6ca9 .fill b600 .fill ae00 .fill 4001 .fill ae01 -.fill 784e +.fill 7e95 .fill 6000 .fill 1dff .fill 9180 .fill 4001 .fill ae01 -.fill 784d +.fill 7e94 .fill 6000 .fill 6380 .fill 1d81 @@ -25879,7 +27508,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 @@ -25890,7 +27519,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 784e +.fill 7e95 .fill 6000 .fill 6380 .fill 1d81 @@ -25902,7 +27531,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 784d +.fill 7e94 .fill 6000 .fill 6380 .fill 1d81 @@ -25912,7 +27541,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 @@ -25966,7 +27595,7 @@ .fill afbb .fill 4001 .fill ae01 -.fill 784d +.fill 7e94 .fill 1dff .fill 9180 .fill 6000 @@ -25993,7 +27622,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73b9 +.fill 79ff .fill c300 .fill 1d82 .fill 1080 @@ -26014,7 +27643,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 738e +.fill 79d5 .fill c300 .fill 1d82 .fill 2380 @@ -26032,7 +27661,7 @@ .fill a499 .fill 4001 .fill ae01 -.fill 784d +.fill 7e94 .fill 6000 .fill 1dff .fill 9180 @@ -26047,7 +27676,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -26068,7 +27697,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 784d +.fill 7e94 .fill 6000 .fill 6380 .fill 1d81 @@ -26080,7 +27709,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 784e +.fill 7e95 .fill 6000 .fill 6380 .fill 1d81 @@ -26090,7 +27719,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73b9 +.fill 79ff .fill c300 .fill 1d82 .fill 1080 @@ -26149,7 +27778,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 784e +.fill 7e95 .fill 1dff .fill 9180 .fill 6000 @@ -26172,7 +27801,7 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 784d +.fill 7e94 .fill 1dff .fill 9180 .fill 6000 @@ -26185,16 +27814,15 @@ .fill ae00 .fill 4601 .fill ae01 -.fill 5a9c +.fill 6100 .fill c300 -.fill 1d80 .fill 4601 .fill ae01 -.fill 60df +.fill 6742 .fill b600 .fill 4001 .fill ae01 -.fill 784f +.fill 7e96 .fill 6000 .fill 1080 .fill a404 @@ -26206,14 +27834,12 @@ .fill 11fd .fill 6000 .fill 1080 -.fill a409 +.fill a407 .fill 2180 -.fill 1181 -.fill 3100 -.fill 1181 +.fill 11ff .fill 4601 .fill ae01 -.fill 67bb +.fill 6e11 .fill b600 .fill ae00 .fill 10d0 @@ -26222,9 +27848,7 @@ .fill 1dff .fill 9180 .fill 2180 -.fill 1181 -.fill 3100 -.fill 1181 +.fill 11ff .fill 6380 .fill 1d81 .fill 1dff @@ -26233,14 +27857,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a417 .fill 4001 .fill ae01 -.fill 784d +.fill 7e94 .fill 6000 .fill 2380 .fill 3100 @@ -26263,25 +27887,23 @@ .fill ae01 .fill 2180 .fill 1080 -.fill a409 +.fill a407 .fill 2180 -.fill 1182 -.fill 3100 -.fill 1181 +.fill 11fe .fill 4601 .fill ae01 -.fill 67bb +.fill 6e11 .fill b600 .fill ae00 .fill 4001 .fill ae01 -.fill 784d +.fill 7e94 .fill 6000 .fill 1080 .fill a45b .fill 4001 .fill ae01 -.fill 784c +.fill 7e93 .fill 6000 .fill 1dff .fill 9180 @@ -26294,7 +27916,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -26306,7 +27928,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 784c +.fill 7e93 .fill 6000 .fill 1dff .fill 9180 @@ -26330,7 +27952,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7424 +.fill 7a67 .fill c300 .fill 1d82 .fill 6380 @@ -26375,7 +27997,7 @@ .fill a4af .fill 4001 .fill ae01 -.fill 784c +.fill 7e93 .fill 6000 .fill 1dff .fill 9180 @@ -26389,7 +28011,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -26418,7 +28040,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 @@ -26473,7 +28095,7 @@ .fill afbb .fill 4001 .fill ae01 -.fill 784c +.fill 7e93 .fill 1dff .fill 9180 .fill 2180 @@ -26484,7 +28106,7 @@ .fill ae00 .fill 4001 .fill ae01 -.fill 784d +.fill 7e94 .fill 6000 .fill 1dff .fill 9180 @@ -26507,7 +28129,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 784c +.fill 7e93 .fill 6000 .fill 1dff .fill 9180 @@ -26522,7 +28144,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7424 +.fill 7a67 .fill c300 .fill 1d82 .fill 6380 @@ -26537,7 +28159,7 @@ .fill 1d83 .fill 4001 .fill ae01 -.fill 784c +.fill 7e93 .fill 1dff .fill 9180 .fill 6000 @@ -26550,7 +28172,7 @@ .fill ae00 .fill 4001 .fill ae01 -.fill 784d +.fill 7e94 .fill 6000 .fill ae01 .fill 2180 @@ -26595,7 +28217,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7851 +.fill 7e98 .fill 6000 .fill 1dff .fill 9180 @@ -26614,7 +28236,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 2380 @@ -26667,10 +28289,9 @@ .fill 1dff .fill 9b80 .fill 1ae0 -.fill 1d80 .fill 4001 .fill ae01 -.fill 8de5 +.fill 9554 .fill 1dff .fill 9180 .fill 4601 @@ -26685,7 +28306,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 050e +.fill 050d .fill c300 .fill 1d81 .fill 2180 @@ -26698,7 +28319,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 050e +.fill 050d .fill c300 .fill 1d81 .fill 4001 @@ -26717,7 +28338,6 @@ .fill 1dff .fill 9b80 .fill 1ae0 -.fill 1d80 .fill 10d0 .fill 1182 .fill 6000 @@ -26756,7 +28376,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7404 +.fill 7a48 .fill c300 .fill 1d82 .fill 2380 @@ -26800,7 +28420,6 @@ .fill 1dff .fill 9b80 .fill 1ae0 -.fill 1d80 .fill 10d0 .fill 1182 .fill 6000 @@ -26808,7 +28427,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7847 +.fill 7e8e .fill 6000 .fill 6380 .fill 1d81 @@ -26818,7 +28437,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 @@ -26847,7 +28466,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7404 +.fill 7a48 .fill c300 .fill 1d82 .fill 2380 @@ -26910,7 +28529,7 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 7851 +.fill 7e98 .fill 1dff .fill 9180 .fill 10d0 @@ -26934,7 +28553,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 @@ -26955,17 +28574,17 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7850 +.fill 7e97 .fill 6000 .fill 1dff .fill 9180 .fill 4001 .fill ae01 -.fill 7850 +.fill 7e97 .fill 6000 .fill 1dff .fill 9180 -.fill cf02 +.fill cf04 .fill 1d81 .fill 6380 .fill 1d81 @@ -27008,7 +28627,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73b9 +.fill 79ff .fill c300 .fill 1d82 .fill 1080 @@ -27047,11 +28666,11 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7850 +.fill 7e97 .fill 6000 .fill 1dff .fill 9180 -.fill ceac +.fill ceae .fill 1d81 .fill 6380 .fill 1d81 @@ -27089,7 +28708,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 @@ -27128,7 +28747,7 @@ .fill 1010 .fill 1dff .fill 9180 -.fill ce5f +.fill ce61 .fill 1d81 .fill 6380 .fill 1d81 @@ -27147,7 +28766,7 @@ .fill afaf .fill 4001 .fill ae01 -.fill 8de8 +.fill 9557 .fill 1dff .fill 9180 .fill 4601 @@ -27157,7 +28776,7 @@ .fill 1d81 .fill 4001 .fill ae01 -.fill 8df6 +.fill 9565 .fill 1dff .fill 9180 .fill 4601 @@ -27182,14 +28801,14 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 4141 +.fill 459f .fill c300 .fill 1d81 .fill 1080 .fill a40b .fill 4001 .fill ae01 -.fill 8e01 +.fill 9570 .fill 1dff .fill 9180 .fill 4601 @@ -27251,14 +28870,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 .fill aa04 .fill 4601 .fill ae01 -.fill 6bda +.fill 722d .fill b600 .fill 2180 .fill 1181 @@ -27269,7 +28888,7 @@ .fill 6000 .fill 1dff .fill 9180 -.fill cda0 +.fill cda3 .fill 1d82 .fill 10d0 .fill 11f7 @@ -27286,7 +28905,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7847 +.fill 7e8e .fill 6000 .fill 6380 .fill 1d81 @@ -27296,7 +28915,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 @@ -27325,7 +28944,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7404 +.fill 7a48 .fill c300 .fill 1d82 .fill 2380 @@ -27357,7 +28976,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73b9 +.fill 79ff .fill c300 .fill 1d82 .fill 1080 @@ -27397,7 +29016,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 2380 @@ -27437,7 +29056,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73b9 +.fill 79ff .fill c300 .fill 1d82 .fill 1080 @@ -27485,7 +29104,7 @@ .fill af34 .fill 4001 .fill ae01 -.fill 7850 +.fill 7e97 .fill 6000 .fill 1dff .fill 9180 @@ -27500,14 +29119,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73b9 +.fill 79ff .fill c300 .fill 1d82 .fill 1080 .fill a41e .fill 4001 .fill ae01 -.fill 7850 +.fill 7e97 .fill 6000 .fill 1dff .fill 9180 @@ -27522,7 +29141,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 738e +.fill 79d5 .fill c300 .fill 1d82 .fill 2380 @@ -27556,7 +29175,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7847 +.fill 7e8e .fill 6000 .fill 6380 .fill 1d81 @@ -27566,7 +29185,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73b9 +.fill 79ff .fill c300 .fill 1d82 .fill 1080 @@ -27607,7 +29226,7 @@ .fill 10c0 .fill 4601 .fill ae01 -.fill 6a5b +.fill 70ae .fill b600 .fill 2180 .fill 1181 @@ -27627,7 +29246,7 @@ .fill 1010 .fill 1dff .fill 9180 -.fill cc3a +.fill cc3d .fill 1d82 .fill 10d0 .fill 1183 @@ -27636,7 +29255,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 67c1 +.fill 6e17 .fill c300 .fill 1d81 .fill 2180 @@ -27648,16 +29267,16 @@ .fill 6000 .fill 1dff .fill 9180 -.fill cc25 +.fill cc28 .fill 1d82 .fill 4001 .fill ae01 -.fill 8e04 +.fill 9573 .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 67c1 +.fill 6e17 .fill c300 .fill 1d81 .fill 10d0 @@ -27687,14 +29306,11 @@ .fill 6000 .fill 1dff .fill 9180 -.fill 4601 -.fill ae01 -.fill 6827 -.fill c300 +.fill cc01 .fill 1d82 .fill 4001 .fill ae01 -.fill 8e2b +.fill 959a .fill 1dff .fill 9180 .fill 4601 @@ -27717,7 +29333,7 @@ .fill 1df7 .fill 4001 .fill ae01 -.fill 7850 +.fill 7e97 .fill 1dff .fill 9180 .fill 2180 @@ -27730,7 +29346,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 8e32 +.fill 95a1 .fill 6380 .fill 1d81 .fill 9040 @@ -27740,7 +29356,7 @@ .fill aa04 .fill 4601 .fill ae01 -.fill 7279 +.fill 78c5 .fill b600 .fill 10d0 .fill 11f7 @@ -27752,7 +29368,7 @@ .fill 6000 .fill 1dff .fill 9180 -.fill cc9d +.fill cca0 .fill 1d82 .fill 10d0 .fill 11ff @@ -27760,9 +29376,8 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 5bd4 +.fill 6238 .fill c300 -.fill 1d80 .fill 6380 .fill 1d81 .fill 9040 @@ -27772,7 +29387,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7f0c +.fill 8573 .fill 6380 .fill 1d81 .fill 9040 @@ -27782,9 +29397,7 @@ .fill 1dff .fill 9180 .fill 2180 -.fill 1181 -.fill 3100 -.fill 1181 +.fill 11ff .fill 6380 .fill 1d81 .fill 1dff @@ -27793,7 +29406,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -27823,11 +29436,11 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 -.fill a4c4 +.fill a4c3 .fill 10d0 .fill 1182 .fill 6000 @@ -27835,7 +29448,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 4141 +.fill 459f .fill c300 .fill 1d81 .fill 2380 @@ -27851,12 +29464,12 @@ .fill a405 .fill 4601 .fill ae01 -.fill 7279 +.fill 78c5 .fill b600 .fill ae00 .fill 4001 .fill ae01 -.fill 8e4e +.fill 95bd .fill 1dff .fill 9180 .fill 10d0 @@ -27864,7 +29477,7 @@ .fill 6000 .fill 1dff .fill 9180 -.fill cc2d +.fill cc33 .fill 1d82 .fill 10d0 .fill 11ff @@ -27872,9 +29485,8 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 5bd4 +.fill 6238 .fill c300 -.fill 1d80 .fill 6380 .fill 1d81 .fill 9040 @@ -27894,7 +29506,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -27915,7 +29527,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -27934,7 +29546,7 @@ .fill a405 .fill 4601 .fill ae01 -.fill 7279 +.fill 78c5 .fill b600 .fill ae00 .fill 10d0 @@ -27953,7 +29565,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -27974,7 +29586,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -27998,7 +29610,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 4369 +.fill 47c7 .fill c300 .fill 1d81 .fill 2380 @@ -28016,12 +29628,12 @@ .fill a405 .fill 4601 .fill ae01 -.fill 7279 +.fill 78c5 .fill b600 .fill ae00 .fill 4601 .fill ae01 -.fill 7275 +.fill 78c1 .fill b600 .fill ae00 .fill 10d0 @@ -28039,7 +29651,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -28051,7 +29663,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 4369 +.fill 47c7 .fill c300 .fill 1d81 .fill 1080 @@ -28062,7 +29674,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 8e6e +.fill 95dd .fill 6380 .fill 1d81 .fill 9040 @@ -28073,13 +29685,13 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 8e91 +.fill 9600 .fill 6380 .fill 1d81 .fill 9040 .fill 4601 .fill ae01 -.fill 7275 +.fill 78c1 .fill b600 .fill 10d0 .fill 11ff @@ -28096,14 +29708,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a40e .fill 4001 .fill ae01 -.fill 7849 +.fill 7e90 .fill 6000 .fill 2380 .fill 3100 @@ -28124,14 +29736,14 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7847 +.fill 7e8e .fill 6000 .fill 6380 .fill 1d81 .fill 9040 .fill 4001 .fill ae01 -.fill 7848 +.fill 7e8f .fill 6000 .fill 1dff .fill 9180 @@ -28146,7 +29758,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7363 +.fill 79ab .fill c300 .fill 1d82 .fill 1080 @@ -28157,7 +29769,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7848 +.fill 7e8f .fill 6000 .fill 6380 .fill 1d81 @@ -28187,7 +29799,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 738e +.fill 79d5 .fill c300 .fill 1d82 .fill 1080 @@ -28276,26 +29888,26 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7847 +.fill 7e8e .fill 6000 .fill 6380 .fill 1d81 .fill 9040 .fill 4001 .fill ae01 -.fill 7847 +.fill 7e8e .fill 1dff .fill 9180 .fill 4001 .fill ae01 -.fill 7848 +.fill 7e8f .fill 6000 .fill 6380 .fill 1d81 .fill 9040 .fill 4001 .fill ae01 -.fill 7848 +.fill 7e8f .fill 1dff .fill 9180 .fill 10d0 @@ -28306,13 +29918,13 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 7850 +.fill 7e97 .fill 6000 .fill 1dff .fill 9180 .fill 4001 .fill ae01 -.fill 7847 +.fill 7e8e .fill 6000 .fill 6380 .fill 1d81 @@ -28322,19 +29934,19 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7363 +.fill 79ab .fill c300 .fill 1d82 .fill 1080 .fill a40d .fill 4001 .fill ae01 -.fill 7850 +.fill 7e97 .fill 1dff .fill 9180 .fill 4001 .fill ae01 -.fill 7847 +.fill 7e8e .fill 6000 .fill 6380 .fill 1d81 @@ -28346,13 +29958,13 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 8eac +.fill 961b .fill 6380 .fill 1d81 .fill 9040 .fill 4601 .fill ae01 -.fill 7275 +.fill 78c1 .fill b600 .fill 10d0 .fill 11ff @@ -28370,20 +29982,20 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a417 .fill 4001 .fill ae01 -.fill 7850 +.fill 7e97 .fill 6000 .fill 1080 .fill a40d .fill 4001 .fill ae01 -.fill 7850 +.fill 7e97 .fill 1dff .fill 9180 .fill 6000 @@ -28396,7 +30008,7 @@ .fill ae00 .fill 4601 .fill ae01 -.fill 7275 +.fill 78c1 .fill b600 .fill 10d0 .fill 11ff @@ -28414,20 +30026,20 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 .fill a428 .fill 4001 .fill ae01 -.fill 7850 +.fill 7e97 .fill 6000 .fill 1dff .fill 9180 .fill 4001 .fill ae01 -.fill 7847 +.fill 7e8e .fill 6000 .fill 6380 .fill 1d81 @@ -28437,14 +30049,14 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 7338 +.fill 7981 .fill c300 .fill 1d82 .fill 1080 .fill a40d .fill 4001 .fill ae01 -.fill 7850 +.fill 7e97 .fill 1dff .fill 9180 .fill 6000 @@ -28457,7 +30069,7 @@ .fill ae00 .fill 4601 .fill ae01 -.fill 7275 +.fill 78c1 .fill b600 .fill 10d0 .fill 11ff @@ -28475,7 +30087,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -28495,7 +30107,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -28514,18 +30126,18 @@ .fill a417 .fill 4001 .fill ae01 -.fill 7850 +.fill 7e97 .fill 1dff .fill 9180 .fill 4001 .fill ae01 -.fill 7850 +.fill 7e97 .fill 6000 .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 6859 +.fill 6eae .fill c300 .fill 1d81 .fill 6380 @@ -28533,7 +30145,7 @@ .fill 9040 .fill 4601 .fill ae01 -.fill 7275 +.fill 78c1 .fill b600 .fill 10d0 .fill 11ff @@ -28551,7 +30163,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -28571,7 +30183,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 2380 @@ -28590,18 +30202,18 @@ .fill a417 .fill 4001 .fill ae01 -.fill 7850 +.fill 7e97 .fill 1dff .fill 9180 .fill 4001 .fill ae01 -.fill 7850 +.fill 7e97 .fill 6000 .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 68ac +.fill 6f00 .fill c300 .fill 1d81 .fill 6380 @@ -28609,7 +30221,7 @@ .fill 9040 .fill 4601 .fill ae01 -.fill 7275 +.fill 78c1 .fill b600 .fill 10d0 .fill 11ff @@ -28627,7 +30239,7 @@ .fill 9380 .fill 4601 .fill ae01 -.fill 73e4 +.fill 7a29 .fill c300 .fill 1d82 .fill 1080 @@ -28646,7 +30258,7 @@ .fill 9180 .fill 1dff .fill 9380 -.fill cbfc +.fill cbf5 .fill 1d82 .fill 2380 .fill 3100 @@ -28668,13 +30280,13 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7850 +.fill 7e97 .fill 6000 .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 6859 +.fill 6eae .fill c300 .fill 1d81 .fill 6380 @@ -28686,7 +30298,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7850 +.fill 7e97 .fill 6000 .fill 1dff .fill 9180 @@ -28715,7 +30327,7 @@ .fill 9180 .fill 1dff .fill 9380 -.fill cbb7 +.fill cbb0 .fill 1d82 .fill 1080 .fill a40d @@ -28755,7 +30367,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 6859 +.fill 6eae .fill c300 .fill 1d81 .fill 6380 @@ -28776,7 +30388,7 @@ .fill 9180 .fill 1dff .fill 9380 -.fill cb7a +.fill cb73 .fill 1d82 .fill 1080 .fill a437 @@ -28791,7 +30403,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 68ac +.fill 6f00 .fill c300 .fill 1d81 .fill 6380 @@ -28804,7 +30416,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7847 +.fill 7e8e .fill 6000 .fill 6380 .fill 1d81 @@ -28812,7 +30424,7 @@ .fill 9180 .fill 1dff .fill 9380 -.fill caaa +.fill caa7 .fill 1d82 .fill 1080 .fill a412 @@ -28846,7 +30458,7 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 68ac +.fill 6f00 .fill c300 .fill 1d81 .fill 6380 @@ -28854,7 +30466,7 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 7850 +.fill 7e97 .fill 1dff .fill 9180 .fill 10d0 @@ -28873,7 +30485,7 @@ .fill 9040 .fill 4001 .fill ae01 -.fill 7850 +.fill 7e97 .fill 6000 .fill 1dff .fill 9180 @@ -28886,13 +30498,13 @@ .fill 9180 .fill 1dff .fill 9380 -.fill ca8b +.fill ca87 .fill 1d82 .fill 1080 .fill a40c .fill 4001 .fill ae01 -.fill 7850 +.fill 7e97 .fill 1dff .fill 9180 .fill 10d0 @@ -28904,7 +30516,7 @@ .fill ae00 .fill 4601 .fill ae01 -.fill 7275 +.fill 78c1 .fill b600 .fill 10d0 .fill 11fe @@ -28912,7 +30524,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7850 +.fill 7e97 .fill 6000 .fill 6380 .fill 1d81 @@ -28969,7 +30581,7 @@ .fill 9180 .fill 1dff .fill 9380 -.fill cab9 +.fill cab2 .fill 1d82 .fill 1080 .fill aa1a @@ -28987,7 +30599,7 @@ .fill 9180 .fill 1dff .fill 9380 -.fill caa7 +.fill caa0 .fill 1d82 .fill 2380 .fill 3100 @@ -29019,7 +30631,7 @@ .fill a405 .fill 4601 .fill ae01 -.fill 7275 +.fill 78c1 .fill b600 .fill ae00 .fill 10d0 @@ -29048,7 +30660,7 @@ .fill 9180 .fill 1dff .fill 9380 -.fill ca6a +.fill ca63 .fill 1d82 .fill 1080 .fill a421 @@ -29059,7 +30671,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 7847 +.fill 7e8e .fill 6000 .fill 6380 .fill 1d81 @@ -29067,7 +30679,7 @@ .fill 9180 .fill 1dff .fill 9380 -.fill ca57 +.fill ca50 .fill 1d82 .fill 1080 .fill a402 @@ -29098,7 +30710,7 @@ .fill 9180 .fill 1dff .fill 9380 -.fill ca38 +.fill ca31 .fill 1d82 .fill 1080 .fill aa19 @@ -29115,7 +30727,7 @@ .fill 9180 .fill 1dff .fill 9380 -.fill ca27 +.fill ca20 .fill 1d82 .fill 2380 .fill 3100 @@ -29144,7 +30756,7 @@ .fill 9180 .fill 1dff .fill 9380 -.fill c9df +.fill c9d9 .fill 1d82 .fill 1080 .fill a41a @@ -29162,7 +30774,7 @@ .fill 9180 .fill 1dff .fill 9380 -.fill c94c +.fill c949 .fill 1d82 .fill 2380 .fill 3100 @@ -29218,7 +30830,7 @@ .fill 9180 .fill 1dff .fill 9380 -.fill c9c0 +.fill c9b9 .fill 1d82 .fill 1080 .fill a410 @@ -29259,14 +30871,14 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 41ab +.fill 4609 .fill c300 .fill 1d84 .fill 1080 .fill a41a .fill 4001 .fill ae01 -.fill 7850 +.fill 7e97 .fill 1dff .fill 9180 .fill 10d0 @@ -29296,17 +30908,17 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 8ebf +.fill 962e .fill 6380 .fill 1d81 .fill 9040 .fill 4601 .fill ae01 -.fill 6c57 +.fill 72a7 .fill b600 .fill 4001 .fill ae01 -.fill 8b59 +.fill 92c0 .fill 1dff .fill 9180 .fill 4601 @@ -29329,7 +30941,7 @@ .fill 1dfe .fill 4001 .fill ae01 -.fill 8ee3 +.fill 9652 .fill 1dff .fill 9180 .fill 4601 @@ -29339,7 +30951,7 @@ .fill 1d81 .fill 4001 .fill ae01 -.fill 8ee8 +.fill 9657 .fill 1dff .fill 9180 .fill 4601 @@ -29349,7 +30961,7 @@ .fill 1d81 .fill 4001 .fill ae01 -.fill 8f25 +.fill 9694 .fill 1dff .fill 9180 .fill 4601 @@ -29363,7 +30975,7 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 8f5d +.fill 96cc .fill 6380 .fill 1d81 .fill 9040 @@ -29389,21 +31001,21 @@ .fill 9180 .fill 4001 .fill ae01 -.fill 8f8b +.fill 96fa .fill 1dff .fill 9180 .fill 4601 .fill ae01 -.fill 0b65 +.fill 0d94 .fill c300 .fill 1d84 .fill 2180 .fill 1181 .fill 1080 -.fill a455 +.fill a452 .fill 4001 .fill ae01 -.fill 8f91 +.fill 9700 .fill 1dff .fill 9180 .fill 4601 @@ -29417,9 +31029,8 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 6088 +.fill 66eb .fill c300 -.fill 1d80 .fill 6380 .fill 1d81 .fill 9040 @@ -29429,16 +31040,14 @@ .fill 1dff .fill 9180 .fill 2180 -.fill 1182 -.fill 3100 -.fill 1181 +.fill 11fe .fill 6380 .fill 1d81 .fill 1dff .fill 9180 .fill 1dff .fill 9380 -.fill c8e4 +.fill c8e0 .fill 1d82 .fill 1080 .fill a406 @@ -29466,7 +31075,7 @@ .fill a40b .fill 4001 .fill ae01 -.fill 8f97 +.fill 9706 .fill 1dff .fill 9180 .fill 4601 @@ -29482,10 +31091,10 @@ .fill 9180 .fill 4601 .fill ae01 -.fill 524a +.fill 58b4 .fill c300 .fill 1d81 -.fill afa7 +.fill afaa .fill 2180 .fill ae01 .fill 2180 @@ -29500,7 +31109,6 @@ .fill 1dff .fill 9b80 .fill 1ae0 -.fill 1d80 .fill 10d0 .fill 1182 .fill 6000 @@ -29543,7 +31151,6 @@ .fill 1dff .fill 9b80 .fill 1ae0 -.fill 1d80 .fill 10d0 .fill 1182 .fill 6000 @@ -29586,7 +31193,6 @@ .fill 1dff .fill 9b80 .fill 1ae0 -.fill 1d80 .fill 10d0 .fill 1182 .fill 6000 @@ -29629,7 +31235,6 @@ .fill 1dff .fill 9b80 .fill 1ae0 -.fill 1d80 .fill 10d0 .fill 1182 .fill 6000 @@ -29672,7 +31277,6 @@ .fill 1dff .fill 9b80 .fill 1ae0 -.fill 1d80 .fill 10d0 .fill 1182 .fill 6000 @@ -29704,7 +31308,6 @@ .fill 1dff .fill 9b80 .fill 1ae0 -.fill 1d80 .fill 10d0 .fill 1182 .fill 6000 @@ -29736,7 +31339,7 @@ .fill 1dff .fill 9b80 .fill 1ae0 -.fill 1dff +.fill 1dfe .fill 10d0 .fill 11ff .fill 1dff @@ -29746,62 +31349,32 @@ .fill 1d81 .fill 9040 .fill 10d0 -.fill 1183 -.fill 6000 +.fill 11fe .fill 1dff .fill 9180 .fill 2180 -.fill 6380 -.fill 1d81 -.fill 1dff -.fill 9180 -.fill 1dff -.fill 9380 -.fill cf24 -.fill 1d82 -.fill 1080 -.fill a40d -.fill 10d0 -.fill 1183 -.fill 1dff -.fill 9180 -.fill 10d0 -.fill 1183 -.fill 6000 -.fill 3100 -.fill 1181 -.fill 6380 -.fill 1d81 -.fill 9040 -.fill ae0c -.fill 10d0 -.fill 1182 -.fill 1dff -.fill 9180 -.fill 10d0 -.fill 1182 -.fill 6000 -.fill 3100 .fill 1181 .fill 6380 .fill 1d81 .fill 9040 .fill 10d0 +.fill 11fe +.fill 6000 +.fill 1080 +.fill a445 +.fill 10d0 .fill 1183 .fill 6000 .fill 1dff .fill 9180 -.fill 2180 +.fill 10d0 +.fill 11fe +.fill 6000 .fill 6380 .fill 1d81 -.fill 1dff -.fill 9180 -.fill 1dff -.fill 9380 -.fill ced0 -.fill 1d82 +.fill 2010 .fill 1080 -.fill a41e +.fill a413 .fill 10d0 .fill 11ff .fill 1dff @@ -29820,18 +31393,44 @@ .fill 6380 .fill 1d81 .fill 9040 +.fill ae00 .fill 10d0 -.fill 1183 +.fill 1182 .fill 1dff .fill 9180 +.fill 10d0 +.fill 1182 .fill 6000 -.fill 1880 -.fill 1181 +.fill 1dff +.fill 9180 +.fill 10d0 +.fill 1182 +.fill 6000 +.fill 6380 +.fill 1d81 +.fill 1010 .fill 6380 .fill 1d81 .fill 9040 -.fill 10c0 -.fill afd2 +.fill 10d0 +.fill 11fe +.fill 1dff +.fill 9180 +.fill 10d0 +.fill 11fe +.fill 6000 +.fill 1dff +.fill 9180 +.fill 10d0 +.fill 11fe +.fill 6000 +.fill 6380 +.fill 1d81 +.fill 1010 +.fill 6380 +.fill 1d81 +.fill 9040 +.fill afb6 .fill 10d0 .fill 11ff .fill 6000 @@ -29850,6 +31449,30 @@ .fill 1ae0 .fill 1dff .fill 10d0 +.fill 1183 +.fill 6000 +.fill 1dff +.fill 9180 +.fill 2180 +.fill 11ff +.fill 6380 +.fill 1d81 +.fill 1dff +.fill 9180 +.fill 1dff +.fill 9380 +.fill cf42 +.fill 1d82 +.fill 1080 +.fill a407 +.fill 10d0 +.fill 1182 +.fill 6000 +.fill 3100 +.fill 1181 +.fill ae40 +.fill ae00 +.fill 10d0 .fill 11ff .fill 1dff .fill 9180 @@ -29871,7 +31494,7 @@ .fill 9180 .fill 1dff .fill 9380 -.fill cedd +.fill cecd .fill 1d82 .fill 1080 .fill a420 @@ -29936,12 +31559,12 @@ .fill 9180 .fill 1dff .fill 9380 -.fill cef2 +.fill cee0 .fill 1d82 .fill 1080 .fill a403 .fill 2180 -.fill ae8c +.fill ae81 .fill ae00 .fill 10d0 .fill 11ff @@ -29952,20 +31575,17 @@ .fill 6000 .fill 1dff .fill 9180 -.fill 2180 -.fill 6380 -.fill 1d81 -.fill 1dff -.fill 9180 -.fill 1dff -.fill 9380 -.fill ce2f -.fill 1d82 -.fill 1dff -.fill 9180 .fill 10d0 .fill 1183 .fill 6000 +.fill 6380 +.fill 1d81 +.fill 1dff +.fill 9180 +.fill 1dff +.fill 9380 +.fill c8cd +.fill 1d82 .fill 1dff .fill 9180 .fill 2180 @@ -29975,15 +31595,7 @@ .fill 9180 .fill 1dff .fill 9380 -.fill ce1f -.fill 1d82 -.fill 6380 -.fill 1d81 -.fill 1dff -.fill 9180 -.fill 1dff -.fill 9380 -.fill cee3 +.fill ce14 .fill 1d82 .fill 6380 .fill 1d81 @@ -30000,7 +31612,7 @@ .fill 9180 .fill 1dff .fill 9380 -.fill ce31 +.fill ce2d .fill 1d82 .fill 1080 .fill a40d @@ -30029,7 +31641,7 @@ .fill 9180 .fill 1dff .fill 9380 -.fill ce14 +.fill ce10 .fill 1d82 .fill 1080 .fill a40d @@ -30060,7 +31672,7 @@ .fill 6000 .fill 1dff .fill 9180 -.fill cf26 +.fill cf19 .fill 1d82 .fill 6380 .fill 1d81 @@ -30093,7 +31705,6 @@ .fill 1dff .fill 9b80 .fill 1ae0 -.fill 1d80 .fill 10d0 .fill 1183 .fill 6000 @@ -30106,7 +31717,7 @@ .fill 9180 .fill 1dff .fill 9380 -.fill ce48 +.fill ce42 .fill 1d82 .fill 1080 .fill a403 @@ -30133,11 +31744,11 @@ .fill 6000 .fill 1dff .fill 9180 -.fill cf28 +.fill cf34 .fill 1d82 .fill 1dff .fill 9180 -.fill ce69 +.fill ce61 .fill 1d82 .fill 6380 .fill 1d81 @@ -30157,7 +31768,6 @@ .fill 1dff .fill 9b80 .fill 1ae0 -.fill 1d80 .fill 10d0 .fill 1182 .fill 6000 @@ -30185,7 +31795,6 @@ .fill 1dff .fill 9b80 .fill 1ae0 -.fill 1d80 .fill 10d0 .fill 1183 .fill 6000 @@ -30196,7 +31805,7 @@ .fill 6000 .fill 1dff .fill 9180 -.fill cfd3 +.fill cfd5 .fill 1d82 .fill 1dff .fill 9180 @@ -30228,7 +31837,6 @@ .fill 1dff .fill 9b80 .fill 1ae0 -.fill 1d80 .fill 10d0 .fill 1183 .fill 6000 @@ -30241,7 +31849,7 @@ .fill 9180 .fill 1dff .fill 9380 -.fill cd15 +.fill cd16 .fill 1d82 .fill 1080 .fill aa19 @@ -30352,7 +31960,7 @@ .fill 9180 .fill 1dff .fill 9380 -.fill cca6 +.fill cca7 .fill 1d82 .fill 1080 .fill aa19 @@ -30386,7 +31994,7 @@ .fill 1080 .fill a403 .fill 2180 -.fill ae96 +.fill ae94 .fill ae00 .fill 10d0 .fill 1183 @@ -30403,7 +32011,7 @@ .fill cca1 .fill 1d82 .fill 1080 -.fill a480 +.fill a47e .fill 10d0 .fill 11ff .fill 1dff @@ -30433,19 +32041,17 @@ .fill 9180 .fill 1dff .fill 9380 -.fill cc55 +.fill cc56 .fill 1d82 .fill 1080 -.fill a433 +.fill a431 .fill 10d0 .fill 1182 .fill 1dff .fill 9180 .fill 4001 .fill ae01 -.fill 4000 -.fill 3100 -.fill 1181 +.fill c000 .fill 1dff .fill 9180 .fill 10d0 @@ -30479,7 +32085,7 @@ .fill 9180 .fill 1dff .fill 9380 -.fill cdce +.fill cddf .fill 1d82 .fill 6380 .fill 1d81 @@ -30515,7 +32121,7 @@ .fill 9180 .fill 1dff .fill 9380 -.fill cdaa +.fill cdbb .fill 1d82 .fill 6380 .fill 1d81 @@ -30531,7 +32137,7 @@ .fill 1d81 .fill 9040 .fill 10c0 -.fill af70 +.fill af72 .fill 10d0 .fill 1182 .fill 6000 @@ -30801,6 +32407,7 @@ .fill 0000 .fill 0000 .fill 0000 +.fill 0000 .fill 0030 .fill 0078 .fill 0000 @@ -31105,6 +32712,34 @@ .fill 0073 .fill 0020 .fill 0028 +.fill 006e +.fill 0061 +.fill 0074 +.fill 0069 +.fill 0076 +.fill 0065 +.fill 0020 +.fill 0062 +.fill 006f +.fill 0062 +.fill 0033 +.fill 0032 +.fill 0020 +.fill 0069 +.fill 006d +.fill 0061 +.fill 0067 +.fill 0065 +.fill 0029 +.fill 0000 +.fill 0020 +.fill 0077 +.fill 006f +.fill 0072 +.fill 0064 +.fill 0073 +.fill 0020 +.fill 0028 .fill 0070 .fill 0072 .fill 006f @@ -31726,25 +33361,14 @@ .fill 006f .fill 0072 .fill 0020 -.fill 0073 -.fill 006f -.fill 0075 -.fill 0072 -.fill 0063 -.fill 0065 -.fill 002f .fill 0063 .fill 006f -.fill 0064 -.fill 0065 -.fill 002f -.fill 006e -.fill 0065 -.fill 0073 -.fill 0074 +.fill 006d +.fill 0070 .fill 0069 -.fill 006e -.fill 0067 +.fill 006c +.fill 0065 +.fill 0072 .fill 0020 .fill 006c .fill 0069 @@ -31760,6 +33384,21 @@ .fill 0064 .fill 0065 .fill 0064 +.fill 0020 +.fill 006e +.fill 0065 +.fill 0061 +.fill 0072 +.fill 0020 +.fill 0074 +.fill 006f +.fill 006b +.fill 0065 +.fill 006e +.fill 0020 +.fill 0027 +.fill 0000 +.fill 0027 .fill 002e .fill 0000 .fill 003a @@ -32661,14 +34300,25 @@ .fill 0020 .fill 0063 .fill 0063 -.fill 0020 -.fill 006f -.fill 0072 +.fill 002c .fill 0020 .fill 006c .fill 006f .fill 0061 .fill 0064 +.fill 002c +.fill 0020 +.fill 006f +.fill 0072 +.fill 0020 +.fill 0069 +.fill 006d +.fill 0070 +.fill 006f +.fill 0072 +.fill 0074 +.fill 0033 +.fill 0032 .fill 0020 .fill 0066 .fill 0069 @@ -32749,6 +34399,265 @@ .fill 0074 .fill 0020 .fill 0000 +.fill 0043 +.fill 0061 +.fill 006e +.fill 006e +.fill 006f +.fill 0074 +.fill 0020 +.fill 0069 +.fill 006d +.fill 0070 +.fill 006f +.fill 0072 +.fill 0074 +.fill 003a +.fill 0020 +.fill 0069 +.fill 006e +.fill 0076 +.fill 0061 +.fill 006c +.fill 0069 +.fill 0064 +.fill 0020 +.fill 006e +.fill 0061 +.fill 006d +.fill 0065 +.fill 002c +.fill 0020 +.fill 0064 +.fill 0075 +.fill 0070 +.fill 006c +.fill 0069 +.fill 0063 +.fill 0061 +.fill 0074 +.fill 0065 +.fill 0020 +.fill 0066 +.fill 0069 +.fill 006c +.fill 0065 +.fill 002c +.fill 0020 +.fill 006f +.fill 0072 +.fill 0020 +.fill 0061 +.fill 006c +.fill 006c +.fill 0020 +.fill 0038 +.fill 0020 +.fill 0073 +.fill 006c +.fill 006f +.fill 0074 +.fill 0073 +.fill 0020 +.fill 0061 +.fill 0072 +.fill 0065 +.fill 0020 +.fill 0075 +.fill 0073 +.fill 0065 +.fill 0064 +.fill 002e +.fill 0000 +.fill 0043 +.fill 0061 +.fill 006e +.fill 006e +.fill 006f +.fill 0074 +.fill 0020 +.fill 0072 +.fill 0065 +.fill 0061 +.fill 0064 +.fill 0020 +.fill 0068 +.fill 006f +.fill 0073 +.fill 0074 +.fill 0020 +.fill 0061 +.fill 0070 +.fill 0070 +.fill 0020 +.fill 0069 +.fill 006d +.fill 0061 +.fill 0067 +.fill 0065 +.fill 0020 +.fill 0070 +.fill 0061 +.fill 0074 +.fill 0068 +.fill 002e +.fill 0000 +.fill 004e +.fill 006f +.fill 0074 +.fill 0020 +.fill 0065 +.fill 006e +.fill 006f +.fill 0075 +.fill 0067 +.fill 0068 +.fill 0020 +.fill 0052 +.fill 0041 +.fill 004d +.fill 0020 +.fill 0066 +.fill 0069 +.fill 006c +.fill 0065 +.fill 0073 +.fill 0079 +.fill 0073 +.fill 0074 +.fill 0065 +.fill 006d +.fill 0020 +.fill 0073 +.fill 0070 +.fill 0061 +.fill 0063 +.fill 0065 +.fill 0020 +.fill 0066 +.fill 006f +.fill 0072 +.fill 0020 +.fill 0074 +.fill 0068 +.fill 0069 +.fill 0073 +.fill 0020 +.fill 0061 +.fill 0070 +.fill 0070 +.fill 0020 +.fill 0069 +.fill 006d +.fill 0061 +.fill 0067 +.fill 0065 +.fill 002e +.fill 0000 +.fill 0049 +.fill 006e +.fill 0076 +.fill 0061 +.fill 006c +.fill 0069 +.fill 0064 +.fill 002c +.fill 0020 +.fill 0074 +.fill 0072 +.fill 0075 +.fill 006e +.fill 0063 +.fill 0061 +.fill 0074 +.fill 0065 +.fill 0064 +.fill 002c +.fill 0020 +.fill 0063 +.fill 006f +.fill 0072 +.fill 0072 +.fill 0075 +.fill 0070 +.fill 0074 +.fill 002c +.fill 0020 +.fill 006f +.fill 0072 +.fill 0020 +.fill 0075 +.fill 006e +.fill 0073 +.fill 0075 +.fill 0070 +.fill 0070 +.fill 006f +.fill 0072 +.fill 0074 +.fill 0065 +.fill 0064 +.fill 0020 +.fill 0042 +.fill 0033 +.fill 0032 +.fill 004b +.fill 0020 +.fill 0061 +.fill 0070 +.fill 0070 +.fill 0020 +.fill 0069 +.fill 006d +.fill 0061 +.fill 0067 +.fill 0065 +.fill 002e +.fill 0000 +.fill 0049 +.fill 006d +.fill 0070 +.fill 006f +.fill 0072 +.fill 0074 +.fill 0065 +.fill 0064 +.fill 0020 +.fill 006e +.fill 0061 +.fill 0074 +.fill 0069 +.fill 0076 +.fill 0065 +.fill 0020 +.fill 0061 +.fill 0070 +.fill 0070 +.fill 0020 +.fill 0061 +.fill 0073 +.fill 0020 +.fill 0000 +.fill 002e +.fill 0020 +.fill 0052 +.fill 0075 +.fill 006e +.fill 0020 +.fill 0069 +.fill 0074 +.fill 0020 +.fill 0077 +.fill 0069 +.fill 0074 +.fill 0068 +.fill 003a +.fill 0020 +.fill 0072 +.fill 0075 +.fill 006e +.fill 0020 +.fill 0000 .fill 0048 .fill 0065 .fill 0061 @@ -34368,7 +36277,7 @@ .fill 0020 .fill 0030 .fill 0078 -.fill 0043 +.fill 0044 .fill 0030 .fill 0030 .fill 0030 @@ -34397,23 +36306,17 @@ .fill 006c .fill 0079 .fill 0020 -.fill 0061 -.fill 0074 +.fill 0069 +.fill 006e .fill 0020 -.fill 0030 -.fill 0078 -.fill 0043 -.fill 0030 -.fill 0030 -.fill 0030 -.fill 002e -.fill 002e -.fill 0030 -.fill 0078 -.fill 0044 -.fill 0046 -.fill 0046 -.fill 0046 +.fill 0068 +.fill 0065 +.fill 0061 +.fill 0070 +.fill 0020 +.fill 0052 +.fill 0041 +.fill 004d .fill 002e .fill 0020 .fill 0070 @@ -34483,14 +36386,6 @@ .fill 0072 .fill 006f .fill 0020 -.fill 0031 -.fill 002e -.fill 002e -.fill 0038 -.fill 0031 -.fill 0039 -.fill 0032 -.fill 0020 .fill 0068 .fill 0065 .fill 0061 @@ -35886,19 +37781,27 @@ .fill 0073 .fill 0065 .fill 0020 -.fill 0031 -.fill 002e -.fill 002e -.fill 0038 -.fill 0031 -.fill 0039 -.fill 0032 +.fill 0061 +.fill 0020 +.fill 0070 +.fill 006f +.fill 0073 +.fill 0069 +.fill 0074 +.fill 0069 +.fill 0076 +.fill 0065 .fill 0020 .fill 0077 .fill 006f .fill 0072 .fill 0064 -.fill 0073 +.fill 0020 +.fill 0063 +.fill 006f +.fill 0075 +.fill 006e +.fill 0074 .fill 003b .fill 0020 .fill 006d diff --git a/kernel/API.md b/kernel/API.md index 719dbc0..9e1502e 100644 --- a/kernel/API.md +++ b/kernel/API.md @@ -40,7 +40,9 @@ The kernel-only `bob_snapshot(int *descriptor, int operation)` is trap 7. Operation 0 saves; 1 restores. The four-word descriptor contains pointers to the 192-word names table, then eight-word length, kind and used tables. File contents occupy the fixed `0xF000..0xFFFF` region. Descriptors can be on the -kernel stack; tables must be disjoint and below `0x9000`. The host validates +kernel stack; tables must be disjoint and below `0xA000` in bob16 mode. In +bob32 mode they may be in low kernel RAM or in the loaded kernel image, which +now resides above `0x10000`. The host validates metadata, payload checksum and complete file length before committing a restore. Returns 0 on success, 1 when restored binaries were omitted because the kernel changed, -1 for storage errors, -2 for invalid data and -3 for invalid arguments. @@ -52,14 +54,16 @@ user-facing save/restore workflow. | --- | --- | | `int strlen(char *text)` | Count words before the zero terminator | | `int strcmp(char *a, char *b)` | Negative, zero or positive according to the first differing ASCII character | -| `void memcpy(int *dst, int *src, int count)` | Copy count words forward; source and destination must not overlap | -| `void memset(int *dst, int value, int count)` | Fill count words with a 16-bit value | +| `void memcpy(void *dst, void *src, int count)` | Copy count words forward; source and destination must not overlap | +| `void memset(void *dst, int value, int count)` | Fill count words with a 16-bit value | | `int *alloc(int words)` | Return a zeroed heap block, or null for an invalid size or exhaustion | String routines require terminated strings. Memory routines require valid regions; they do not perform bounds checks for kernel callers. Counts are words, -not host bytes. Allocation reserves from 0xC000 upward, with 8,192 total words. -The heap is shared with loaded programs. There is no free or reset operation. +not host bytes. The bob16 heap reserves 8,192 words from 0xC000; bob32 reserves +4,096 words from 0xD000 so the enlarged kernel and compatibility-program stack +fit below it. The heap is shared with loaded programs. There is no free or reset +operation. ## RAM filesystem @@ -67,9 +71,13 @@ The heap is shared with loaded programs. There is no free or reset operation. `file_content(slot)` return addresses into the filesystem buffers. `file_write(name, data, length, kind)` copies data and creates/replaces a file, returning its slot or -1 for a bad name, length or a full table. Kind 0 is text; -kind 1 is machine code. Its copy appends a zero word, which is not part of length. -Names hold at most 23 characters and data at most 511 words. Valid slot indices -are 0..7. These routines are internal kernel APIs; callers must check slots. +kind 1 is machine code, kind 2 is resident bob32 C code, and kind 3 is a packed +native B32K v2 image. Its copy appends a zero word, which is not part of length. +Names hold at most 23 characters. bob16 retains eight fixed 511-word slots; +bob32 packs files into a shared 4,096-word content region. Text files remain +limited to 511 words; resident programs and native images can use the remaining +shared capacity (up to 4,095 words per file). Valid slot indices are 0..7. +These are internal kernel APIs. Failed size/name validation does not overwrite an existing file. Edits start with the existing file contents in a scratch buffer and commit on :w, :wq or a @@ -89,27 +97,46 @@ kernel stack reserved at `0xE600..0xEFFF`. Input buffers are `0x0100..0x01FF`. ## Program execution -`bob_run(entry)` invokes emulator trap 6. Valid entries are 0x9000..0xBDFF. -The shell's run_file copies a binary RAM file to 0x9000 after clearing the -12,288-word program region. Entry 0x9000 executes with r6=0xC000, r5=0, and -r7 pointing to the reserved return sentinel. The shell CPU state is restored -on completion. RET or TRAP 0 ends the program. +`bob_run(entry)` invokes emulator trap 6. In bob16 mode valid entries are +0xA000..0xBDFF. In bob32 mode kind-1 legacy entries are 0xC200..0xCFFF and +kind-2 native entries are 0x20000..0xEFFFF when the caller explicitly supplies +a wide entry. The shell places legacy programs at 0xC200 in bob32 mode to avoid +overwriting the bob32 kernel image, and native bob32 files at 0x20000. The entry executes +with r6 at the top of its protected stack region, r5=0, and r7 pointing to the +reserved return sentinel. In bob32 mode kind-1 apps use `0xC200..0xCFFF` because +the expanded kernel occupies the old bob16 program window. Compatibility apps +retain access to the shared `0xD000..0xDFFF` heap. The shell CPU state is +restored on completion. RET or TRAP 0 ends the program. Return values -1, -2 and -3 are reserved for invalid entry/nested execution, program fault, and timeout. Otherwise r0 is the program's exit status. A program returning one of those reserved values is indistinguishable from that service status. Five million cycles is the per-run limit. Programs may write only -0x9000..0xDFFF; kernel code, RAM files and the shell stack are protected from -their stores. Program and heap contents themselves are not private or restored. +their application and stack regions; bob16 and compatibility applications may +also write the shared heap. Kernel code, RAM files and the shell stack +are protected from their stores. Program and heap contents themselves are not +private or restored. -The resident compiler uses variable words at 0x9800..0x980F and inline string -data in its program image. Its files can contain at most 511 code/data words, -so these variable words do not overlap its code. Its console/helper calls use -the separate program stack. Compiled resident programs depend on addresses in -the current kernel and should not be reused with a different kernel build. +The resident compiler uses variable words at 0x9800..0x980F in bob16 mode and +0xF0000..0xF000F in bob32 mode; string data is inline in the program image. +In bob16 its files can contain at most 511 code/data words; bob32 compiler output +uses the available packed filesystem capacity. Console and arithmetic calls +use the separate program stack. Compiled resident programs depend on addresses +in the current kernel and should not be reused with a different kernel build. `bob_address(function_name)` is a host-compiler intrinsic that inserts a kernel function address. `bob_call(entry)` is an unchecked direct call for trusted kernel code; ordinary shell programs use bob_run for recovery and write checks. See [the OS guide](../C_OS.md) for commands, examples and C subset limits. + +In bob32 mode, `import32 HOST_PATH NAME` validates and packs a B32K v2 image +into a guest RAM file; `run NAME` loads and executes it. B32S version 2 +snapshots preserve packed files; version 1 fixed-slot snapshots remain readable +and are converted to the packed layout on restore. `run32 HOST_PATH` remains +available for direct host-path launches. + +Native C applications can include `bob_string.h` for small app-side string +and parsing helpers. It provides bounded integer formatting, status-returning +decimal/hex parsing, and in-place quoted tokenization without depending on the +kernel's private runtime functions. diff --git a/kernel/bob.h b/kernel/bob.h index be953bf..8c0332f 100644 --- a/kernel/bob.h +++ b/kernel/bob.h @@ -2,11 +2,14 @@ #define BOB_KERNEL_H /* Guest services. bob16 int, char and pointers occupy one 16-bit word. */ void bob_putc(int character); -void bob_puts(char *text); +void bob_puts(const char *text); void bob_gets(char *buffer, int capacity); void bob_halt(void); int bob_getc(void); int bob_run(int entry); +int bob_run_image(const char *path); +int bob_import_image(int *descriptor); +int bob_run_native(const int *descriptor); int bob_snapshot(int *descriptor, int operation); int bob_key(void); int bob_terminal(void); diff --git a/kernel/bob_string.h b/kernel/bob_string.h new file mode 100644 index 0000000..56f40b2 --- /dev/null +++ b/kernel/bob_string.h @@ -0,0 +1,125 @@ +#ifndef BOB_STRING_H +#define BOB_STRING_H + +/* Small word-addressed string helpers for native bob applications. */ +int bob_strlen(const char *text) { + int length; length = 0; + while (text[length]) length++; + return length; +} + +char *bob_strcpy(char *destination, const char *source) { + int i; i = 0; + while (source[i]) { destination[i] = source[i]; i++; } + destination[i] = 0; + return destination; +} + +int bob_strcmp(const char *left, const char *right) { + int i; i = 0; + while (left[i] && left[i] == right[i]) i++; + return left[i] - right[i]; +} + +char *bob_strcat(char *destination, const char *source) { + int i; int j; + i = bob_strlen(destination); j = 0; + while (source[j]) destination[i++] = source[j++]; + destination[i] = 0; + return destination; +} + +char *bob_strchr(const char *text, int character) { + while (*text && *text != character) text++; + if (*text == character) return (char *)text; + return 0; +} + +int bob_isspace(int character) { + return character == ' ' || character == '\t' || character == '\n' || + character == '\r' || character == '\v' || character == '\f'; +} + +/* Decimal and 0x-prefixed signed integers. valid is cleared on any error. */ +int bob_parse_int(const char *text, int *valid) { + int negative; int base; int digit; int digits; + unsigned int value; unsigned int limit; unsigned int radix; + const char *cursor; + *valid = 0; cursor = text; negative = 0; base = 10; digits = 0; value = 0; + while (bob_isspace(*cursor)) cursor++; + if (*cursor == '+' || *cursor == '-') { + negative = *cursor == '-'; cursor++; + } + if (cursor[0] == '0' && (cursor[1] == 'x' || cursor[1] == 'X')) { + base = 16; cursor += 2; + } + radix = (unsigned int)base; + limit = negative ? 0x80000000U : 0x7fffffffU; + while (*cursor) { + if (bob_isspace(*cursor)) break; + digit = *cursor; + if (digit >= '0' && digit <= '9') digit -= '0'; + else if (digit >= 'a' && digit <= 'f') digit = digit - 'a' + 10; + else if (digit >= 'A' && digit <= 'F') digit = digit - 'A' + 10; + else return 0; + if (digit >= base || value > limit / radix || + (value == limit / radix && (unsigned int)digit > limit % radix)) return 0; + value = value * radix + (unsigned int)digit; + digits++; cursor++; + } + while (bob_isspace(*cursor)) cursor++; + if (!digits || *cursor) return 0; + *valid = 1; + if (!negative) return (int)value; + if (value == 0x80000000U) return -2147483647 - 1; + return -(int)value; +} + +/* Returns the character count, or -1 when the destination is too small. */ +int bob_format_int(int value, char *destination, int capacity) { + char reverse[11]; + unsigned int magnitude; int negative; int count; int i; + if (capacity < 1) return -1; + negative = value < 0; + magnitude = negative ? 0U - (unsigned int)value : (unsigned int)value; + count = 0; + do { + reverse[count++] = (char)('0' + magnitude % 10U); + magnitude /= 10U; + } while (magnitude); + if (count + negative + 1 > capacity) return -1; + i = 0; + if (negative) destination[i++] = '-'; + while (count) destination[i++] = reverse[--count]; + destination[i] = 0; + return i; +} + +/* In-place shell-like token reader: whitespace separates, quotes group, and + backslash quotes the next character. Returns 1/token, 0/end, or -1/bad quote. */ +int bob_token_next(char **cursor, char **token) { + char *scan; char *write; int quote; int character; + if (!cursor || !token || !*cursor) return -1; + scan = *cursor; + while (bob_isspace(*scan)) scan++; + if (!*scan) { *cursor = scan; *token = 0; return 0; } + write = scan; *token = write; quote = 0; + while (*scan) { + character = *scan; + if (quote) { + if (character == quote) { quote = 0; scan++; continue; } + if (character == '\\' && scan[1]) scan++; + } else { + if (bob_isspace(character)) break; + if (character == '"' || character == '\'') { quote = character; scan++; continue; } + if (character == '\\' && scan[1]) scan++; + } + *write++ = *scan++; + } + if (quote) { *token = 0; *cursor = scan; return -1; } + while (bob_isspace(*scan)) scan++; + *write = 0; *cursor = scan; + return 1; +} + +#endif diff --git a/kernel/compiler.c b/kernel/compiler.c index 8f710fd..e80bdb7 100644 --- a/kernel/compiler.c +++ b/kernel/compiler.c @@ -1,4 +1,4 @@ -/* Resident recursive-descent compiler. It emits bob16 machine words in RAM. */ +/* Resident recursive-descent compiler. It emits native instruction words in RAM. */ #define TOKEN_ID 256 #define TOKEN_NUMBER 257 #define TOKEN_STRING 258 @@ -20,11 +20,22 @@ #define TOKEN_AND_ASSIGN 274 #define TOKEN_OR_ASSIGN 275 #define TOKEN_XOR_ASSIGN 276 +#ifdef BOBC_WIDE +#define TOKEN_SHL_ASSIGN 277 +#define TOKEN_SHR_ASSIGN 278 +#endif #if BOBC_LEGACY #define CALL_R3 0xcb00 #else #define CALL_R3 0xc300 #endif +#ifdef BOBC_WIDE +#define CC_PROGRAM_BASE WIDE_PROGRAM_BASE +#define CC_VARIABLE_BASE WIDE_VARIABLE_BASE +#else +#define CC_PROGRAM_BASE PROGRAM_BASE +#define CC_VARIABLE_BASE 0x9800 +#endif char *cc_source; int cc_token; int cc_value; @@ -32,18 +43,26 @@ int cc_value; int cc_error; int cc_position; /* Editor and compiler run separately, so they share reserved scratch RAM. */ +#ifdef BOBC_WIDE +#define cc_code ((int *)WIDE_PROGRAM_BASE) +#else #define cc_code ((int *)0xe000) +#endif #define cc_names ((char *)0xe200) int cc_variables; int cc_error_offset; int cc_depth; char *cc_begin; +#ifdef BOBC_WIDE +int cc_scope_depth; +int cc_scope_floor[33]; +#endif int cc_alpha(int ch) { return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || ch == '_'; } int cc_digit(int ch) { return ch >= '0' && ch <= '9'; } void cc_fail(void) { if (!cc_error) cc_error_offset = (int)(cc_source - cc_begin); - cc_error = 1; + cc_error = 1; cc_token = 0; } void cc_next(void) { int ch; int count; int digit; int base; @@ -54,7 +73,7 @@ void cc_next(void) { } else if (cc_source[0] == '/' && cc_source[1] == '*') { cc_source = cc_source + 2; while (*cc_source && !(cc_source[0] == '*' && cc_source[1] == '/')) cc_source++; - if (!*cc_source) { cc_fail(); cc_token = 0; return; } + if (!*cc_source) { cc_fail(); return; } cc_source = cc_source + 2; } else break; } @@ -63,7 +82,7 @@ void cc_next(void) { if (cc_alpha(ch)) { count = 0; while (cc_alpha(*cc_source) || cc_digit(*cc_source)) { - if (count == 63) { cc_fail(); cc_token = 0; return; } + if (count == 63) { cc_fail(); return; } cc_text[count++] = *cc_source++; } cc_text[count] = 0; cc_token = TOKEN_ID; return; @@ -71,14 +90,22 @@ void cc_next(void) { if (cc_digit(ch)) { cc_value = 0; count = 0; base = 10; if (cc_source[0] == '0' && (cc_source[1] == 'x' || cc_source[1] == 'X')) { base = 16; cc_source = cc_source + 2; } + else if(ch == '0') base = 8; while (1) { digit = *cc_source; if (cc_digit(digit)) digit = digit - '0'; else if (base == 16 && digit >= 'a' && digit <= 'f') digit = digit - 'a' + 10; else if (base == 16 && digit >= 'A' && digit <= 'F') digit = digit - 'A' + 10; else break; + if(digit >= base) cc_fail(); +#ifdef BOBC_WIDE + if ((base == 10 && (cc_value > 214748364 || (cc_value == 214748364 && digit > 7))) || + (base == 16 && (count == 8 || (count == 0 && digit > 7))) || + (base == 8 && (cc_value > 268435455 || (cc_value == 268435455 && digit > 7)))) { cc_fail(); return; } +#else if ((base == 10 && (cc_value > 3276 || (cc_value == 3276 && digit > 7))) || - (base == 16 && count == 4)) { cc_fail(); cc_token = 0; return; } + (base == 16 && count == 4) || (base == 8 && (cc_value & -8192))) { cc_fail(); return; } +#endif cc_value = cc_value * base + digit; cc_source++; count++; } if (!count) cc_fail(); @@ -88,12 +115,18 @@ void cc_next(void) { cc_source++; count = 0; while (*cc_source && *cc_source != ch) { digit = *cc_source++; + if(digit == '\n' || digit == '\r') cc_fail(); if (digit == '\\') { if (!*cc_source) { cc_fail(); break; } digit = *cc_source++; if (digit == 'n') digit = '\n'; else if (digit == 't') digit = '\t'; - else if (digit != '\\' && digit != '"' && digit != '\'') { cc_fail(); break; } + else if (digit == 'r') digit = '\r'; + else if (digit == 'b') digit = '\b'; + else if (digit == 'a') digit = '\a'; + else if (digit == 'f') digit = '\f'; + else if (digit == 'v') digit = '\v'; + else if (digit != '\\' && digit != '"' && digit != '\'' && digit != '?') { cc_fail(); break; } } if (count == 63 || digit == 0) { cc_fail(); break; } cc_text[count++] = digit; @@ -104,6 +137,7 @@ void cc_next(void) { else cc_token = TOKEN_STRING; return; } + cc_text[0] = ch; cc_text[1] = 0; cc_source++; cc_token = ch; if (*cc_source == ch) { if (ch == '&') cc_token = TOKEN_AND; @@ -113,7 +147,16 @@ void cc_next(void) { else if (ch == '<') cc_token = TOKEN_SHL; else if (ch == '>') cc_token = TOKEN_SHR; else if (ch != '=') return; - if (ch != '=') { cc_source++; return; } + if (ch != '=') { + cc_source++; +#ifdef BOBC_WIDE + if ((cc_token == TOKEN_SHL || cc_token == TOKEN_SHR) && *cc_source == '=') { + cc_token = cc_token == TOKEN_SHL ? TOKEN_SHL_ASSIGN : TOKEN_SHR_ASSIGN; + cc_source++; + } +#endif + return; + } } if (*cc_source == '=') { if (ch == '=') cc_token = TOKEN_EQ; @@ -135,7 +178,12 @@ void cc_next(void) { int cc_is(char *name) { return cc_token == TOKEN_ID && strcmp(cc_text, name) == 0; } void cc_expect(int token) { if (cc_token != token) { cc_fail(); return; } cc_next(); } void cg_emit(int word) { + if(cc_error)return; +#ifdef BOBC_WIDE + if (cc_position >= FILE_WORDS - 1) { cc_fail(); return; } +#else if (cc_position >= 511) { cc_fail(); return; } +#endif cc_code[cc_position++] = word; } void cg_literal(int reg, int value) { cg_emit(0x4001 + reg * 512); cg_emit(0xae01); cg_emit(value); } @@ -143,18 +191,131 @@ void cg_push(void) { cg_emit(0x1dff); cg_emit(0x9180); } void cg_pop(void) { cg_emit(0x6380); cg_emit(0x1d81); } int cg_jump(int target) { int patch; patch = cc_position + 2; - cg_literal(3, PROGRAM_BASE + target); cg_emit(0xb600); return patch; + cg_literal(3, CC_PROGRAM_BASE + target); cg_emit(0xb600); return patch; } -void cg_patch(int patch) { if (!cc_error) cc_code[patch] = PROGRAM_BASE + cc_position; } +void cg_patch(int patch) { if (!cc_error) cc_code[patch] = CC_PROGRAM_BASE + cc_position; } void cg_call(int address, int args) { cg_literal(3, address); cg_emit(CALL_R3); cg_emit(0x1d80 + args); } int cg_if_zero(void) { cg_emit(0x1080); cg_emit(0xaa04); return cg_jump(0); } int cc_variable(char *name) { int i; +#ifdef BOBC_WIDE + for (i = cc_variables - 1; i >= 0; i--) if (strcmp(cc_names + i * NAME_WORDS, name) == 0) return i; +#else for (i = 0; i < cc_variables; i++) if (strcmp(cc_names + i * NAME_WORDS, name) == 0) return i; +#endif return -1; } +#ifdef BOBC_WIDE +int cc_variable_current_scope(char *name) { + int i; + for (i = cc_scope_floor[cc_scope_depth]; i < cc_variables; i++) + if (strcmp(cc_names + i * NAME_WORDS, name) == 0) return i; + return -1; +} +#endif +#ifdef BOBC_WIDE +int cc_function_find(char *name) { + int i; + for (i = 0; i < cc_function_count; i++) if (strcmp(cc_function_names[i], name) == 0) return i; + if (cc_function_count == 16 || strlen(name) >= 24) { cc_fail(); return -1; } + i = cc_function_count++; memcpy(cc_function_names[i], name, strlen(name) + 1); + cc_function_addresses[i] = -1; cc_function_parameters[i] = -1; + cc_function_call_parameters[i] = -1; + cc_function_parameter_array_mask[i] = 0; + cc_function_parameter_array_known[i] = 0; + cc_function_call_array_mask[i] = 0; + cc_function_call_array_known[i] = 0; + cc_function_call_array_conflicts[i] = 0; + cc_function_defined[i] = 0; cc_function_calls[i] = -1; + return i; +} +int cc_function_lookup(char *name) { + for (int i = 0; i < cc_function_count; i++) + if (strcmp(cc_function_names[i], name) == 0) return i; + return -1; +} +int cc_parameter_full_mask(int count) { return count ? (1 << count) - 1 : 0; } +int cc_function_array_signature_matches(int function, int count, int array_mask) { + int all; all = cc_parameter_full_mask(count); + if ((cc_function_parameter_array_known[function] & all) == all && + ((cc_function_parameter_array_mask[function] ^ array_mask) & all)) return 0; + if (cc_function_call_array_conflicts[function] & all) return 0; + if (((cc_function_call_array_mask[function] ^ array_mask) & cc_function_call_array_known[function] & all)) return 0; + return 1; +} +int cc_function_record_array_argument(int function, int parameter, int is_array) { + int bit; int is_known; int was_array; + bit = 1 << parameter; + if ((cc_function_parameter_array_known[function] & bit) && + !!(cc_function_parameter_array_mask[function] & bit) != is_array) return 0; + is_known = (cc_function_call_array_known[function] & bit) != 0; + was_array = (cc_function_call_array_mask[function] & bit) != 0; + if (is_known && was_array != is_array) cc_function_call_array_conflicts[function] |= bit; + else { + cc_function_call_array_known[function] |= bit; + if (is_array) cc_function_call_array_mask[function] |= bit; + } + return 1; +} +int cc_builtin_function(char *name) { + int function; + int address; + if (strcmp(name, "print") == 0) address = bob_address(print); + else if (strcmp(name, "println") == 0) address = bob_address(println); + else if (strcmp(name, "print_dec") == 0) address = bob_address(print_dec); + else if (strcmp(name, "print_hex") == 0) address = bob_address(print_hex); + else return -1; + function = cc_function_find(name); + if (function < 0) return -1; + cc_function_addresses[function] = address; + cc_function_parameters[function] = 1; + cc_function_parameter_array_known[function] = 1; + cc_function_defined[function] = 2; + return function; +} +void cc_function_value(int function) { + int patch; + cg_literal(0, cc_function_defined[function] == 2 ? cc_function_addresses[function] : + cc_function_defined[function] ? CC_PROGRAM_BASE + cc_function_addresses[function] : 0); + if (!cc_function_defined[function]) { + patch = cc_position - 1; + cc_code[patch] = cc_function_calls[function]; + cc_function_calls[function] = patch; + } +} +#endif +void cc_load_variable(int variable) { +#ifdef BOBC_WIDE + cg_emit(0x6140 | (cc_variable_offsets[variable] & 63)); +#else + cg_literal(0, CC_VARIABLE_BASE + variable); cg_emit(0x6000); +#endif +} +void cc_store_variable(int variable) { +#ifdef BOBC_WIDE + cg_emit(0x9140 | (cc_variable_offsets[variable] & 63)); +#else + cg_literal(1, CC_VARIABLE_BASE + variable); cg_emit(0x9040); +#endif +} +#ifdef BOBC_WIDE +void cc_array_index_address(int variable) { + cg_push(); + if (cc_array_flags[variable] == 2) { + cc_load_variable(variable); + cg_literal(1, 0); + cg_emit(0x1402); + } else { + cg_literal(1, 0); + cg_emit(0x1452); + cg_emit(0x15d0 | (cc_variable_offsets[variable] & 0x7f)); + } + cg_pop(); + cg_emit(0x1422); +} +#endif int cc_less(int a, int b) { return a < b; } int cc_greater(int a, int b) { return a > b; } int cc_less_equal(int a, int b) { return a <= b; } @@ -172,6 +333,48 @@ int cc_shift_left(int a, int b) { return a << b; } int cc_shift_right(int a, int b) { return a >> b; } int cc_truth(int a) { return !!a; } int cc_loop_depth; +int cc_expression_is_array; +#ifdef BOBC_WIDE +int cc_variable_offsets[16]; +int cc_array_flags[16]; +int cc_function_pointer_flags[16]; +int cc_function_pointer_parameters[16]; +int cc_function_count; +int cc_function_addresses[16]; +int cc_function_parameters[16]; +int cc_function_parameter_array_mask[16]; +int cc_function_parameter_array_known[16]; +int cc_function_call_parameters[16]; +int cc_function_call_array_mask[16]; +int cc_function_call_array_known[16]; +int cc_function_call_array_conflicts[16]; +int cc_function_defined[16]; +int cc_function_calls[16]; +int cc_return_chain; +int cc_local_count; +char cc_function_names[16][24]; +#endif +void cc_function_pointer_rhs(int variable) { +#ifdef BOBC_WIDE + int source_variable; int source_function; char source_name[64]; + if (cc_token == TOKEN_NUMBER && cc_value == 0) { cg_literal(0, 0); cc_next(); return; } + if (cc_token != TOKEN_ID || strlen(cc_text) >= sizeof(source_name)) { cc_fail(); return; } + memcpy(source_name, cc_text, strlen(cc_text) + 1); + source_variable = cc_variable(source_name); + if (source_variable >= 0) { + if (!cc_function_pointer_flags[source_variable] || + cc_function_pointer_parameters[source_variable] != cc_function_pointer_parameters[variable]) { cc_fail(); return; } + cc_load_variable(source_variable); cc_next(); return; + } + source_function = cc_function_lookup(source_name); + if (source_function < 0 || cc_function_parameters[source_function] < 0 || + cc_function_parameters[source_function] != cc_function_pointer_parameters[variable]) { cc_fail(); return; } + cc_function_value(source_function); cc_next(); + if (cc_token == '(') cc_fail(); +#else + (void)variable; +#endif +} #define cc_break_chain ((int *)0xe3c0) #define cc_continue_chain ((int *)0xe3d0) @@ -214,39 +417,163 @@ void cc_operation(int op) { void cc_expression(void); void cc_primary(void) { - int variable; int patch; int start; int count; int op; + int variable; int patch; int start; int count; int op; int indexed_array; +#ifdef BOBC_WIDE + int indirect_function; int argument_count; +#endif if (cc_error) return; cc_depth++; if (cc_depth > 32) { cc_fail(); return; } + cc_expression_is_array = 0; if (cc_token == TOKEN_NUMBER) { cg_literal(0, cc_value); cc_next(); } else if (cc_token == TOKEN_STRING) { - count = strlen(cc_text); /* Inline string data is skipped by an absolute jump. */ patch = cg_jump(0); start = cc_position; - for (variable = 0; variable <= count; variable++) cg_emit(cc_text[variable]); - cg_patch(patch); cg_literal(0, PROGRAM_BASE + start); cc_next(); + do { + count = strlen(cc_text); + for (variable = 0; variable < count; variable++) cg_emit(cc_text[variable]); + cc_next(); + } while (cc_token == TOKEN_STRING); + cg_emit(0); cg_patch(patch); cg_literal(0, CC_PROGRAM_BASE + start); } else if (cc_token == '(') { cc_next(); cc_expression(); cc_expect(')'); } else if (cc_token == '-' || cc_token == '!' || cc_token == '+' || cc_token == '~') { op = cc_token; cc_next(); cc_primary(); cg_push(); if (op == '-') cg_call(bob_address(cc_negate), 1); else if (op == '!') cg_call(bob_address(cc_not), 1); else { cg_emit(0x6180); cg_emit(0x1d81); if (op == '~') cg_emit(0x3100); } + cc_expression_is_array = 0; } else if (cc_token == TOKEN_INC || cc_token == TOKEN_DEC) { op = cc_token; cc_next(); variable = cc_variable(cc_text); if (cc_token != TOKEN_ID || variable < 0) { cc_fail(); return; } - cc_next(); cg_literal(0, 0x9800 + variable); cg_emit(0x6000); +#ifdef BOBC_WIDE + if (cc_array_flags[variable]) { + cc_next(); + if (cc_token != '[') { cc_fail(); return; } + cc_next(); cc_expression(); cc_expect(']'); + cc_array_index_address(variable); cg_emit(0x6080); + if (op == TOKEN_INC) cg_emit(0x1181); else cg_emit(0x11ff); + cg_emit(0x9080); cc_depth--; return; + } +#endif + cc_next(); cc_load_variable(variable); if (op == TOKEN_INC) cg_emit(0x1181); else cg_emit(0x11ff); - cg_literal(1, 0x9800 + variable); cg_emit(0x9040); + cc_store_variable(variable); } else if (cc_token == TOKEN_ID) { variable = cc_variable(cc_text); - if (variable < 0) { cc_fail(); return; } - cg_literal(0, 0x9800 + variable); cg_emit(0x6000); cc_next(); - if (cc_token == TOKEN_INC || cc_token == TOKEN_DEC) { - op = cc_token; cc_next(); cg_push(); - if (op == TOKEN_INC) cg_emit(0x1181); else cg_emit(0x11ff); - cg_literal(1, 0x9800 + variable); cg_emit(0x9040); - cg_emit(0x6180); cg_emit(0x1d81); + if (variable >= 0) { + indexed_array = 0; +#ifdef BOBC_WIDE + indirect_function = 0; +#endif + cc_next(); +#ifdef BOBC_WIDE + if (cc_array_flags[variable]) { + if (cc_token == '[') { + indexed_array = 1; + cc_next(); cc_expression(); cc_expect(']'); + cc_array_index_address(variable); cg_emit(0x6080); + cc_expression_is_array = 0; + } else { + if (cc_token == TOKEN_INC || cc_token == TOKEN_DEC) cc_fail(); + if (cc_array_flags[variable] == 2) cc_load_variable(variable); + else { + cg_literal(0, 0); cg_emit(0x1050); + cg_emit(0x11d0 | (cc_variable_offsets[variable] & 0x7f)); + } + cc_expression_is_array = 1; + } + } else { cc_load_variable(variable); cc_expression_is_array = 0; } +#else + cc_load_variable(variable); +#endif +#ifdef BOBC_WIDE + if (!cc_error && cc_function_pointer_flags[variable] && cc_token == '(') { + indirect_function = 1; cg_push(); cc_next(); argument_count = 0; + if (cc_token != ')') { + do { + if (argument_count == 16) { cc_fail(); return; } + cc_expression(); cg_push(); argument_count++; + if (cc_token != ',') break; + cc_next(); + } while (!cc_error); + } + cc_expect(')'); + if (argument_count != cc_function_pointer_parameters[variable]) cc_fail(); + cg_emit(0x6780 | (argument_count + 1)); + cg_emit(CALL_R3); cg_emit(0x1d80 + argument_count + 1); + cc_expression_is_array = 0; + } +#endif + if (!cc_error && indexed_array && (cc_token == TOKEN_INC || cc_token == TOKEN_DEC)) { + op = cc_token; cc_next(); cg_push(); + if (op == TOKEN_INC) cg_emit(0x1181); else cg_emit(0x11ff); + cg_emit(0x9080); cg_pop(); cg_emit(0x5020); cg_emit(0x1002); + } +#ifdef BOBC_WIDE + if (!cc_error && cc_function_pointer_flags[variable] && + (cc_token == TOKEN_INC || cc_token == TOKEN_DEC)) cc_fail(); +#endif + if (!cc_error && !indexed_array +#ifdef BOBC_WIDE + && !indirect_function && !cc_function_pointer_flags[variable] +#endif + && (cc_token == TOKEN_INC || cc_token == TOKEN_DEC)) { + op = cc_token; cc_next(); cg_push(); + if (op == TOKEN_INC) cg_emit(0x1181); else cg_emit(0x11ff); + cc_store_variable(variable); + cg_emit(0x6180); cg_emit(0x1d81); + } } +#ifdef BOBC_WIDE + else { + char name[64]; int function; int argument_count; int call_patch; + memcpy(name, cc_text, strlen(cc_text) + 1); + function = cc_function_lookup(name); + if (function < 0) function = cc_builtin_function(name); + if (function < 0) function = cc_function_find(name); + if (function < 0) return; + cc_next(); + if (cc_token != '(') { + if (cc_function_parameters[function] < 0) { cc_fail(); return; } + call_patch = cc_position + 2; + cg_literal(0, cc_function_defined[function] ? CC_PROGRAM_BASE + cc_function_addresses[function] : 0); + if (!cc_function_defined[function]) { + cc_code[call_patch] = cc_function_calls[function]; cc_function_calls[function] = call_patch; + } + } else { + cc_next(); argument_count = 0; + if (cc_token != ')') { + do { + if (argument_count == 16) { cc_fail(); return; } + cc_expression(); + if (!cc_function_record_array_argument(function, argument_count, cc_expression_is_array)) cc_fail(); + cg_push(); argument_count++; + if (cc_token != ',') break; + cc_next(); + } while (!cc_error); + } + cc_expect(')'); + if (cc_function_parameters[function] == -2) { + if (cc_function_defined[function]) { + if (cc_function_parameters[function] != argument_count) cc_fail(); + } else if (cc_function_call_parameters[function] < 0) + cc_function_call_parameters[function] = argument_count; + else if (cc_function_call_parameters[function] != argument_count) cc_fail(); + } else if (cc_function_parameters[function] < 0) cc_function_parameters[function] = argument_count; + else if (cc_function_parameters[function] != argument_count) cc_fail(); + call_patch = cc_position + 2; + cg_literal(3, cc_function_defined[function] == 2 ? cc_function_addresses[function] : + cc_function_defined[function] ? CC_PROGRAM_BASE + cc_function_addresses[function] : 0); + cg_emit(CALL_R3); cg_emit(0x1d80 + argument_count); + if (!cc_function_defined[function]) { + cc_code[call_patch] = cc_function_calls[function]; cc_function_calls[function] = call_patch; + } + cc_expression_is_array = 0; + } + } +#else + else cc_fail(); +#endif } else cc_fail(); cc_depth--; } @@ -255,6 +582,7 @@ void cc_binary(int minimum) { cc_primary(); level = cc_precedence(cc_token); while (!cc_error && level >= minimum && level) { op = cc_token; cc_next(); + cc_expression_is_array = 0; if (op == TOKEN_AND || op == TOKEN_OR) { cg_emit(0x1080); if (op == TOKEN_AND) cg_emit(0xaa04); else cg_emit(0xa404); @@ -267,26 +595,139 @@ void cc_binary(int minimum) { level = cc_precedence(cc_token); } } +#ifdef BOBC_WIDE +void cc_expression(void) { + int branch; int end; int variable; int op; int saved_value; int compound; + char name[64]; char *saved_source; + if (!cc_error && cc_token == TOKEN_ID) { + memcpy(name, cc_text, strlen(cc_text) + 1); variable = cc_variable(name); + saved_source = cc_source; saved_value = cc_value; cc_next(); op = cc_token; + if (!cc_error && (op == '=' || (op >= TOKEN_ADD_ASSIGN && op <= TOKEN_XOR_ASSIGN) || + op == TOKEN_SHL_ASSIGN || op == TOKEN_SHR_ASSIGN)) { + if (variable < 0) { cc_fail(); return; } + cc_depth++; + if (cc_depth > 32) { cc_fail(); cc_depth--; return; } + if (cc_function_pointer_flags[variable]) { + if (op != '=') { cc_fail(); cc_depth--; return; } + cc_next(); cc_function_pointer_rhs(variable); + if (!cc_error) cc_store_variable(variable); + cc_expression_is_array = 0; + cc_depth--; return; + } + compound = op != '='; + if (compound) { cc_load_variable(variable); cg_push(); } + cc_next(); cc_expression(); + if (compound) { + cg_pop(); + if (op == TOKEN_ADD_ASSIGN) op = '+'; + else if (op == TOKEN_SUB_ASSIGN) op = '-'; + else if (op == TOKEN_MUL_ASSIGN) op = '*'; + else if (op == TOKEN_DIV_ASSIGN) op = '/'; + else if (op == TOKEN_MOD_ASSIGN) op = '%'; + else if (op == TOKEN_AND_ASSIGN) op = '&'; + else if (op == TOKEN_OR_ASSIGN) op = '|'; + else if (op == TOKEN_XOR_ASSIGN) op = '^'; + else if (op == TOKEN_SHL_ASSIGN) op = TOKEN_SHL; + else op = TOKEN_SHR; + cc_operation(op); + } + cc_store_variable(variable); + cc_expression_is_array = 0; + cc_depth--; return; + } + if (cc_error) return; + cc_source = saved_source; cc_token = TOKEN_ID; cc_value = saved_value; + memcpy(cc_text, name, strlen(name) + 1); + } + cc_binary(1); + if (!cc_error && cc_token == '?') { + cc_depth++; + if (cc_depth > 32) { cc_fail(); cc_depth--; return; } + cc_next(); branch = cg_if_zero(); + cc_expression(); cc_expect(':'); + end = cg_jump(0); cg_patch(branch); + cc_expression(); cg_patch(end); + cc_expression_is_array = 0; + cc_depth--; + } +} +#else void cc_expression(void) { cc_binary(1); } +#endif void cc_patch_chain(int chain, int target) { int next; while (chain >= 0 && !cc_error) { - next = cc_code[chain]; cc_code[chain] = PROGRAM_BASE + target; chain = next; + next = cc_code[chain]; cc_code[chain] = CC_PROGRAM_BASE + target; chain = next; } } void cc_simple(void) { char name[24]; int variable; int address; int op; +#ifdef BOBC_WIDE + char *saved_source; +#endif if (cc_token == TOKEN_INC || cc_token == TOKEN_DEC) { cc_primary(); return; } if (cc_token != TOKEN_ID || strlen(cc_text) >= NAME_WORDS) { cc_fail(); return; } - memcpy(name, cc_text, strlen(cc_text) + 1); cc_next(); op = cc_token; + memcpy(name, cc_text, strlen(cc_text) + 1); +#ifdef BOBC_WIDE + saved_source = cc_source; +#endif + cc_next(); op = cc_token; +#ifdef BOBC_WIDE + if (op == '[') { + variable = cc_variable(name); + if (variable < 0 || !cc_array_flags[variable]) { cc_fail(); return; } + cc_next(); cc_expression(); cc_expect(']'); + cc_array_index_address(variable); + op = cc_token; + if (op == TOKEN_INC || op == TOKEN_DEC) { + cg_emit(0x1dff); cg_emit(0x9580); cg_emit(0x6080); + if (op == TOKEN_INC) cg_emit(0x1181); else cg_emit(0x11ff); + cg_pop(); cg_emit(0x9040); cc_next(); + } else if (op == '=') { + cg_emit(0x1dff); cg_emit(0x9580); cc_next(); cc_expression(); + cg_pop(); cg_emit(0x9040); + } else if (op >= TOKEN_ADD_ASSIGN && op <= TOKEN_SHR_ASSIGN) { + cg_emit(0x1dff); cg_emit(0x9580); cg_emit(0x6080); cg_push(); + cc_next(); cc_expression(); cg_pop(); + if (op == TOKEN_ADD_ASSIGN) op = '+'; + else if (op == TOKEN_SUB_ASSIGN) op = '-'; + else if (op == TOKEN_MUL_ASSIGN) op = '*'; + else if (op == TOKEN_DIV_ASSIGN) op = '/'; + else if (op == TOKEN_MOD_ASSIGN) op = '%'; + else if (op == TOKEN_AND_ASSIGN) op = '&'; + else if (op == TOKEN_OR_ASSIGN) op = '|'; + else if (op == TOKEN_XOR_ASSIGN) op = '^'; + else if (op == TOKEN_SHL_ASSIGN) op = TOKEN_SHL; + else op = TOKEN_SHR; + cc_operation(op); cg_pop(); cg_emit(0x9040); + } else cc_fail(); + } + else +#endif if (op == TOKEN_INC || op == TOKEN_DEC) { variable = cc_variable(name); if (variable < 0) { cc_fail(); return; } - cc_next(); cg_literal(0, 0x9800 + variable); cg_emit(0x6000); +#ifdef BOBC_WIDE + if (cc_array_flags[variable]) { cc_fail(); return; } +#endif + cc_next(); cc_load_variable(variable); if (op == TOKEN_INC) cg_emit(0x1181); else cg_emit(0x11ff); - cg_literal(1, 0x9800 + variable); cg_emit(0x9040); - } else if (op == '=' || (op >= TOKEN_ADD_ASSIGN && op <= TOKEN_XOR_ASSIGN)) { + cc_store_variable(variable); + } else if (op == '=' || (op >= TOKEN_ADD_ASSIGN && op <= TOKEN_XOR_ASSIGN) +#ifdef BOBC_WIDE + || op == TOKEN_SHL_ASSIGN || op == TOKEN_SHR_ASSIGN +#endif + ) { variable = cc_variable(name); if (variable < 0) { cc_fail(); return; } - if (op != '=') { cg_literal(0, 0x9800 + variable); cg_emit(0x6000); cg_push(); } +#ifdef BOBC_WIDE + if (cc_array_flags[variable]) { cc_fail(); return; } + if (cc_function_pointer_flags[variable]) { + if (op != '=') { cc_fail(); return; } + cc_next(); cc_function_pointer_rhs(variable); + if (!cc_error) cc_store_variable(variable); + return; + } +#endif + if (op != '=') { cc_load_variable(variable); cg_push(); } cc_next(); cc_expression(); if (op != '=') { cg_pop(); @@ -297,10 +738,16 @@ void cc_simple(void) { else if (op == TOKEN_MOD_ASSIGN) op = '%'; else if (op == TOKEN_AND_ASSIGN) op = '&'; else if (op == TOKEN_OR_ASSIGN) op = '|'; +#ifdef BOBC_WIDE + else if (op == TOKEN_XOR_ASSIGN) op = '^'; + else if (op == TOKEN_SHL_ASSIGN) op = TOKEN_SHL; + else if (op == TOKEN_SHR_ASSIGN) op = TOKEN_SHR; +#else else op = '^'; +#endif cc_operation(op); } - cg_literal(1, 0x9800 + variable); cg_emit(0x9040); + cc_store_variable(variable); } else if (op == '(') { address = 0; if (strcmp(name, "print") == 0) address = bob_address(print); @@ -308,7 +755,14 @@ void cc_simple(void) { else if (strcmp(name, "print_dec") == 0) address = bob_address(print_dec); else if (strcmp(name, "print_hex") == 0) address = bob_address(print_hex); else if (strcmp(name, "bob_putc") == 0) address = 1; - if (!address) { cc_fail(); return; } + if (!address) { +#ifdef BOBC_WIDE + cc_source = saved_source; cc_token = TOKEN_ID; memcpy(cc_text, name, strlen(name) + 1); + cc_expression(); return; +#else + cc_fail(); return; +#endif + } cc_next(); cc_expression(); cc_expect(')'); if (address == 1) cg_emit(0xf100); else { cg_push(); cg_call(address, 1); } @@ -316,25 +770,130 @@ void cc_simple(void) { } void cc_statement(void) { int variable; int start; int patch; int end; int step; int body; +#ifdef BOBC_WIDE + int saved_variables; + int opened_scope; + int function_pointer; + int function_pointer_parameters; +#endif + char declaration_name[NAME_WORDS]; if (cc_error) return; cc_depth++; if (cc_depth > 32) { cc_fail(); return; } if (cc_token == '{') { +#ifdef BOBC_WIDE + saved_variables = cc_variables; + opened_scope = 1; + if (cc_scope_depth == 32) { cc_fail(); cc_depth--; return; } + cc_scope_depth++; + cc_scope_floor[cc_scope_depth] = cc_scope_depth == 1 ? 0 : cc_variables; +#endif cc_next(); while (!cc_error && cc_token && cc_token != '}') cc_statement(); cc_expect('}'); +#ifdef BOBC_WIDE + cc_variables = saved_variables; + if (opened_scope) cc_scope_depth--; +#endif } else if (cc_is("int")) { cc_next(); - if (cc_token != TOKEN_ID || strlen(cc_text) >= NAME_WORDS || cc_variables == 16 || cc_variable(cc_text) >= 0) { cc_fail(); return; } - variable = cc_variables++; memcpy(cc_names + variable * NAME_WORDS, cc_text, strlen(cc_text) + 1); - cc_next(); - if (cc_token == '=') { cc_next(); cc_expression(); } - else cg_literal(0, 0); - cg_literal(1, 0x9800 + variable); cg_emit(0x9040); cc_expect(';'); + do { +#ifdef BOBC_WIDE + function_pointer = 0; function_pointer_parameters = 0; + if (cc_token == '(') { + function_pointer = 1; cc_next(); cc_expect('*'); + if (cc_token != TOKEN_ID || strlen(cc_text) >= NAME_WORDS) { cc_fail(); return; } + memcpy(declaration_name, cc_text, strlen(cc_text) + 1); cc_next(); cc_expect(')'); cc_expect('('); + if (cc_is("void")) { cc_next(); cc_expect(')'); } + else if (cc_token == ')') cc_next(); + else { + while (!cc_error) { + if (!cc_is("int") || function_pointer_parameters == 16) { cc_fail(); break; } + cc_next(); function_pointer_parameters++; + if (cc_token == TOKEN_ID) cc_next(); + if (cc_token != ',') break; + cc_next(); + } + cc_expect(')'); + } + } else +#else + if (cc_token != TOKEN_ID || strlen(cc_text) >= NAME_WORDS) { cc_fail(); return; } + memcpy(declaration_name, cc_text, strlen(cc_text) + 1); cc_next(); +#endif +#ifdef BOBC_WIDE + if (!function_pointer) { + if (cc_token != TOKEN_ID || strlen(cc_text) >= NAME_WORDS) { cc_fail(); return; } + memcpy(declaration_name, cc_text, strlen(cc_text) + 1); cc_next(); + } +#endif + if (cc_variables == 16 +#ifdef BOBC_WIDE + || cc_variable_current_scope(declaration_name) >= 0 +#else + || cc_variable(declaration_name) >= 0 +#endif + ) { cc_fail(); return; } + variable = cc_variables++; + memcpy(cc_names + variable * NAME_WORDS, declaration_name, strlen(declaration_name) + 1); +#ifdef BOBC_WIDE + cc_array_flags[variable] = 0; + cc_function_pointer_flags[variable] = function_pointer; + cc_function_pointer_parameters[variable] = function_pointer_parameters; + if (cc_token == '[') { + int array_size; int base_offset; int initialized; + cc_next(); + if (cc_token != TOKEN_NUMBER || cc_value < 1 || cc_value > 32 - cc_local_count) { cc_fail(); return; } + array_size = cc_value; cc_next(); cc_expect(']'); + base_offset = -(cc_local_count + array_size); + cc_local_count += array_size; + cc_variable_offsets[variable] = base_offset; + cc_array_flags[variable] = 1; + for (int i = 0; i < array_size; i++) { + cg_literal(0, 0); + cg_emit(0x9140 | ((base_offset + i) & 63)); + } + if (cc_token == '=') { + cc_next(); cc_expect('{'); initialized = 0; + while (!cc_error && cc_token != '}') { + if (initialized == array_size) { cc_fail(); break; } + cc_expression(); + cg_emit(0x9140 | ((base_offset + initialized) & 63)); + initialized++; + if (cc_token != ',') break; + cc_next(); + if (cc_token == '}') break; + } + cc_expect('}'); + } + } else { + if (cc_local_count == 32) { cc_fail(); return; } + cc_variable_offsets[variable] = -(++cc_local_count); + if (cc_token == '=') { + if (function_pointer) { + cc_next(); cc_function_pointer_rhs(variable); + } else { cc_next(); cc_expression(); } + } + else cg_literal(0, 0); + cc_store_variable(variable); + } +#else + if (cc_token == '=') { cc_next(); cc_expression(); } + else cg_literal(0, 0); + cc_store_variable(variable); +#endif + if (cc_token != ',') break; + cc_next(); + } while (!cc_error); + cc_expect(';'); } else if (cc_is("return")) { cc_next(); if (cc_token == ';') cg_literal(0, 0); else cc_expression(); +#ifdef BOBC_WIDE + patch = cg_jump(0); cc_code[patch] = cc_return_chain; cc_return_chain = patch; +#else cg_emit(0x1cd0); cg_emit(0x6b80); cg_emit(0x1d81); cg_emit(0x6f80); cg_emit(0x1d81); cg_emit(0xe000); +#endif cc_expect(';'); } else if (cc_is("break") || cc_is("continue")) { variable = cc_is("continue"); @@ -346,8 +905,28 @@ void cc_statement(void) { cc_code[patch] = cc_break_chain[cc_loop_depth - 1]; cc_break_chain[cc_loop_depth - 1] = patch; } cc_expect(';'); - } else if (cc_is("for")) { + } +#ifdef BOBC_WIDE + else if (cc_is("do")) { if (cc_loop_depth == 16) { cc_fail(); return; } + cc_next(); start = cc_position; + cc_break_chain[cc_loop_depth] = -1; cc_continue_chain[cc_loop_depth] = -1; cc_loop_depth++; + cc_statement(); cc_loop_depth--; step = cc_position; + cc_patch_chain(cc_continue_chain[cc_loop_depth], step); + if (!cc_is("while")) cc_fail(); else cc_next(); + cc_expect('('); cc_expression(); cc_expect(')'); cc_expect(';'); + patch = cg_if_zero(); cg_jump(start); cg_patch(patch); + cc_patch_chain(cc_break_chain[cc_loop_depth], cc_position); + } +#endif + else if (cc_is("for")) { + if (cc_loop_depth == 16) { cc_fail(); return; } +#ifdef BOBC_WIDE + saved_variables = cc_variables; + if (cc_scope_depth == 32) { cc_fail(); cc_depth--; return; } + cc_scope_depth++; + cc_scope_floor[cc_scope_depth] = cc_variables; +#endif cc_next(); cc_expect('('); if (cc_token == ';') cc_next(); else cc_statement(); start = cc_position; @@ -359,6 +938,10 @@ void cc_statement(void) { cc_statement(); cc_loop_depth--; cg_jump(step); cg_patch(patch); cc_patch_chain(cc_break_chain[cc_loop_depth], cc_position); cc_patch_chain(cc_continue_chain[cc_loop_depth], step); +#ifdef BOBC_WIDE + cc_variables = saved_variables; + cc_scope_depth--; +#endif } else if (cc_is("if") || cc_is("while")) { variable = cc_is("while"); cc_next(); cc_expect('('); start = cc_position; cc_expression(); cc_expect(')'); @@ -381,15 +964,119 @@ void cc_statement(void) { else cc_fail(); cc_depth--; } +#ifdef BOBC_WIDE +void cc_compile_functions(void) { + int entry_patch; int main_address; int function; int parameter_count; int local_adjust; int epilogue; + int has_unnamed; int unspecified_parameters; int declared_parameters; int parameter_array_mask; int is_array; + char function_name[24]; + entry_patch = cg_jump(0); main_address = -1; + while (!cc_error && cc_token) { + if (!cc_is("int")) { cc_fail(); break; } + cc_next(); + if (cc_token != TOKEN_ID || strlen(cc_text) >= sizeof(function_name)) { cc_fail(); break; } + memcpy(function_name, cc_text, strlen(cc_text) + 1); cc_next(); cc_expect('('); + cc_variables = 0; parameter_count = 0; memset(cc_names, 0, 384); cc_local_count = 0; + has_unnamed = 0; unspecified_parameters = 0; + parameter_array_mask = 0; + memset(cc_array_flags, 0, sizeof(cc_array_flags)); + memset(cc_function_pointer_flags, 0, sizeof(cc_function_pointer_flags)); + if (cc_is("void")) { cc_next(); cc_expect(')'); } + else if (cc_token == ')') { unspecified_parameters = 1; cc_next(); } + else { + while (!cc_error && cc_token != ')') { + if (!cc_is("int")) { cc_fail(); break; } + cc_next(); + if (parameter_count == 16) { cc_fail(); break; } + is_array = 0; + if (cc_token == TOKEN_ID) { + if (strlen(cc_text) >= NAME_WORDS || cc_variables == 16 || cc_variable(cc_text) >= 0) { cc_fail(); break; } + memcpy(cc_names + cc_variables * NAME_WORDS, cc_text, strlen(cc_text) + 1); + cc_variable_offsets[cc_variables] = 2; cc_variables++; parameter_count++; + cc_next(); + } else { has_unnamed = 1; parameter_count++; } + if (cc_token == '[') { + is_array = 1; cc_next(); + if (cc_token != ']') { + if (cc_token != TOKEN_NUMBER || cc_value < 1) { cc_fail(); break; } + cc_next(); + } + cc_expect(']'); + if (cc_token == '[') { cc_fail(); break; } + } + if (is_array) parameter_array_mask |= 1 << (parameter_count - 1); + if (cc_token != ',') break; + cc_next(); + } + cc_expect(')'); + } + function = cc_function_find(function_name); + if (function < 0) break; + if (cc_token == ';') { + declared_parameters = unspecified_parameters ? -2 : parameter_count; + if (declared_parameters >= 0 && cc_function_parameters[function] >= 0 && + cc_function_parameters[function] != declared_parameters) { cc_fail(); break; } + if (declared_parameters >= 0) { + if (!cc_function_array_signature_matches(function, parameter_count, parameter_array_mask)) { cc_fail(); break; } + cc_function_parameter_array_mask[function] = parameter_array_mask; + cc_function_parameter_array_known[function] = cc_parameter_full_mask(parameter_count); + } + if (declared_parameters >= 0 || cc_function_parameters[function] < 0) + cc_function_parameters[function] = declared_parameters; + cc_next(); continue; + } + if (cc_token != '{' || has_unnamed) { cc_fail(); break; } + if (cc_function_defined[function] || (cc_function_parameters[function] >= 0 && cc_function_parameters[function] != parameter_count) || + (cc_function_call_parameters[function] >= 0 && cc_function_call_parameters[function] != parameter_count)) { cc_fail(); break; } + if (!cc_function_array_signature_matches(function, parameter_count, parameter_array_mask)) { cc_fail(); break; } + cc_function_parameters[function] = parameter_count; cc_function_defined[function] = 1; + cc_function_parameter_array_mask[function] = parameter_array_mask; + cc_function_parameter_array_known[function] = cc_parameter_full_mask(parameter_count); + for (int i = 0; i < parameter_count; i++) { + cc_array_flags[i] = (parameter_array_mask & (1 << i)) ? 2 : 0; + } + cc_function_addresses[function] = cc_position; + if (strcmp(function_name, "main") == 0) { + if (main_address >= 0 || parameter_count) { cc_fail(); break; } + main_address = cc_position; + } + cc_patch_chain(cc_function_calls[function], cc_position); + cc_function_calls[function] = -1; + for (int i = 0; i < parameter_count; i++) cc_variable_offsets[i] = 2 + parameter_count - 1 - i; + cc_local_count = 0; cc_return_chain = -1; cc_loop_depth = 0; cc_depth = 0; + cc_scope_depth = 0; cc_scope_floor[0] = 0; + /* Save r7 and the caller's frame pointer; local slots grow below r5. */ + cg_emit(0x1dff); cg_emit(0x9f80); cg_emit(0x1dff); cg_emit(0x9b80); cg_emit(0x1ae0); + local_adjust = cc_position; cg_emit(0x1d80); + cc_statement(); + if (cc_error) break; + cg_literal(0, 0); + epilogue = cc_position; cc_patch_chain(cc_return_chain, epilogue); + cg_emit(0x1cd0); cg_emit(0x6b80); cg_emit(0x1d81); cg_emit(0x6f80); cg_emit(0x1d81); cg_emit(0xe000); + cc_code[local_adjust] = 0x1d80 | ((-cc_local_count) & 0x7f); + } + for (int i = 0; i < cc_function_count; i++) if (cc_function_calls[i] >= 0) cc_fail(); + if (main_address < 0) cc_fail(); + if (!cc_error) cc_code[entry_patch] = CC_PROGRAM_BASE + main_address; +} +#endif int compile_command(char *source_name, char *output_name) { int slot; int result; int i; int line; int column; slot = file_find(source_name); if (slot < 0 || file_kinds[slot]) { println("C source file not found."); return 0; } if (!*output_name || strlen(output_name) >= NAME_WORDS) { println("Usage: cc SOURCE OUTPUT"); return 0; } if (strcmp(source_name, output_name) == 0) { println("Output must differ from source; choose another name."); return 0; } - cc_source = file_content(slot); cc_begin = cc_source; + cc_source = (char *)file_content(slot); cc_begin = cc_source; cc_error = 0; cc_position = 0; cc_variables = 0; cc_error_offset = 0; cc_depth = 0; cc_loop_depth = 0; memset(cc_names, 0, 384); cc_next(); +#ifdef BOBC_WIDE + cc_function_count = 0; memset(cc_function_names, 0, sizeof(cc_function_names)); + memset(cc_function_addresses, 0, sizeof(cc_function_addresses)); + memset(cc_function_parameters, 0xff, sizeof(cc_function_parameters)); + memset(cc_function_call_parameters, 0xff, sizeof(cc_function_call_parameters)); + memset(cc_function_defined, 0, sizeof(cc_function_defined)); + memset(cc_function_calls, 0xff, sizeof(cc_function_calls)); + cc_compile_functions(); +#else if (!cc_is("int")) cc_fail(); else cc_next(); if (!cc_is("main")) cc_fail(); else cc_next(); cc_expect('('); if (cc_is("void")) cc_next(); cc_expect(')'); @@ -400,9 +1087,10 @@ int compile_command(char *source_name, char *output_name) { if (cc_token) cc_fail(); cg_literal(0, 0); cg_emit(0x1cd0); cg_emit(0x6b80); cg_emit(0x1d81); cg_emit(0x6f80); cg_emit(0x1d81); cg_emit(0xe000); +#endif if (cc_error) { print("C compile error near character "); print_dec(cc_error_offset); - println(". Unsupported syntax or source/code/nesting limit exceeded."); + print(". Unsupported syntax or compiler limit exceeded near token '"); print(cc_text); println("'."); line = 1; column = 1; for (i = 0; i < cc_error_offset; i++) { if (cc_begin[i] == '\n') { line++; column = 1; } @@ -412,8 +1100,13 @@ int compile_command(char *source_name, char *output_name) { print(", column "); print_dec(column); println(". Use edit to fix the source."); return 0; } +#ifdef BOBC_WIDE + result = file_write(output_name, cc_code, cc_position, 2); + if (result < 0) println("Cannot save compiled program; free RAM filesystem space and retry."); +#else result = file_write(output_name, cc_code, cc_position, 1); if (result < 0) println("Cannot save compiled program (max 511 words)."); - else { print("Compiled "); print_dec(cc_position); println(" words."); } +#endif + if (result >= 0) { print("Compiled "); print_dec(cc_position); println(" words."); } return result >= 0; } diff --git a/kernel/files.c b/kernel/files.c index 6301880..9a202c3 100644 --- a/kernel/files.c +++ b/kernel/files.c @@ -8,9 +8,17 @@ void file_snapshot(int operation) { descriptor[0] = (int)file_names; descriptor[1] = (int)file_lengths; descriptor[2] = (int)file_kinds; descriptor[3] = (int)file_used; result = bob_snapshot(descriptor, operation); +#ifdef BOBC_WIDE + if (result == -1) println("Storage unavailable. Check bob-files.b32 location/permissions (or BOB16_STORAGE)."); +#else if (result == -1) println("Storage unavailable. Check bob-files.b16 location/permissions (or BOB16_STORAGE)."); +#endif else if (result < 0) println("Invalid saved files; RAM files unchanged."); +#ifdef BOBC_WIDE + else if (operation == 0) println("Files saved to bob-files.b32 (or BOB16_STORAGE)."); +#else else if (operation == 0) println("Files saved to bob-files.b16 (or BOB16_STORAGE)."); +#endif else { println("Files restored; previous RAM files replaced."); if (result == 1) println("Kernel changed: old programs omitted. Compile restored C sources again."); @@ -20,7 +28,16 @@ void file_snapshot(int operation) { char *file_name(int slot) { return file_names + slot * NAME_WORDS; } /* The upper 4096 words are reserved for file contents, above the kernel stack. Supervised programs cannot write this region. */ -int *file_content(int slot) { return (int *)0xf000 + slot * FILE_WORDS; } +int *file_content(int slot) { +#ifdef BOBC_WIDE + int i; int offset; + offset = 0; + for (i = 0; i < slot; i++) if (file_used[i]) offset += file_lengths[i] + 1; + return (int *)0xf000 + offset; +#else + return (int *)0xf000 + slot * FILE_WORDS; +#endif +} int file_find(char *name) { int i; for (i = 0; i < FILE_COUNT; i++) @@ -44,16 +61,79 @@ int file_slot(char *name) { } return -1; } -int file_write(char *name, int *data, int length, int kind) { +int file_prepare_native(char *name) { + int i; int count; int length; + length = strlen(name); + if (!length || length >= NAME_WORDS || file_find(name) >= 0) return -1; + for (i = 0; i < length; i++) if (name[i] < 33 || name[i] > 126) return -1; + count = 0; + for (i = 0; i < FILE_COUNT; i++) if (file_used[i]) { + if (i != count) { + memcpy(file_name(count), file_name(i), NAME_WORDS); + file_lengths[count] = file_lengths[i]; file_kinds[count] = file_kinds[i]; file_used[count] = 1; + file_used[i] = 0; + } + count++; + } + if (count == FILE_COUNT) return -1; + memset(file_name(count), 0, NAME_WORDS); memcpy(file_name(count), name, length); + file_lengths[count] = 0; file_kinds[count] = 3; file_used[count] = 1; + return count; +} +int file_write(char *name, void *data, int length, int kind) { +#ifdef BOBC_WIDE + int slot; int i; int used; int available; int targetOffset; int sourceSlot; + if (length < 0 || length >= FILE_WORDS || (!kind && length >= TEXT_WORDS)) return -1; + if (!kind) for (i = 0; i < length; i++) if (!((int *)data)[i] || ((int *)data)[i] > 255) return -1; + int oldSlot = file_find(name); + slot = file_slot(name); + if (slot < 0) return -1; + sourceSlot = -1; + for (i = 0; i < FILE_COUNT; i++) if (file_used[i] && data == file_content(i)) sourceSlot = i; + used = 0; + for (i = 0; i < FILE_COUNT; i++) if (file_used[i] && i != slot) used += file_lengths[i] + 1; + available = FILE_WORDS - used; + if (length + 1 > available) { + if (oldSlot < 0) { file_used[slot] = 0; file_lengths[slot] = 0; file_kinds[slot] = 0; memset(file_name(slot), 0, NAME_WORDS); } + return -1; + } + if (sourceSlot == slot) return slot; + /* Compact first so variable-sized files never leave unusable gaps. */ + for (i = 0; i < FILE_COUNT; i++) if (file_used[i] && i != slot) { + int *source; int *destination; int j; + source = (int *)0xf000; destination = (int *)0xf000; + for (j = 0; j < i; j++) if (file_used[j] && j != slot) destination += file_lengths[j] + 1; + for (j = 0; j < i; j++) if (file_used[j]) source += file_lengths[j] + 1; + if (source != destination && destination < source) + for (j = 0; j <= file_lengths[i]; j++) destination[j] = source[j]; + } + /* Insert the rewritten target at its slot-ordered offset. */ + targetOffset = 0; + for (i = 0; i < slot; i++) if (file_used[i] && i != slot) targetOffset += file_lengths[i] + 1; + { int total = 0; + for (i = 0; i < FILE_COUNT; i++) if (file_used[i] && i != slot) total += file_lengths[i] + 1; + for (i = total - 1; i >= targetOffset; i--) ((int *)0xf000)[i + length + 1] = ((int *)0xf000)[i]; + if (sourceSlot >= 0) { + int sourceOffset = 0; + for (i = 0; i < sourceSlot; i++) if (file_used[i] && i != slot) sourceOffset += file_lengths[i] + 1; + if (sourceSlot > slot) sourceOffset += length + 1; + data = (int *)0xf000 + sourceOffset; + } + memcpy((int *)0xf000 + targetOffset, data, length); + ((int *)0xf000)[targetOffset + length] = 0; + file_lengths[slot] = length; file_kinds[slot] = kind; + } + return slot; +#else int slot; if (length < 0 || length >= FILE_WORDS) return -1; slot = file_slot(name); if (slot < 0) return -1; memcpy(file_content(slot), data, length); file_content(slot)[length] = 0; - file_lengths[slot] = length; - file_kinds[slot] = kind; + file_lengths[slot] = length; file_kinds[slot] = kind; return slot; +#endif } void file_list(void) { int i; int count; @@ -61,13 +141,19 @@ void file_list(void) { for (i = 0; i < FILE_COUNT; i++) { if (file_used[i]) { print(file_name(i)); print(" "); print_dec(file_lengths[i]); - if (file_kinds[i]) println(" words (program)"); + if (file_kinds[i] == 3) println(" words (native bob32 image)"); + else if (file_kinds[i]) println(" words (program)"); else println(" chars (text)"); count++; } } if (!count) println("No files."); - print("Used "); print_dec(count); println("/8 slots; limit 511 words per file. delete frees a slot."); + print("Used "); print_dec(count); +#ifdef BOBC_WIDE + println("/8 slots; shared 4096-word storage. Text/resident files max 511; native apps use remaining space."); +#else + println("/8 slots; limit 511 words per file. delete frees a slot."); +#endif } void file_manage(char *operation, char *name, char *destination) { int slot; int target; @@ -75,9 +161,18 @@ void file_manage(char *operation, char *name, char *destination) { slot = file_find(name); if (slot < 0) { println("File not found. Use ls to see names."); return; } if (strcmp(operation, "delete") == 0) { +#ifdef BOBC_WIDE + int sourceOffset; int destinationOffset; int i; int j; + sourceOffset = 0; destinationOffset = 0; + for (i = 0; i < FILE_COUNT; i++) if (file_used[i]) { + if (i == slot) { sourceOffset += file_lengths[i] + 1; continue; } + if (sourceOffset != destinationOffset) + for (j = 0; j <= file_lengths[i]; j++) ((int *)0xf000)[destinationOffset + j] = ((int *)0xf000)[sourceOffset + j]; + sourceOffset += file_lengths[i] + 1; destinationOffset += file_lengths[i] + 1; + } +#endif file_used[slot] = 0; file_lengths[slot] = 0; file_kinds[slot] = 0; memset(file_name(slot), 0, NAME_WORDS); - memset(file_content(slot), 0, FILE_WORDS); println("Deleted."); return; } if (!*destination || strlen(destination) >= NAME_WORDS) { diff --git a/kernel/input.c b/kernel/input.c index 48826b8..8857961 100644 --- a/kernel/input.c +++ b/kernel/input.c @@ -44,7 +44,11 @@ void input_complete(void) { count = input_cursor - start; matches = 0; if (input_cursor != input_length) return; if (!start) { +#ifdef BOBC_WIDE + words = "help echo clear mem halt list ls dir read write edit load run run32 cc go copy rename delete alloc peek poke save restore"; +#else words = "help echo clear mem halt list ls dir read write edit load run cc go copy rename delete alloc peek poke save restore"; +#endif while (*words) { length = 0; while (*words && *words != ' ') candidate[length++] = *words++; diff --git a/kernel/kernel.c b/kernel/kernel.c index 47dd68d..7414ba7 100644 --- a/kernel/kernel.c +++ b/kernel/kernel.c @@ -9,7 +9,11 @@ int main(void) { int length; char *sample; println("bob!"); +#ifdef BOBC_WIDE + println("bob32 OS: help COMMAND for usage; go bob.c runs the example."); +#else println("bob16 OS: help COMMAND for usage; go bob.c runs the example."); +#endif println("Files are in RAM; halt exits. Type help to get started."); sample = "int main(void) { println(\"bob!\"); return 0; }"; file_write("bob.c", sample, strlen(sample), 0); diff --git a/kernel/runtime.c b/kernel/runtime.c index bf24468..6283450 100644 --- a/kernel/runtime.c +++ b/kernel/runtime.c @@ -1,5 +1,10 @@ int heap_used; +#ifdef BOBC_WIDE +int bit_masks[32] = {(-2147483647-1),1073741824,536870912,268435456,134217728,67108864,33554432,16777216, + 8388608,4194304,2097152,1048576,524288,262144,131072,65536,32768,16384,8192,4096,2048,1024,512,256,128,64,32,16,8,4,2,1}; +#else int bit_masks[16] = {-32768,16384,8192,4096,2048,1024,512,256,128,64,32,16,8,4,2,1}; +#endif int bit_weights[4] = {8,4,2,1}; int strlen(char *text) { int n; n = 0; while (text[n]) n++; return n; } @@ -8,12 +13,21 @@ int strcmp(char *a, char *b) { while (a[i] && a[i] == b[i]) i++; return a[i] - b[i]; } -void memcpy(int *dst, int *src, int count) { +#ifdef BOBC_WIDE +void memcpy(void *dst, void *src, int count) { + int i; for (i = 0; i < count; i++) ((int *)dst)[i] = ((int *)src)[i]; +} +void memset(void *dst, int value, int count) { + int i; for (i = 0; i < count; i++) ((int *)dst)[i] = value; +} +#else +void word_copy(int *dst, int *src, int count) { int i; for (i = 0; i < count; i++) dst[i] = src[i]; } -void memset(int *dst, int value, int count) { +void word_fill(int *dst, int value, int count) { int i; for (i = 0; i < count; i++) dst[i] = value; } +#endif void print(char *text) { int i; i = 0; while (text[i]) { bob_putc(text[i]); i++; } } void println(char *text) { print(text); bob_putc('\n'); } void decimal_negative(int number) { @@ -31,7 +45,11 @@ void print_dec(int number) { void print_hex(int number) { int nibble; int bit; int digit; print("0x"); +#ifdef BOBC_WIDE + for (nibble = 0; nibble < 8; nibble++) { +#else for (nibble = 0; nibble < 4; nibble++) { +#endif digit = 0; for (bit = 0; bit < 4; bit++) { if (number & bit_masks[nibble * 4 + bit]) digit = digit + bit_weights[bit]; diff --git a/kernel/runtime.h b/kernel/runtime.h index 7d7be30..1678349 100644 --- a/kernel/runtime.h +++ b/kernel/runtime.h @@ -1,17 +1,42 @@ #ifndef BOB_RUNTIME_H #define BOB_RUNTIME_H #include "bob.h" +#if BOBC_WIDE +#define HEAP_BASE 0xd000 +#define HEAP_WORDS 4096 +#define PROGRAM_BASE 0xc200 +#define PROGRAM_WORDS 3584 +#else #define HEAP_BASE 0xc000 #define HEAP_WORDS 8192 -#define PROGRAM_BASE 0x9000 -#define PROGRAM_WORDS 12288 +#define PROGRAM_BASE 0xa000 +#define PROGRAM_WORDS 8192 +#endif +#define WIDE_PROGRAM_BASE 0x20000 +#define WIDE_VARIABLE_BASE 0xf0000 #define FILE_COUNT 8 +#define TEXT_WORDS 512 +#if BOBC_WIDE +#define FILE_WORDS 4096 +#else #define FILE_WORDS 512 +#endif #define NAME_WORDS 24 int strlen(char *text); int strcmp(char *a, char *b); -void memcpy(int *dst, int *src, int count); -void memset(int *dst, int value, int count); +int file_find(char *name); +int file_prepare_native(char *name); +char *file_name(int slot); +int *file_content(int slot); +#if BOBC_WIDE +void memcpy(void *dst, void *src, int count); +void memset(void *dst, int value, int count); +#else +void word_copy(int *dst, int *src, int count); +void word_fill(int *dst, int value, int count); +#define memcpy(dst, src, count) word_copy((int *)(dst), (int *)(src), (count)) +#define memset(dst, value, count) word_fill((int *)(dst), (value), (count)) +#endif void print(char *text); void println(char *text); void print_dec(int number); diff --git a/kernel/shell.c b/kernel/shell.c index e1f61e9..84ad6b0 100644 --- a/kernel/shell.c +++ b/kernel/shell.c @@ -80,13 +80,13 @@ int editor_changed(char *name) { int slot; slot = file_find(name); if (slot < 0) return editor_length != 0; - return strcmp(edit_buffer, file_content(slot)) != 0; + return strcmp(edit_buffer, (char *)file_content(slot)) != 0; } int editor_replace(int start, int end, char *text, int newline) { int added; int delta; int i; added = strlen(text) + newline; delta = added - (end - start); - if (editor_length + delta >= FILE_WORDS) { println("File too large; change rejected."); return 0; } + if (editor_length + delta >= TEXT_WORDS) { println("File too large; change rejected."); return 0; } memcpy(edit_undo, edit_buffer, editor_length + 1); editor_undo_length = editor_length; editor_has_undo = 1; if (delta > 0) { @@ -195,10 +195,36 @@ void load_words(char *name) { if (slot < 0) println("Cannot create program file."); else println("Loaded."); } -void run_file(char *name) { +void run_file(char *name, char *app_arguments) { int slot; int status; int *program; slot = file_find(name); - if (slot < 0 || !file_kinds[slot]) { println("Program not found. Use cc or load first."); return; } + if (slot < 0 || !file_kinds[slot]) { println("Program not found. Use cc, load, or import32 first."); return; } +#ifdef BOBC_WIDE + if (file_kinds[slot] == 3) { + int descriptor[4]; + descriptor[0] = (int)file_content(slot); descriptor[1] = file_lengths[slot]; + descriptor[2] = (int)app_arguments; + descriptor[3] = (int)name; + status = bob_run_native(descriptor); + if (status == -4) println("Invalid or unsupported native bob32 image."); + else if (status == -5) println("Not enough emulator memory to load this app."); + else if (status == -2) println("Program fault; shell restored."); + else if (status == -3) println("Program timed out; shell restored."); + else { print("Exit "); print_dec(status); bob_putc('\n'); } + return; + } + if (file_kinds[slot] == 2) { + program = (int *)WIDE_PROGRAM_BASE; + memset(program, 0, file_lengths[slot] + 1); + memcpy(program, file_content(slot), file_lengths[slot]); + memset((int *)WIDE_VARIABLE_BASE, 0, 16); + status = bob_run(WIDE_PROGRAM_BASE); + if (status == -2) println("Program fault; shell restored."); + else if (status == -3) println("Program timed out; shell restored."); + else { print("Exit "); print_dec(status); bob_putc('\n'); } + return; + } +#endif program = (int *)PROGRAM_BASE; memset(program, 0, PROGRAM_WORDS); memcpy(program, file_content(slot), file_lengths[slot]); @@ -207,19 +233,65 @@ void run_file(char *name) { else if (status == -3) println("Program timed out; shell restored."); else { print("Exit "); print_dec(status); bob_putc('\n'); } } +void import_wide_image(char *path, char *name) { + int slot; int descriptor[3]; int result; int i; int used; + slot = file_prepare_native(name); + if (slot < 0) { println("Cannot import: invalid name, duplicate file, or all 8 slots are used."); return; } + used = 0; for (i = 0; i < FILE_COUNT; i++) if (file_used[i] && i != slot) used += file_lengths[i] + 1; + descriptor[0] = (int)path; descriptor[1] = (int)file_content(slot); descriptor[2] = FILE_WORDS - used; + result = bob_import_image(descriptor); + if (result < 0) { + file_used[slot] = 0; file_lengths[slot] = 0; file_kinds[slot] = 0; memset(file_name(slot), 0, NAME_WORDS); + if (result == -1) println("Cannot read host app image path."); + else if (result == -5) println("Not enough RAM filesystem space for this app image."); + else println("Invalid, truncated, corrupt, or unsupported B32K app image."); + return; + } + file_content(slot)[result] = 0; file_lengths[slot] = result; file_kinds[slot] = 3; + print("Imported native app as "); print(name); print(". Run it with: run "); println(name); +} +#ifdef BOBC_WIDE +void run_wide_image(char *path) { + int status; + status = bob_run_image(path); + if (status == -5) println("Cannot read B32 app image."); + else if (status == -4) println("Invalid B32 app image or unsupported address range."); + else if (status == -2) println("Program fault; shell restored."); + else if (status == -3) println("Program timed out; shell restored."); + else { print("Exit "); print_dec(status); bob_putc('\n'); } +} +#endif void memory_status(void) { - print("Heap "); print_hex(HEAP_BASE); print(".."); print_hex(0xdfff); + print("Heap "); print_hex(HEAP_BASE); print(".."); print_hex(HEAP_BASE + HEAP_WORDS - 1); print("; free "); print_dec(HEAP_WORDS - heap_used); println(" words"); +#ifdef BOBC_WIDE + print("bob16 programs 0x0000A000..0x0000BDFF; bob32 legacy programs "); print_hex(PROGRAM_BASE); print("..0x0000CFFF; native bob32 programs "); print_hex(WIDE_PROGRAM_BASE); print("..0x000EFFFF"); println(""); +#else print("Programs "); print_hex(PROGRAM_BASE); print(".."); print_hex(0xbfff); println(""); +#endif +#ifdef BOBC_WIDE + println("Files: 8 slots, 4096 words total; text files up to 511 words; native apps share remaining space."); +#else println("Files: 8 slots, 511 words each; stack above 0xE600."); +#endif } void command_help(char *name) { if (strcmp(name, "save") == 0 || strcmp(name, "restore") == 0) { - println("save: snapshot all files to bob-files.b16 in the working directory (or BOB16_STORAGE). restore yes: replace RAM files with that snapshot. Save current work first. Changed kernels restore text only; recompile programs."); return; +#ifdef BOBC_WIDE + println("save: snapshot all files to bob-files.b32 in the working directory (or BOB16_STORAGE). restore yes: replace RAM files with that snapshot. Save current work first. Changed kernels restore text only; recompile programs."); +#else + println("save: snapshot all files to bob-files.b16 in the working directory (or BOB16_STORAGE). restore yes: replace RAM files with that snapshot. Save current work first. Changed kernels restore text only; recompile programs."); +#endif + return; } if (strcmp(name, "edit") == 0) println("edit NAME: type/arrows; Ctrl+O saves, Ctrl+X exits, Ctrl+Z undo/redo. Unsaved exit asks Y/N. Redirected input uses the line editor; see C_OS.md."); - else if (strcmp(name, "cc") == 0 || strcmp(name, "go") == 0) + else if (strcmp(name, "cc") == 0 || strcmp(name, "go") == 0) { +#ifdef BOBC_WIDE + println("cc SOURCE [OUTPUT]: compile a native 32-bit C program; output defaults to app. Code can use available RAM filesystem space. go also runs it. 32-bit int; ?:, do/while, arrays; one main; no includes."); +#else println("cc SOURCE [OUTPUT]: compile C; output defaults to app. go SOURCE [OUTPUT] also runs on success. Example: go bob.c. One int main(void); no includes. Use edit SOURCE to fix errors."); +#endif + } else if (strcmp(name, "write") == 0) println("write NAME TEXT: create/replace a text file. Example: write note bob! Names: 1..23 characters without spaces; 8 file slots, 511 words each. Use edit for multiple lines."); else if (strcmp(name, "read") == 0) println("read NAME: print text. Example: read bob.c. Use ls to see names; run executes program files."); else if (strcmp(name, "ls") == 0 || strcmp(name, "dir") == 0 || strcmp(name, "list") == 0) @@ -227,18 +299,27 @@ void command_help(char *name) { else if (strcmp(name, "copy") == 0 || strcmp(name, "rename") == 0 || strcmp(name, "delete") == 0) println("copy OLD NEW | rename OLD NEW | delete NAME. Example: copy bob.c backup.c. Destinations must be new. Copy needs a free slot; rename does not. Delete is permanent."); else if (strcmp(name, "run") == 0) println("run NAME: execute a compiled/loaded program. Example: cc bob.c bob, then run bob. Exit shows return value; faults/timeouts restore the shell."); +#ifdef BOBC_WIDE + else if (strcmp(name, "run32") == 0) println("run32 PATH: load and run a B32K v2 application image in the bob32 OS. Example: run32 build/wide-app.b32. Compile with bobcc --wide-app."); + else if (strcmp(name, "import32") == 0) println("import32 HOST_PATH GUEST_NAME: import a B32K v2 image into RAM files; then run GUEST_NAME and save to keep it in B32S."); +#endif else if (strcmp(name, "load") == 0) println("load NAME 0xWORD ...: store machine words. Example: load empty 0x2180 0xE000, then run empty. RET 0xE000 returns; use cc for C source."); else if (strcmp(name, "peek") == 0 || strcmp(name, "poke") == 0) - println("peek ADDRESS | poke ADDRESS VALUE: word addresses, hex 0x0000..0xFFFF or signed decimal. Example: poke 0xC000 98. Writes allowed only at 0xC000..0xDFFF. peek also shows signed value."); + println("peek ADDRESS | poke ADDRESS VALUE: word addresses, hex 0x0000..0xFFFF or signed decimal. Example: poke 0xD000 98. Writes allowed only in heap RAM. peek also shows signed value."); else if (strcmp(name, "alloc") == 0 || strcmp(name, "mem") == 0) - println("alloc WORDS: allocate/zero 1..8192 heap words, print start address; no free. Example: alloc 16. mem shows remaining heap and memory regions."); + println("alloc WORDS: allocate/zero heap words, print start address; no free. Example: alloc 16. mem shows remaining heap and memory regions."); else if (strcmp(name, "echo") == 0) println("echo TEXT: print text. Example: echo bob!"); else if (strcmp(name, "clear") == 0) println("clear: clear an ANSI-capable terminal; does not remove files."); else if (strcmp(name, "halt") == 0) println("halt: stop emulator. Unsaved RAM files and allocations are lost; use save before quitting."); else if (strcmp(name, "help") == 0) println("help: list commands. help COMMAND: show usage and an example. Try help edit or help go."); else println("No help for that command. Type help for available names."); } -void shell_command(char *line) { +#ifdef BOBC_WIDE +#define SHELL_COMMAND_BODY shell_command_normal +#else +#define SHELL_COMMAND_BODY shell_command +#endif +void SHELL_COMMAND_BODY(char *line) { char *command; char *name; char *text; int value; int address; int *pointer; arguments = line; command = next_arg(); if (!*command) return; @@ -250,6 +331,10 @@ void shell_command(char *line) { println("list / ls / dir | read NAME | write NAME TEXT | edit NAME"); println("copy OLD NEW | rename OLD NEW | delete NAME (permanent in RAM)"); println("load NAME 0xWORD ... | run NAME | cc SOURCE [OUTPUT] | go SOURCE [OUTPUT]"); +#ifdef BOBC_WIDE + println("run32 PATH: run a native bob32 B32K v2 application image."); + println("import32 HOST_PATH GUEST_NAME: import once, then run the guest filename."); +#endif println("cc/go default output: app. Try go bob.c to compile and print bob!"); println("Use hex addresses. poke is limited to heap RAM."); println("Type help COMMAND for usage/examples. Try help edit or help go."); @@ -276,23 +361,23 @@ void shell_command(char *line) { value = file_find(next_arg()); if (value < 0) println("File not found."); else if (file_kinds[value]) println("Binary program; use run."); - else println(file_content(value)); + else println((char *)file_content(value)); } else if (strcmp(command, "write") == 0) { name = next_arg(); text = remaining_args(); if (file_write(name, text, strlen(text), 0) < 0) println("Cannot write file. Names: 1..23 printable characters; 8 slots. Use ls or help write."); else println("Saved."); } else if (strcmp(command, "edit") == 0) edit_file(next_arg()); else if (strcmp(command, "load") == 0) { name = next_arg(); load_words(name); } - else if (strcmp(command, "run") == 0) run_file(next_arg()); + else if (strcmp(command, "run") == 0) { name = next_arg(); run_file(name, remaining_args()); } else if (strcmp(command, "cc") == 0 || strcmp(command, "go") == 0) { name = next_arg(); text = next_arg(); if (!*name || *next_arg()) { println("Usage: cc SOURCE [OUTPUT] | go SOURCE [OUTPUT]"); return; } if (!*text) text = "app"; value = compile_command(name, text); - if (value && strcmp(command, "go") == 0) run_file(text); + if (value && strcmp(command, "go") == 0) run_file(text, ""); } else if (strcmp(command, "alloc") == 0) { value = parse_number(next_arg()); - if (!number_ok) { println("Invalid allocation size. Use 1..8192 words; mem shows available space."); return; } + if (!number_ok) { println("Invalid allocation size. Use a positive word count; mem shows available space."); return; } pointer = alloc(value); if (!pointer) println("Allocation failed. Use a positive size within free space; see mem. No free command."); else { print_hex((int)pointer); bob_putc('\n'); } @@ -303,11 +388,26 @@ void shell_command(char *line) { if (strcmp(command, "poke") == 0) { value = parse_number(next_arg()); if (!number_ok) { println("Invalid value. Use -32768..65535 or 0x0000..0xFFFF."); return; } - if (address >= 0 || address < -16384 || address >= -8192) { - println("poke is limited to 0xC000..0xDFFF."); return; - } +#ifdef BOBC_WIDE + if (address < 0xd000 || address > 0xdfff) { println("poke is limited to heap RAM."); return; } +#else + if (address >= 0 || address < -16384 || address >= -8192) { println("poke is limited to 0xC000..0xDFFF."); return; } +#endif *pointer = value; } print_hex(address); print(": "); print_hex(*pointer); print(" ("); print_dec(*pointer); println(")"); } else println("Unknown command. Type help."); } +#ifdef BOBC_WIDE +void shell_command(char *line) { + if(line[0]=='r' && line[1]=='u' && line[2]=='n' && line[3]=='3' && line[4]=='2' && (!line[5] || line[5]==' ')) { + arguments=line+5;char *path=next_arg();int slot; + if(!*path)println("Usage: run32 PATH [ARG ...]"); + else {slot=file_find(path);if(slot>=0 && file_kinds[slot]==3)run_file(path,remaining_args());else if(*remaining_args())println("Arguments require an imported native app.");else run_wide_image(path);} + } else if(line[0]=='i' && line[1]=='m' && line[2]=='p' && line[3]=='o' && line[4]=='r' && line[5]=='t' && line[6]=='3' && line[7]=='2' && (!line[8] || line[8]==' ')) { + arguments=line+8;char *path=next_arg();char *name=next_arg(); + if(!*path || !*name || *next_arg())println("Usage: import32 HOST_PATH GUEST_NAME"); + else import_wide_image(path,name); + } else shell_command_normal(line); +} +#endif diff --git a/kernel/stdbool.h b/kernel/stdbool.h new file mode 100644 index 0000000..b169355 --- /dev/null +++ b/kernel/stdbool.h @@ -0,0 +1,9 @@ +#ifndef BOB_STDBOOL_H +#define BOB_STDBOOL_H + +#define bool _Bool +#define true 1 +#define false 0 +#define __bool_true_false_are_defined 1 + +#endif diff --git a/kernel/stddef.h b/kernel/stddef.h new file mode 100644 index 0000000..85bdb7b --- /dev/null +++ b/kernel/stddef.h @@ -0,0 +1,11 @@ +#ifndef BOB_STDDEF_H +#define BOB_STDDEF_H + +typedef unsigned int size_t; +typedef int ptrdiff_t; + +#ifndef NULL +#define NULL ((void *)0) +#endif + +#endif diff --git a/kernel32.b32 b/kernel32.b32 new file mode 100644 index 0000000000000000000000000000000000000000..3dddd7f9ded249817f763d6cc10400470c8fa7f3 GIT binary patch literal 189668 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

TO*V1jc{`5`DxC+D1^kB&KEPJ0{ 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 #include #include +#include +#include #ifdef _WIN32 #include #endif /* Kernel disk exposed to the guest boot ROM through trap 4. */ -static uint16_t bootDisk[0x10000]; -static uint16_t bootWords; -static uint16_t bootOrigin; +static uint32_t bootDisk[0x10000]; +static bool cpu32; +static bool application32; +static uint32_t applicationArgc; +static uint32_t applicationArgv; +static bool applicationEntryArguments; +static uint32_t bootWords; +static uint32_t bootOrigin; +static bool bootWideHeader; static bool bootMode; static bool programMode; static bool programDone; +static bool legacyProgram32; +static bool assembledWide; +static uint32_t assembledWords; +static uint32_t assembledOrigin; +static uint32_t currentInstructionAddress; +static uint16_t currentInstruction; static jmp_buf programFault; - static void machineFault(void) { - if (programMode) longjmp(programFault, 1); + if (programMode) { + if (getenv("BOB16_TRACE_FAULT")) + fprintf(stderr,"Program fault at 0x%08X (instruction 0x%04X)\n",currentInstructionAddress,currentInstruction); + longjmp(programFault, 1); + } exit(1); } - static unsigned readWord(FILE *file) { int lo = fgetc(file), hi = fgetc(file); if (lo == EOF || hi == EOF) { - fprintf(stderr, "Truncated bob16 kernel image\n"); + fprintf(stderr, "%s bob16/bob32 kernel image\n",ferror(file)?"Cannot read":"Truncated"); exit(1); } return (unsigned)lo | ((unsigned)hi << 8); } +static uint32_t readDword(FILE *file) { + uint32_t lo=readWord(file),hi=readWord(file); + return lo|(hi<<16); +} static void bootImage(const char *path); #ifdef _WIN32 @@ -160,9 +180,9 @@ static int terminalKey(void) { #ifdef _WIN32 if(terminalAvailable()) { HANDLE input=GetStdHandle(STD_INPUT_HANDLE);DWORD mode,count;INPUT_RECORD record; - GetConsoleMode(input,&mode); + if(!GetConsoleMode(input,&mode))return -1; + if(!SetConsoleMode(input,mode&~ENABLE_PROCESSED_INPUT))return -1; if(!rawInputStarted){originalInputMode=mode;rawInputStarted=true;atexit(restoreInputMode);} - SetConsoleMode(input,mode&~ENABLE_PROCESSED_INPUT); int key=0; while(ReadConsoleInputA(input,&record,1,&count) && count) { if(record.EventType!=KEY_EVENT || !record.Event.KeyEvent.bKeyDown)continue; @@ -177,14 +197,17 @@ static int terminalKey(void) { } if(key==13)return '\n'; if(key==4)return -1; - return key; + return key?key:-1; } #endif return getchar(); } -typedef uint16_t ureg_t; -typedef int16_t reg_t; +typedef uint32_t ureg_t; +typedef uint16_t instruction_t; +typedef int32_t reg_t; +static reg_t wordValue(uint32_t value) { return cpu32?(int32_t)value:(int16_t)(uint16_t)value; } +static reg_t wordAdd(reg_t a,reg_t b) { return wordValue((uint32_t)a+(uint32_t)b); } typedef enum INSTRUCTION_E { NOP, @@ -224,54 +247,131 @@ typedef struct alu_t { struct cpu_t { reg_t regFile[8]; - ureg_t ir; + instruction_t ir; ureg_t pc; bool cc[3]; alu_t alu; } cpu; struct ram_t { - int16_t memory[0x10000]; + int32_t memory[0x10000]; ureg_t mar; reg_t mdr; } ram; +static int32_t memoryRead(ureg_t address); +static void memoryWrite(ureg_t address,int32_t value); #include "storage.c" +enum { MEMORY_PAGE_SHIFT=12, MEMORY_PAGE_WORDS=1<used) { + if(!create)return NULL; + page->words=allocateSparsePage(); + if(!page->words)return NULL; + page->number=number;page->used=1;return page; + } + if(page->number==number)return page; + } + machineFault();return NULL; +} +static void memoryPageInstall(uint32_t number,int32_t *words) { + uint32_t slot=(number*2654435761u)%MEMORY_PAGE_SLOTS; + for(unsigned probe=0;probeused)continue; + page->number=number;page->words=words;page->used=1;return; + } + machineFault(); +} +static int32_t memoryRead(ureg_t address) { + if(address<0x10000)return ram.memory[address]; + SparseMemoryPage *page=memoryPage(address>>MEMORY_PAGE_SHIFT,0); + return page?page->words[address&(MEMORY_PAGE_WORDS-1)]:0; +} +static void memoryWrite(ureg_t address,int32_t value) { + if(address<0x10000){ram.memory[address]=value;return;} + SparseMemoryPage *page=memoryPage(address>>MEMORY_PAGE_SHIFT,1); + if(!page)machineFault(); + page->words[address&(MEMORY_PAGE_WORDS-1)]=value; +} +static void memoryReset(void) { + for(unsigned i=0;i= 0xbe00) return -1; +static int runProgram(uint32_t entry) { + bool savedCpu32=cpu32; + bool savedLegacyProgram32=legacyProgram32; + volatile uint32_t legacyBase=savedCpu32?0xc200u:0xa000u; + volatile uint32_t legacyEnd=savedCpu32?0xd000u:0xbe00u; + if (programMode || (application32 ? (entry < 0x20000 || entry >= 0xf0000) : (entry < legacyBase || entry >= legacyEnd))) return -1; struct cpu_t saved = cpu; ureg_t savedMar = ram.mar; reg_t savedMdr = ram.mdr; volatile int status = -2; + legacyProgram32=savedCpu32&&!application32; programMode = true; programDone = false; + bool savedApplicationEntryArguments=applicationEntryArguments; if (setjmp(programFault) == 0) { - cpu.pc = entry; - cpu.regFile[6] = (int16_t)0xc000; + if(!application32)cpu32=false; + cpu.pc = addressValue(entry); + cpu.regFile[6] = wordValue(application32?0x100000u:(savedCpu32?0xd000u:0xc000u)); cpu.regFile[5] = 0; cpu.regFile[7] = 0x80; + if(application32 && applicationEntryArguments) { cpu.regFile[0]=wordValue(applicationArgc);cpu.regFile[1]=wordValue(applicationArgv); } + applicationEntryArguments=false; unsigned cycles = 0; while (!programDone && cpu.pc != 0x80 && cycles < 5000000) { cpuCycle(); ++cycles; } - status = cycles == 5000000 ? -3 : cpu.regFile[0]; + status = cycles == 5000000 ? -3 : (int32_t)(uint32_t)cpu.regFile[0]; } programMode = false; + if(savedCpu32 && !application32 && bootWideHeader) { + uint64_t imageEnd=(uint64_t)bootOrigin+bootWords; + uint32_t restoreStart=bootOrigin>legacyBase?bootOrigin:legacyBase; + uint32_t restoreEnd=imageEnd> n; + if(!length || length>16)machineFault(); + unsigned bits=(uint16_t)val & ((1u< 0; @@ -279,34 +379,40 @@ void updateCC(int16_t val) { void fetch() { ram.mar = cpu.pc; - cpu.pc++; - ram.mdr = ram.memory[ram.mar]; - cpu.ir = ram.mdr; + currentInstructionAddress=(uint32_t)cpu.pc; + cpu.pc = addressValue(cpu.pc+1); + ram.mdr = memoryRead(ram.mar); + if(cpu32 && ((uint32_t)ram.mdr & 0xffff0000u)) { + fprintf(stderr,"Reserved upper bits in bob32 instruction at %04X\n",ram.mar);machineFault(); + } + cpu.ir = (uint16_t)ram.mdr; + currentInstruction=cpu.ir; } void evalAddress() { int opcode = (cpu.ir >> 12) & 0xF; if (opcode == LD || opcode == ST || opcode == LEA || opcode == BR) { - ram.mar = cpu.pc + sext(cpu.ir & 0x1FF, 9); + ram.mar = addressValue(cpu.pc + sext(cpu.ir & 0x1FF, 9)); } else if (opcode == LDI || opcode == STI) { - ram.mar = cpu.pc + sext(cpu.ir & 0x1FF, 9); - ram.mdr = ram.memory[ram.mar]; - ram.mar = ram.mdr; + ram.mar = addressValue(cpu.pc + sext(cpu.ir & 0x1FF, 9)); + ram.mdr = memoryRead(ram.mar); + ram.mar = addressValue((uint32_t)ram.mdr); } else if (opcode == LDR || opcode == STR) { - ram.mar = cpu.regFile[(cpu.ir >> 6) & 0x7] + sext(cpu.ir & 0x3F, 6); + ram.mar = addressValue((uint32_t)cpu.regFile[(cpu.ir >> 6) & 0x7] + (uint32_t)sext(cpu.ir & 0x3F, 6)); } } void fetchOperands() { int opcode = (cpu.ir >> 12) & 0xF; if (opcode == LD || opcode == LDI || opcode == LDR) { - ram.mdr = ram.memory[ram.mar]; + ram.mdr = memoryRead(ram.mar); } } void execute() { switch ((cpu.ir >> 12) & 0xF) { case NOP: + if(cpu.ir & 0x0fff)machineFault(); break; case ADD: switch ((cpu.ir >> 7) & 0x3) { @@ -316,10 +422,10 @@ void execute() { machineFault(); } - cpu.alu.accumulator = cpu.regFile[(cpu.ir >> 4) & 0x7] + cpu.regFile[(cpu.ir >> 1) & 0x7]; + cpu.alu.accumulator = wordAdd(cpu.regFile[(cpu.ir >> 4) & 0x7],cpu.regFile[(cpu.ir >> 1) & 0x7]); break; case 1: - cpu.alu.accumulator = cpu.regFile[(cpu.ir >> 4) & 0x7] + sext(cpu.ir & 0xF, 4); + cpu.alu.accumulator = wordAdd(cpu.regFile[(cpu.ir >> 4) & 0x7],sext(cpu.ir & 0xF, 4)); break; case 2: if (cpu.ir & 0xF) { @@ -327,10 +433,10 @@ void execute() { machineFault(); } - cpu.alu.accumulator = cpu.regFile[(cpu.ir >> 9) & 0x7] + cpu.regFile[(cpu.ir >> 4) & 0x7]; + cpu.alu.accumulator = wordAdd(cpu.regFile[(cpu.ir >> 9) & 0x7],cpu.regFile[(cpu.ir >> 4) & 0x7]); break; case 3: - cpu.alu.accumulator = cpu.regFile[(cpu.ir >> 9) & 0x7] + sext(cpu.ir & 0x7F, 7); + cpu.alu.accumulator = wordAdd(cpu.regFile[(cpu.ir >> 9) & 0x7],sext(cpu.ir & 0x7F, 7)); break; } @@ -363,7 +469,7 @@ void execute() { break; case NOT: - if (cpu.ir & 0x1F) { + if (cpu.ir & ((cpu.ir & 0x100)?0xff:0x1f)) { printf("bad instruction: %X\n at memory address %X\n", cpu.ir, (uint16_t)(cpu.pc - 1)); machineFault(); } @@ -393,7 +499,7 @@ void execute() { (cpu.cc[Z] && ((cpu.ir >> 10) & 1)) || (cpu.cc[P] && ((cpu.ir >> 9) & 1)) ) { - cpu.pc = cpu.pc + sext(cpu.ir & 0x1FF, 9); + cpu.pc = addressValue(cpu.pc + sext(cpu.ir & 0x1FF, 9)); } break; @@ -403,14 +509,15 @@ void execute() { machineFault(); } - cpu.pc = cpu.regFile[(cpu.ir >> 9) & 0x7]; + cpu.pc = addressValue((uint32_t)cpu.regFile[(cpu.ir >> 9) & 0x7]); break; case JSR: { - ureg_t target = (ureg_t)cpu.regFile[(cpu.ir >> 8) & 0x7]; - cpu.regFile[7] = cpu.pc; + if(!(cpu.ir & 0x800) && (cpu.ir & 0xff))machineFault(); + ureg_t target = addressValue((uint32_t)cpu.regFile[(cpu.ir >> 8) & 0x7]); + cpu.regFile[7] = wordValue(cpu.pc); if (cpu.ir & 0x800) { - cpu.pc += sext(cpu.ir & 0x7FF, 11); + cpu.pc = addressValue(cpu.pc + sext(cpu.ir & 0x7FF, 11)); } else { cpu.pc = target; } @@ -420,7 +527,8 @@ void execute() { case LEA: break; case RET: - cpu.pc = cpu.regFile[7]; + if(cpu.ir & 0x0fff)machineFault(); + cpu.pc = addressValue((uint32_t)cpu.regFile[7]); break; case TRAP: if (cpu.ir & 0xFF) { @@ -438,66 +546,81 @@ void execute() { break; case PUTS: { - unsigned remaining = 0x10000; - cpu.regFile[7] = cpu.pc; - cpu.pc = cpu.regFile[0]; - while (cpu.ir != 0) { + uint64_t remaining = (uint64_t)UINT32_MAX+1; + cpu.regFile[7] = wordValue(cpu.pc); + cpu.pc = addressValue((uint32_t)cpu.regFile[0]); + while (true) { if (!remaining--) machineFault(); - cpu.ir = ram.memory[cpu.pc]; - if (cpu.ir == 0) break; - cpu.regFile[0] = cpu.ir; + reg_t character=wordValue((uint32_t)memoryRead(cpu.pc)); + if (character == 0) break; + cpu.regFile[0] = character; putchar(cpu.regFile[0] & 0xFF); - cpu.pc++; + if(cpu32 && cpu.pc==UINT32_MAX)machineFault(); + cpu.pc=addressValue(cpu.pc+1); } putchar('\n'); - cpu.pc = cpu.regFile[7]; + cpu.pc = addressValue((uint32_t)cpu.regFile[7]); break; } case GETS: { + if(cpu32 && ((uint32_t)cpu.regFile[1] & 0xffff0000u))machineFault(); int n = (uint16_t)cpu.regFile[1]; - cpu.regFile[7] = cpu.pc; - unsigned address = (uint16_t)cpu.regFile[0]; - if (n < 2 || address + (unsigned)n > 0x10000 || - (programMode && (address < 0x9000 || address + (unsigned)n > 0xe000))) { + cpu.regFile[7] = wordValue(cpu.pc); + uint32_t address = addressValue((uint32_t)cpu.regFile[0]); + uint64_t end = (uint64_t)address + (unsigned)n; + uint32_t legacyBase=legacyProgram32?0xc200u:0xa000u; + uint32_t legacyEnd=0xe000u; + int guestRange=application32?(address>=0x20000 && end<=0x100000):((address>=legacyBase && end<=legacyEnd) || address>=0x10000); + if (n < 2 || end > (uint64_t)UINT32_MAX+1 || (programMode && !guestRange)) { fprintf(stderr, "Invalid input buffer\n"); machineFault(); } char *buf = calloc((size_t)n, 1); if (!buf) machineFault(); if (!fgets(buf, n, stdin)) buf[0] = '\0'; - for (size_t i = 0; i <= strlen(buf); i++) { - ram.memory[address + i] = buf[i] & 0xFF; + size_t length=strlen(buf); + for (size_t i = 0; i <= length; i++) { + memoryWrite(address + (uint32_t)i,buf[i] & 0xFF); } free(buf); - cpu.pc = cpu.regFile[7]; + cpu.pc = addressValue((uint32_t)cpu.regFile[7]); break; } case 4: /* disk_read(dst=r0, word_offset=r1, count=r2) */ { - unsigned dst = (uint16_t)cpu.regFile[0]; + if(cpu32 && (((uint32_t)cpu.regFile[1] | (uint32_t)cpu.regFile[2]) & 0xffff0000u)) { + fprintf(stderr,"Invalid boot disk argument\n");machineFault(); + } + uint32_t dst = addressValue((uint32_t)cpu.regFile[0]); unsigned offset = (uint16_t)cpu.regFile[1]; unsigned count = (uint16_t)cpu.regFile[2]; + uint64_t end=(uint64_t)dst+count; if (programMode || !bootMode || offset + count > bootWords || - dst < 0x100 || dst + count > 0xf000) { + dst < 0x100 || end > (uint64_t)UINT32_MAX+1 || (dst < 0xf000 && end > 0xf000)) { fprintf(stderr, "Invalid boot disk read\n"); machineFault(); } for (unsigned i = 0; i < count; ++i) - ram.memory[dst + i] = (int16_t)bootDisk[offset + i]; - cpu.regFile[0] = (int16_t)count; + memoryWrite(dst + i,wordValue(bootDisk[offset + i])); + cpu.regFile[0] = wordValue(count); break; } case 5: cpu.regFile[0] = (int16_t)getchar(); break; case 6: - cpu.regFile[0] = (int16_t)runProgram((uint16_t)cpu.regFile[0]); + if(programMode){cpu.regFile[0]=-1;break;} + application32=cpu32 && ((uint32_t)cpu.regFile[0]>=0x20000u && (uint32_t)cpu.regFile[0]<0xf0000u); + if(cpu32 && ((uint32_t)cpu.regFile[0]&0xffff0000u) && + ((uint32_t)cpu.regFile[0]<0x20000u || (uint32_t)cpu.regFile[0]>=0xf0000u))cpu.regFile[0]=-2; + else cpu.regFile[0] = wordValue((uint32_t)runProgram(cpu32?(uint32_t)cpu.regFile[0]:(uint16_t)cpu.regFile[0])); + application32=false; break; case 7: if(programMode)machineFault(); - cpu.regFile[0]=(int16_t)snapshotService((uint16_t)cpu.regFile[0],cpu.regFile[1]); + cpu.regFile[0]=wordValue((uint32_t)snapshotService(cpu32?(uint32_t)cpu.regFile[0]:(uint16_t)cpu.regFile[0],cpu.regFile[1])); break; case 8: cpu.regFile[0]=(int16_t)terminalKey(); @@ -515,6 +638,18 @@ void execute() { } #endif break; + case 12: + if(programMode || !cpu32)cpu.regFile[0]=-4; + else cpu.regFile[0]=wordValue((uint32_t)runWideImageFromGuest((uint32_t)cpu.regFile[0])); + break; + case 13: + if(programMode || !cpu32)cpu.regFile[0]=-4; + else cpu.regFile[0]=wordValue((uint32_t)runWidePackedFromGuest((uint32_t)cpu.regFile[0])); + break; + case 14: + if(programMode || !cpu32)cpu.regFile[0]=-4; + else cpu.regFile[0]=wordValue((uint32_t)importWideImageFromGuest((uint32_t)cpu.regFile[0])); + break; default: machineFault(); } @@ -527,16 +662,24 @@ void storeResult() { int opcode = (cpu.ir >> 12) & 0xF; int dest = (cpu.ir >> 9) & 0x7; if (opcode == LD || opcode == LDI || opcode == LDR) { - cpu.regFile[dest] = ram.mdr; + cpu.regFile[dest] = wordValue((uint32_t)ram.mdr); updateCC(cpu.regFile[dest]); } else if (opcode == ST || opcode == STI || opcode == STR) { - if (programMode && (ram.mar < 0x9000 || ram.mar >= 0xe000)) machineFault(); - ram.memory[ram.mar] = cpu.regFile[dest]; + uint32_t storeBase=application32?0x20000u:(legacyProgram32?0xc200u:0xa000u); + uint32_t storeEnd=application32?0x100000u:0xe000u; + bool allowedStore=ram.mar>=storeBase && ram.mar=0x9800u && ram.mar<0x9810u) allowedStore=true; + if (programMode && !allowedStore) { + if (getenv("BOB16_TRACE_FAULT")) + fprintf(stderr,"Rejected store to 0x%08X (valid 0x%08X..0x%08X%s)\n",ram.mar,storeBase,storeEnd-1,(!application32&&!legacyProgram32?" or 0x00009800..0x0000980F":"")); + machineFault(); + } + memoryWrite(ram.mar,wordValue((uint32_t)cpu.regFile[dest])); } else if (opcode == ADD || opcode == AND || opcode == NOT) { - cpu.regFile[dest] = cpu.alu.accumulator; + cpu.regFile[dest] = wordValue((uint32_t)cpu.alu.accumulator); updateCC(cpu.regFile[dest]); } else if (opcode == LEA) { - cpu.regFile[dest] = ram.mar; + cpu.regFile[dest] = wordValue(ram.mar); updateCC(cpu.regFile[dest]); } } @@ -568,6 +711,34 @@ int parseReg(const char* s) { return s[1] - '0'; } +static int parseImmediate(const char *text,int *value) { + const char *p=text;if(*p=='+' || *p=='-')p++; + if(!*p)return 0; + for(;*p;p++)if(*p<'0' || *p>'9')return 0; + errno=0;char *end;long parsed=strtol(text,&end,10); + if(errno==ERANGE || *end || parsedINT_MAX)return 0; + *value=(int)parsed;return 1; +} +static int readAssemblyLine(FILE *file,char line[257]) { + size_t length=0;int ch,readAny=0,tooLong=0; + while((ch=fgetc(file))!=EOF) { + readAny=1; + if(ch=='\n')break; + if(ch==0) { + while((ch=fgetc(file))!=EOF && ch!='\n'){} + line[0]=0;return -2; + } + if(length<256)line[length++]=(char)ch; + else tooLong=1; + } + if(ferror(file)){line[0]=0;return -3;} + if(!readAny && ch==EOF)return 0; + if(length && line[length-1]=='\r')length--; + line[length]=0; + if(tooLong || length>255)return -1; + return 1; +} +static int assembleSource(FILE *file); int assemble() { memset(ram.memory, 0, sizeof(ram.memory)); @@ -577,18 +748,35 @@ int assemble() { setbuf(stdout, NULL); printf("Enter source assembly file name: \n"); if (!fgets(fileName, 256, stdin)) return -8; - fileName[strcspn(fileName, "\n")] = '\0'; + if(!strchr(fileName,'\n')) { + int next=fgetc(stdin); + if(next=='\r')next=fgetc(stdin); + if(next!=EOF && next!='\n') { + while(next!=EOF && next!='\n')next=fgetc(stdin); + printf("Source file name exceeds 255 characters!\n");return -1; + } + } + fileName[strcspn(fileName, "\r\n")] = '\0'; file = fopen(fileName, "r"); if (!file) { printf("Source file doesn't exist!\n"); return -1; } - int instructionCount = 0; + int result=assembleSource(file); + if(fclose(file) && !result){fprintf(stderr,"Cannot close assembly source\n");result=-1;} + if(!result)printf("Starting execution!\n"); + return result; +} +static int assembleSource(FILE *file) { + + uint32_t instructionCount = 0; + assembledOrigin=0; int lineCount = 0; - char line[256]; - while (fgets(line, 256, file)) { - uint16_t instruction = 0; + char line[257]; + int lineStatus; + while ((lineStatus=readAssemblyLine(file,line))>0) { + uint32_t instruction = 0; size_t n = strspn(line, " \t\r"); char* lineTrimmed = line + n; @@ -599,7 +787,7 @@ int assemble() { char* tokens[4] = { NULL, NULL, NULL, NULL }; int tokenCount = 0; - char* token = strtok(lineTrimmed, " \t\n"); + char* token = strtok(lineTrimmed, " \t\r\n"); while (token != NULL) { if (tokenCount == 4) { printf("Too many tokens on line %d!\n", lineCount); @@ -608,24 +796,36 @@ int assemble() { tokens[tokenCount] = token; tokenCount++; - token = strtok(NULL, " \t\n"); + token = strtok(NULL, " \t\r\n"); } if (tokenCount == 0) { lineCount++; continue; } + if(strcmp(tokens[0],".org")==0) { + char *end;errno=0;unsigned long long value=tokenCount==2?strtoull(tokens[1],&end,0):0; + if(!cpu32 || tokenCount!=2 || tokens[1][0]=='-' || end==tokens[1] || *end || errno==ERANGE || value>UINT32_MAX || value(cpu32?UINT32_MAX:0xffffu)) { printf("Wrong token on line %d!\n", lineCount); return -3; } + instruction=(uint32_t)value; } else if (strcmp(tokens[0], ".stringz") == 0) { if (tokenCount != 2) { @@ -633,17 +833,17 @@ int assemble() { return -4; } - for (size_t i = 0; i < strlen(tokens[1]); i++) { - ram.memory[instructionCount] = tokens[1][i] & 0x00FF; + size_t length=strlen(tokens[1]); + uint64_t assemblyLimit=instructionCount>=0x10000?(uint64_t)UINT32_MAX+1:0x10000; + if((uint64_t)instructionCount+length+1>assemblyLimit){printf("Too many instructions!\n");return -7;} + for (size_t i = 0; i < length; i++) { + memoryWrite(instructionCount, tokens[1][i] & 0x00FF); instructionCount++; } - ram.memory[instructionCount] = 0; + memoryWrite(instructionCount, 0); instructionCount++; - if (instructionCount > 0xFFFF) { - printf("Too many instructions!\n"); - return -7; - } + lineCount++;continue; } else if (strcmp(tokens[0], "add") == 0) { instruction += (1 << 12); @@ -661,7 +861,7 @@ int assemble() { instruction += (src0 << 4); if (src1 < 0) { //imm instruction += (1 << 7); - int imm = atoi(tokens[3]); + int imm; if(!parseImmediate(tokens[3],&imm)){printf("Invalid decimal operand on line %d!\n",lineCount);return -3;} if (imm > 7) { imm = 7; } @@ -686,7 +886,7 @@ int assemble() { instruction += (dst << 9); if (src < 0) { //imm instruction += (3 << 7); - int imm = atoi(tokens[2]); + int imm; if(!parseImmediate(tokens[2],&imm)){printf("Invalid decimal operand on line %d!\n",lineCount);return -3;} if (imm > 63) { imm = 63; } @@ -722,7 +922,7 @@ int assemble() { instruction += (r1 << 4); if (r2 < 0) { //imm instruction += (1 << 7); - int imm = atoi(tokens[3]); + int imm; if(!parseImmediate(tokens[3],&imm)){printf("Invalid decimal operand on line %d!\n",lineCount);return -3;} if (imm > 7) { imm = 7; } @@ -747,7 +947,7 @@ int assemble() { instruction += (r0 << 9); if (r1 < 0) { //imm instruction += (3 << 7); - int imm = atoi(tokens[2]); + int imm; if(!parseImmediate(tokens[2],&imm)){printf("Invalid decimal operand on line %d!\n",lineCount);return -3;} if (imm > 63) { imm = 63; } @@ -769,18 +969,24 @@ int assemble() { } else if (strcmp(tokens[0], "not") == 0) { instruction += (3 << 12); + if(tokenCount!=2 && tokenCount!=3) { + printf("Wrong amount of tokens on line %d!\n",lineCount);return -4; + } int r0 = parseReg(tokens[1]); - int r1 = parseReg(tokens[2]); if (r0 < 0) { printf("Wrong tokens on line %d!\n", lineCount); return -3; } instruction += (r0 << 9); - if (r1 < 0) { //imm + if(tokenCount==2) { instruction += (1 << 8); - } else { //normal + } else { + int r1=parseReg(tokens[2]); + if(r1<0) { + printf("Wrong tokens on line %d!\n",lineCount);return -3; + } instruction += (r1 << 5); } @@ -792,13 +998,13 @@ int assemble() { } int r0 = parseReg(tokens[1]); - if (r0 == -1) { + if (r0 < 0) { printf("Wrong tokens on line %d!\n", lineCount); return -3; } instruction += (r0 << 9); - int imm = atoi(tokens[2]); + int imm; if(!parseImmediate(tokens[2],&imm)){printf("Invalid decimal operand on line %d!\n",lineCount);return -3;} if (imm > 255) { imm = 255; } @@ -818,13 +1024,13 @@ int assemble() { } int r0 = parseReg(tokens[1]); - if (r0 == -1) { + if (r0 < 0) { printf("Wrong tokens on line %d!\n", lineCount); return -3; } instruction += (r0 << 9); - int imm = atoi(tokens[2]); + int imm; if(!parseImmediate(tokens[2],&imm)){printf("Invalid decimal operand on line %d!\n",lineCount);return -3;} if (imm > 255) { imm = 255; } @@ -844,14 +1050,14 @@ int assemble() { int r0 = parseReg(tokens[1]); int r1 = parseReg(tokens[2]); - if (r0 == -1 || r1 == -1) { + if (r0 < 0 || r1 < 0) { printf("Wrong tokens on line %d!\n", lineCount); return -3; } instruction += (r0 << 9); instruction += (r1 << 6); - int imm = atoi(tokens[3]); + int imm; if(!parseImmediate(tokens[3],&imm)){printf("Invalid decimal operand on line %d!\n",lineCount);return -3;} if (imm > 31) { imm = 31; } @@ -870,13 +1076,13 @@ int assemble() { } int r0 = parseReg(tokens[1]); - if (r0 == -1) { + if (r0 < 0) { printf("Wrong tokens on line %d!\n", lineCount); return -3; } instruction += (r0 << 9); - int imm = atoi(tokens[2]); + int imm; if(!parseImmediate(tokens[2],&imm)){printf("Invalid decimal operand on line %d!\n",lineCount);return -3;} if (imm > 255) { imm = 255; } @@ -895,13 +1101,13 @@ int assemble() { } int r0 = parseReg(tokens[1]); - if (r0 == -1) { + if (r0 < 0) { printf("Wrong tokens on line %d!\n", lineCount); return -3; } instruction += (r0 << 9); - int imm = atoi(tokens[2]); + int imm; if(!parseImmediate(tokens[2],&imm)){printf("Invalid decimal operand on line %d!\n",lineCount);return -3;} if (imm > 255) { imm = 255; } @@ -921,14 +1127,14 @@ int assemble() { int r0 = parseReg(tokens[1]); int r1 = parseReg(tokens[2]); - if (r0 == -1 || r1 == -1) { + if (r0 < 0 || r1 < 0) { printf("Wrong tokens on line %d!\n", lineCount); return -3; } instruction += (r0 << 9); instruction += (r1 << 6); - int imm = atoi(tokens[3]); + int imm; if(!parseImmediate(tokens[3],&imm)){printf("Invalid decimal operand on line %d!\n",lineCount);return -3;} if (imm > 31) { imm = 31; } @@ -960,12 +1166,14 @@ int assemble() { conditionCodes |= 0b010; } else if (tokens[1][i] == 'p') { conditionCodes |= 0b001; + } else { + printf("Invalid branch condition on line %d!\n",lineCount);return -3; } } instruction += ((conditionCodes & 0b111) << 9); - int imm = atoi(tokens[2]); + int imm; if(!parseImmediate(tokens[2],&imm)){printf("Invalid decimal operand on line %d!\n",lineCount);return -3;} if (imm > 255) { imm = 255; } @@ -1001,7 +1209,7 @@ int assemble() { return -4; } - int imm = atoi(tokens[1]); + int imm; if(!parseImmediate(tokens[1],&imm)){printf("Invalid decimal operand on line %d!\n",lineCount);return -3;} if (imm > 1023) { imm = 1023; } @@ -1043,7 +1251,7 @@ int assemble() { } instruction += (r0 << 9); - int imm = atoi(tokens[2]); + int imm; if(!parseImmediate(tokens[2],&imm)){printf("Invalid decimal operand on line %d!\n",lineCount);return -3;} if (imm > 255) { imm = 255; } @@ -1070,8 +1278,8 @@ int assemble() { return -4; } - int vector = atoi(tokens[1]); - if (vector < 0 || vector > 15) { + int vector; if(!parseImmediate(tokens[1],&vector)){printf("Invalid trap vector on line %d!\n",lineCount);return -5;} + if (vector < 0 || vector > 11) { printf("Bad trap vector on line %d!\n", lineCount); return -5; } @@ -1083,18 +1291,23 @@ int assemble() { return -6; } - ram.memory[instructionCount] = instruction; - instructionCount++; - if (instructionCount > 0xFFFF) { + if (instructionCount == UINT32_MAX) { printf("Too many instructions!\n"); return -7; } + memoryWrite(instructionCount++, instruction); lineCount++; } + if(lineStatus<0) { + if(lineStatus==-1)printf("Source line %d exceeds 255 characters!\n",lineCount); + else if(lineStatus==-2)printf("Source line %d contains a zero byte!\n",lineCount); + else fprintf(stderr,"Cannot read assembly source\n"); + return -2; + } - printf("Starting execution!\n"); - fclose(file); + if(ferror(file)){fprintf(stderr,"Cannot read assembly source\n");return -1;} + assembledWords=instructionCount-assembledOrigin; return 0; } @@ -1102,34 +1315,253 @@ static void bootImage(const char *path) { FILE *file = fopen(path, "rb"); if (!file) { perror(path); exit(1); } char magic[4]; - if (fread(magic, 1, 4, file) != 4 || memcmp(magic, "B16K", 4)) { - fprintf(stderr, "Not a bob16 kernel image\n"); exit(1); + if (fread(magic, 1, 4, file) != 4 || (memcmp(magic, "B16K", 4) && memcmp(magic,"B32K",4))) { + fprintf(stderr, "Not a bob16/bob32 kernel image\n"); exit(1); } - unsigned version = readWord(file), origin = readWord(file); - unsigned entry = readWord(file), words = readWord(file), checksum = readWord(file); - if (version != 1 || !words || origin < 0x100 || origin + words > 0x9000 || - entry < origin || entry >= origin + words) { - fprintf(stderr, "Invalid bob16 kernel header\n"); exit(1); + cpu32=!memcmp(magic,"B32K",4); + unsigned version=readWord(file),headerSize=0; + uint32_t origin,entry,words,checksum; + if(cpu32 && version==2) { + headerSize=readWord(file);origin=readDword(file);entry=readDword(file); + words=readDword(file);checksum=readDword(file); + } else { + origin=readWord(file);entry=readWord(file);words=readWord(file);checksum=readWord(file); + if(cpu32)checksum|=(uint32_t)readWord(file)<<16; } - unsigned sum = 0; - for (unsigned i = 0; i < words; ++i) { bootDisk[i] = readWord(file); sum += bootDisk[i]; } - if ((sum & 0xffff) != checksum || fgetc(file) != EOF) { + uint64_t end=(uint64_t)origin+words; + int validV1=version==1 && words && origin>=0x100 && end<=0xa000 && entry>=origin && entry=origin && entry=0xf000)return -4; + while(length255)return -4; + path[length++]=(char)character; + } + if(length==sizeof(path)-1 || pathAddress+length>=0xf000)return -4; + path[length]=0; + FILE *file=fopen(path,"rb");if(!file)return -5; + unsigned char header[24];int valid=fread(header,1,sizeof(header),file)==sizeof(header); + if(valid && (memcmp(header,"B32K",4) || header[4]!=2 || header[5]!=0 || header[6]!=24 || header[7]!=0))valid=0; + uint32_t origin=0,entry=0,count=0,checksum=0; + if(valid) { + for(unsigned i=0;i<4;i++) { + origin|=(uint32_t)header[8+i]<<(8*i);entry|=(uint32_t)header[12+i]<<(8*i); + count|=(uint32_t)header[16+i]<<(8*i);checksum|=(uint32_t)header[20+i]<<(8*i); + } + uint64_t end=(uint64_t)origin+count; + if(!count || count>0x10000 || origin<0x20000 || end>0x100000 || entry=end)valid=0; + } + uint32_t *words=NULL;uint32_t sum=0; + if(valid) {words=malloc((size_t)count*sizeof(*words));if(!words)valid=0;} + if(valid)for(uint32_t i=0;i>MEMORY_PAGE_SHIFT,lastPage=(origin+count-1)>>MEMORY_PAGE_SHIFT;unsigned neededPages=0,freePages=0; + for(uint32_t page=firstPage;page<=lastPage;page++)if(!memoryPage(page,0))neededPages++; + for(unsigned i=0;ifreePages){free(words);return -5;} + typedef struct {uint32_t number;int32_t *words;} PendingPage; + PendingPage *pending=neededPages?calloc(neededPages,sizeof(*pending)):NULL; + if(neededPages && !pending){free(words);return -5;} + unsigned pendingCount=0; + for(uint32_t page=firstPage;page<=lastPage;page++)if(!memoryPage(page,0)) { + pending[pendingCount].number=page; + pending[pendingCount].words=allocateSparsePage(); + if(!pending[pendingCount].words) { + for(unsigned i=0;i0xf000-4)return -4; + uint32_t address=(uint32_t)memoryRead(descriptor),length=(uint32_t)memoryRead(descriptor+1); + uint32_t argumentAddress=(uint32_t)memoryRead(descriptor+2); + uint32_t programNameAddress=(uint32_t)memoryRead(descriptor+3); + const char *arguments=NULL; + char argumentBuffer[128]; + if(argumentAddress) { + if(argumentAddress<0x100 || argumentAddress>=0xf000)return -4; + unsigned i=0; + while(i255)return -4; + argumentBuffer[i++]=(char)c; + if(!c)break; + } + if(!i || argumentBuffer[i-1])return -4; + arguments=argumentBuffer; + } + char programNameBuffer[128]; + if(programNameAddress) { + if(programNameAddress<0x100 || programNameAddress>=0xf000)return -4; + unsigned i=0; + while(i255)return -4; + programNameBuffer[i++]=(char)c; + if(!c)break; + } + if(!i || programNameBuffer[i-1])return -4; + } else programNameBuffer[0]=0; + if(address<0xf000 || address>=0x10000 || !length || length>4096 || address+length>0x10000)return -4; + if((uint32_t)memoryRead(address)!=0x4233324bu || (uint32_t)memoryRead(address+1)!=0x00180002u)return -4; + uint32_t origin=(uint32_t)memoryRead(address+2),entry=(uint32_t)memoryRead(address+3); + uint32_t count=(uint32_t)memoryRead(address+4),checksum=(uint32_t)memoryRead(address+5); + if(!count || count+6!=length || count>0x10000 || origin<0x20000 || (uint64_t)origin+count>0x100000 || entry=origin+count)return -4; + uint32_t sum=0;for(uint32_t i=0;i>MEMORY_PAGE_SHIFT,lastPage=(origin+count-1)>>MEMORY_PAGE_SHIFT;unsigned neededPages=0,freePages=0; + for(uint32_t page=firstPage;page<=lastPage;page++)if(!memoryPage(page,0))neededPages++; + for(unsigned i=0;i>MEMORY_PAGE_SHIFT; + int needsArgumentPage=!memoryPage(argumentPage,0) && (argumentPagelastPage); + if(neededPages+(unsigned)needsArgumentPage>freePages)return -5; + typedef struct {uint32_t number;int32_t *words;} PendingPage; + PendingPage *pending=neededPages?calloc(neededPages,sizeof(*pending)):NULL; + if(neededPages && !pending)return -5; + unsigned pendingCount=0; + for(uint32_t page=firstPage;page<=lastPage;page++)if(!memoryPage(page,0)) { + pending[pendingCount].number=page;pending[pendingCount].words=allocateSparsePage(); + if(!pending[pendingCount].words) {for(unsigned i=0;i0xf000-3)return -4; + uint32_t pathAddress=(uint32_t)memoryRead(descriptor),destination=(uint32_t)memoryRead(descriptor+1),capacity=(uint32_t)memoryRead(descriptor+2); + if(pathAddress<0x100 || pathAddress>=0xf000)return -4; + if(destination<0xf000 || destination>=0x10000 || capacity>0x10000-destination || capacity<7)return -4; + char path[512];unsigned pathLength=0; + while(pathLength255)return -4;path[pathLength++]=(char)c;} + if(!pathLength || pathLength==sizeof(path)-1)return -4; + path[pathLength]=0; + FILE *file=fopen(path,"rb");if(!file)return -1; + unsigned char header[24];int valid=fread(header,1,sizeof(header),file)==sizeof(header); + if(valid && (memcmp(header,"B32K",4)||header[4]!=2||header[5]!=0||header[6]!=24||header[7]!=0))valid=0; + uint32_t origin=0,entry=0,count=0,checksum=0; + if(valid)for(unsigned i=0;i<4;i++){origin|=(uint32_t)header[8+i]<<(8*i);entry|=(uint32_t)header[12+i]<<(8*i);count|=(uint32_t)header[16+i]<<(8*i);checksum|=(uint32_t)header[20+i]<<(8*i);} + if(valid && (!count || count>0x10000 || origin<0x20000 || (uint64_t)origin+count>0x100000 || entry=origin+count))valid=0; + if(valid && count+7>capacity){fclose(file);return -5;} + uint32_t sum=0;memoryWrite(destination,0x4233324b);memoryWrite(destination+1,0x00180002);memoryWrite(destination+2,origin);memoryWrite(destination+3,entry);memoryWrite(destination+4,count);memoryWrite(destination+5,checksum); + for(uint32_t i=0;valid && i'9')return 0; + errno=0;char *end;unsigned long value=strtoul(text,&end,10); + if(errno==ERANGE || *end || !value)return 0; + *limit=value;return 1; +} int main(int argc, char** argv) { + memoryReset(); #ifdef _WIN32 HANDLE console = GetStdHandle(STD_OUTPUT_HANDLE); DWORD mode; @@ -1138,12 +1570,27 @@ int main(int argc, char** argv) { unsigned long maxCycles = 0; if (argc == 2 && strcmp(argv[1], "--os") == 0) { bootImage("build/kernel.b16"); + } else if(argc==3 && strcmp(argv[1],"--asm32")==0) { + cpu32=true; + FILE *assembly=fopen(argv[2],"rb"); + if(!assembly){perror(argv[2]);return 1;} + int result=assembleSource(assembly); + if(fclose(assembly) && !result){fprintf(stderr,"Cannot close assembly source\n");return 1;} + if(result){fprintf(stderr,"B32 assembly failed (%d)\n",result);return 1;} + assembledWide=true; + cpu.pc=assembledOrigin; + if(assembledWords<=0x10000) { + bootOrigin=assembledOrigin;bootWords=assembledWords;bootWideHeader=true; + for(uint32_t i=0;i= 3 && strcmp(argv[1], "--boot") == 0) { - if (argc == 5 && strcmp(argv[3], "--max-cycles") == 0) maxCycles = strtoul(argv[4], NULL, 10); + if (argc == 5 && strcmp(argv[3], "--max-cycles") == 0) { + if(!parseCycleLimit(argv[4],&maxCycles)){fprintf(stderr,"--max-cycles requires a positive decimal integer within unsigned long range\n");return 1;} + } else if (argc != 3) { fprintf(stderr, "Usage: %s --boot kernel.b16 [--max-cycles N]\n", argv[0]); return 1; } bootImage(argv[2]); } else { - if (argc != 1) { fprintf(stderr, "Usage: %s [--os | --boot kernel.b16 [--max-cycles N]]\n", argv[0]); return 1; } + if (argc != 1) { fprintf(stderr, "Usage: %s [--os | --boot image.b16/b32 [--max-cycles N] | --asm32 source.basm]\n", argv[0]); return 1; } int assembleReturn = -1; while (assembleReturn < 0) { assembleReturn = assemble(); @@ -1151,12 +1598,27 @@ int main(int argc, char** argv) { } } - uint16_t identityWords[0x8d00]; + uint32_t identityWords[0x8d00]; + uint64_t bootEnd=(uint64_t)bootOrigin+bootWords; for(unsigned i=0;i<0x8d00;i++) { unsigned address=0x300+i; - identityWords[i]=bootMode?(address>=bootOrigin && address=bootOrigin && (uint64_t)address= maxCycles) { fprintf(stderr, "CPU cycle limit reached\n"); return 2; } diff --git a/storage.c b/storage.c index 1e2334a..f5f19ee 100644 --- a/storage.c +++ b/storage.c @@ -1,52 +1,65 @@ /* Included by main.c after ram is defined. Durable file device; guest owns shell. */ enum { SNAP_WORDS = 4312 }; static uint32_t kernelIdentity; -static uint32_t snapshotHash(const uint16_t *words, unsigned count) { +static uint32_t snapshotHash(const uint32_t *words, unsigned count) { uint32_t hash=2166136261u; for(unsigned i=0;i>8))*16777619u; + hash=(hash^((words[i]>>8)&255))*16777619u; + if(cpu32) { hash=(hash^((words[i]>>16)&255))*16777619u; hash=(hash^(words[i]>>24))*16777619u; } } return hash; } -static int snapshotValid(const uint16_t *words) { +static int snapshotValidFormat(const uint32_t *words, int packed) { + unsigned packedOffset=0; for(unsigned i=0;i<8;i++) { unsigned length=words[192+i],kind=words[200+i],used=words[208+i]; - if(used>1 || kind>1 || length>511)return 0; + if(used>1 || kind>(cpu32?(packed?3u:2u):1u) || length>=(packed?4096u:512u))return 0; if(!used)continue; - const uint16_t *name=words+i*24;unsigned n=0; + const uint32_t *name=words+i*24;unsigned n=0; while(n<24 && name[n]) {if(name[n]<33 || name[n]>126)return 0;n++;} - if(!n || n==24 || words[216+i*512+length])return 0; - if(!kind)for(unsigned k=0;k255)return 0; + unsigned contentOffset=packed?packedOffset:i*512; + if(!n || n==24 || words[216+contentOffset+length])return 0; + if(!kind)for(unsigned k=0;k255)return 0; + if(packed)packedOffset+=length+1; for(unsigned j=0;j4096)return 0; return 1; } +static int snapshotValid(const uint32_t *words) { return snapshotValidFormat(words,cpu32); } static int snapshotService(unsigned descriptor, int operation) { - if(programMode || descriptor<0x300 || descriptor+4>0xf000)return -3; + if(programMode || descriptor<0x300 || descriptor>0xf000-4)return -3; unsigned addresses[4],sizes[4]={192,8,8,8}; for(unsigned i=0;i<4;i++) { - addresses[i]=(uint16_t)ram.memory[descriptor+i]; - if(addresses[i]<0x300 || addresses[i]+sizes[i]>0x9000)return -3; + addresses[i]=cpu32?(uint32_t)memoryRead(descriptor+i):(uint16_t)ram.memory[descriptor+i]; + uint64_t end=(uint64_t)addresses[i]+sizes[i]; + int lowArray=addresses[i]>=0x300 && end<=(cpu32?0xc000u:0xa000u); + uint32_t kernelStart=bootMode?bootOrigin:(assembledWide?assembledOrigin:0); + uint64_t kernelEnd=bootMode?(uint64_t)bootOrigin+bootWords:(assembledWide?(uint64_t)assembledOrigin+assembledWords:0); + int kernelArray=cpu32 && addresses[i]>=kernelStart && end<=kernelEnd; + if(!lowArray && !kernelArray)return -3; for(unsigned j=0;j>(8*i));header[12+i]=(unsigned char)(hash>>(8*i));} int okay=fwrite(header,1,16,file)==16; - for(unsigned i=0;i>8,file)==EOF)okay=0; + for(unsigned i=0;i>(8*b))&255,file)==EOF)okay=0; if(fclose(file))okay=0; if(okay) { #ifdef _WIN32 @@ -62,19 +75,41 @@ static int snapshotService(unsigned descriptor, int operation) { FILE *file=fopen(path,"rb");if(!file)return -1; unsigned char header[16];int valid=fread(header,1,16,file)==16; for(unsigned i=0;i>=` are recognized and executed. Shell integration uses short editor input lines (below the command limit), frees source slots after each run, and asserts all nine successful B32 shell programs. bob16 image remains 36,093 words. Full suite: CPU 189, OS/compiler 1,746, native console 28. + +Supervised-store boundary audit found that the B32 condition rejected writes in `0x100000..0x10FFFF` but accidentally allowed all later sparse-memory addresses. The guard now enforces `[0x10000,0x100000)` for native apps and `[0x9000,0xE000)` for B16 legacy apps. B32 legacy apps use `[0xB000,0xE000)`. Direct CPU regressions accept the final B32 app word and reject below-range, end, former-hole, arbitrary-high and maximum addresses without modifying them. Suite: CPU 189, OS/compiler 1,746, console 28. + +B32 external-image allocation is now transactional: missing sparse pages are allocated into temporary buffers before any are installed or image words are copied. Allocation failure returns the documented loader error rather than taking the emulator's non-program machine-fault exit. A test-only allocator fault forces this failure and confirms the target page remains absent and unchanged. Suite: CPU 187, OS/compiler 1,746, native console 28. + +Nested trap-6 audit found that a rejected recursive run cleared `application32` while the outer native app kept running. The trap now returns `-1` before changing execution mode. A CPU fixture executes nested trap 6, then stores to valid high app memory and exits successfully. Suite: CPU 187, OS/compiler 1,746, console 28. + +The expanded bob32 kernel overlapped the legacy program region at `0x9000`. The bob32 OS now loads kind-1 legacy apps at `0xB000..0xBFFF`, leaves the 16-bit bob16 location unchanged, and rejects a legacy run if the active B32 kernel occupies that window. This also removes the old post-run image restore that reset RAM filesystem metadata. Snapshot descriptor validation now allows B32 kernel tables below `0xB000` while retaining the old bob16 ceiling. CPU fixtures run a 16-bit `LEA/PUTS/HALT` program and reject a low legacy entry; OS integration checks `bob!`/exit 33, file listing after execution, and snapshot save/restore. Suite: CPU 189, OS/compiler 1,746, console 28. + +Resident B32 functions now use per-call stack frames, parameter offsets, local slots, forward-call patch chains, and a common return epilogue. The shell regression calls a later-defined no-argument function as a statement, calls a two-argument function for its value, and computes factorial recursively; it prints `bob!` and returns 0. The test runner counts all nine successful B32 shell programs. Suite: CPU 189, OS/compiler 1,746, console 28. + +Resident B32 frame-offset audit found that local slot numbers were masked to six bits when encoded in LDR/STR instructions. A sufficiently large function with many sequential inner-scope declarations could silently access the wrong stack word after slot 32. The compiler now rejects a 33rd local slot, and a shell regression generates 33 block-scoped declarations to verify rejection. B32 kernel rebuild: 43,113 words; OS/compiler suite: 1,749 checks passed. + + +The B32 kernel had only 70 words of headroom before the legacy-app region after adding local arrays. Since RAM files are limited to 511 words, the kind-1 B32 legacy window moved to `0xB800..0xBFFF` and was reduced to 2,048 reserved words, still leaving over three times the largest file size. The emulator's entry/store/GETS bounds, OS program loading, snapshot table ceiling, direct CPU fixture and memory-map docs now agree. The kernel ends at `0xAFBA`, leaving 2,118 words before the B32 legacy window. CPU boundary fixtures verify writes at `0xB800` and rejection below it. Full suites: CPU 191, OS/compiler 1,752, console 28. + +Resident bob32 local arrays are fixed-size, one-dimensional `int` objects within the 32-slot frame budget. The compiler zero-initializes elements, emits indexed loads, and supports indexed assignment statements. A shell regression fills and sums an array in loops and verifies `bob!`/exit 0. At that stage array parameters, explicit initializers, multidimensional arrays and bob16 resident arrays remained unsupported. Full suites: CPU 191, OS/compiler 1,752, console 28. + +Indexed bob32 array statements now also support postfix increment/decrement and compound assignments, including shifts implemented through helper calls. The regression increments element zero, adds to element one and shifts element two before summing. The B32 kernel is 44,833 words, ending at `0xB221` with 1,503 words before the `0xB800` legacy-app region. Full suites: CPU 191, OS/compiler 1,752, console 28. + +Fixed-size bob32 local arrays now accept brace initializer lists containing scalar expressions and an optional trailing comma. Omitted elements retain the zero fill emitted for automatic arrays; an excess element triggers a compile error. The shell fixture validates explicit values and zero-filled tail elements before exercising indexed mutation, then confirms an oversized initializer is rejected. The rebuilt B32 kernel is 45,070 words and ends at `0xB30E`, leaving 1,266 words before the legacy-app region. OS/compiler suite: 1,753 checks passed. + +Indexed bob32 array prefix/postfix increment and decrement now work inside expressions. The generated code preserves the old value for postfix, stores the updated element, then returns the old value; prefix returns the new value. A separate compiled app verifies both value rules at runtime. It is kept separate from the larger array loop test so both remain below the 511-word RAM-file cap. The kernel is 45,299 words, ending at `0xB3F3` with 1,037 words before the legacy window. OS/compiler suite: 1,754 checks passed. + +The bob32 resident parser now accepts comma-separated local scalar and fixed-array declarators, each with its own initializer. Runtime coverage combines an initialized array and scalar, and initializes a scalar from an array postfix expression in the same declaration. The 45,331-word kernel ends at `0xB413`, leaving 1,005 words before the `0xB800` legacy window. OS/compiler suite: 1,754 checks passed. + +The bob32 resident parser now accepts `int` function prototypes with named or unnamed integer parameters, permits unused declarations without definitions, and checks prototype/definition and prototype/call argument counts. A shell integration compiles a prototype-before-definition call and an unused unnamed-parameter declaration, runs it, and rejects conflicting prototypes. The 45,486-word kernel ends at `0xB4AE`, leaving 850 words before the `0xB800` legacy window. OS/compiler suite: 1,758 checks passed. + +Resident bob32 C now supports local function pointers returning `int` and accepting integer arguments. A pointer can be initialized from a function declared by prototype and called indirectly; the integration fixture checks the result, `bob!` output and exit code. The kind-1 compatibility window moved to `0xBA00..0xBFFF` because the kernel reached 46,733 words (`0xB98D` end), leaving 115 words for growth. Emulator bounds, guest loader, storage limit, CPU fixtures and memory-map docs were updated together. Suites: CPU 191, OS/compiler 1,761, console 28. + +Function-pointer initialization and assignment now require a previously declared function with a matching argument count; compatible local function pointers can be copied, and null `0` is supported. Mismatched signatures and integer values are rejected. Kernel growth required moving bob32 compatibility apps to `0xC000..0xCFFF` and the B32 heap to `0xD000..0xDFFF`; bob16 applications move to `0xA000` so its enlarged kernel still fits, with only its dedicated `0x9800..0x980F` compiler-variable area additionally writable by supervised apps. B16 image limits, storage descriptor checks, shell heap bounds, docs and CPU/OS regressions were aligned. Current images: B16 36,325 words (ends `0x90E4`); B32 48,185 words (ends `0xBF38`). Suites: CPU 194, OS/compiler 1,764; console: 28 checks passed. + +Resident bob32 now distinguishes `int f()` from the zero-argument prototype `int f(void)`. A no-prototype declaration can be refined by a typed declaration or later definition; calls before that definition are checked against its eventual parameter count to preserve this calling convention. End-to-end tests cover a valid call through `int loose()` and rejection when a one-argument call precedes a two-argument definition. B32 image: 48,185 words, ending at `0xBF38` with 199 words before the compatibility window. Full suites: CPU 194, OS/compiler 1,764, console 28. + +The bob32 resident compiler now recognizes `print`, `println`, `print_dec` and `print_hex` as kernel functions without requiring source prototypes. A regression runs `write bobs.c int main(void){println("Bob!");return 0;}` followed by `go bobs.c` and verifies `Bob!` with exit status 0. This kernel growth moves the bob32 compatibility-app window to `0xC200..0xCFFF`; the emulator protects that window from writes below it. Current B32 image: 48,645 words, ending at `0xC164`. + +The bob32 resident compiler now stages generated code at the native application origin and can save output up to the available packed filesystem capacity; bob16 retains its 511-word code limit. A shell integration compiles a compact source into a 1,289-word resident app, runs it to print `bob!`, snapshots the filesystem, restores the snapshot, and runs the stored app again. Full suites: CPU 203, OS/compiler 1,822, console 28. + +The bob32 resident compiler now adjusts one-dimensional `int values[]` (and fixed-bound parameter spellings) to a single word-addressed pointer argument using the existing stack ABI. Helpers can index and mutate caller arrays, forward an array to nested helper calls, and combine it with scalar parameters. Regression coverage computes a sum, increments elements in a second helper, calls the sum helper repeatedly, and prints `bob!`; negative cases reject scalar/array argument mismatches, conflicting prototypes, and multidimensional parameter syntax. Full suites: CPU 203, OS/compiler 1,825, console 28. + +Added app-side `bob_string.h` helpers for length/copy/compare/concatenate/search, whitespace checks, signed decimal and hexadecimal parsing with overflow reporting, integer formatting with capacity checks, and in-place quoted command tokenization. A bob32 runtime fixture covers integer limits, malformed input, quoting and escapes; a compact native app imports into bob32 RAM files, prints `bob!`, survives a B32S snapshot restore, and runs again. Full suites: CPU 203, OS/compiler 1,840, console 28. + +The host-compiled C workflow now includes `` backed by the tested `_Bool` type. B16 and B32 guest fixtures verify `bool`, `true` and `false` at runtime and print `bob!`. GCC `-fanalyzer` reported no diagnostics in the emulator, compiler or test sources. At this point suites were CPU 194, OS/compiler 1,769, console 28. + +Added `` with width-matched `size_t`/`ptrdiff_t` and `NULL`. `sizeof` now has unsigned type in expression and type-name forms. Native B16/B32 fixtures verify array size, pointer subtraction, null initialization and unsigned `sizeof` arithmetic. Full suite: CPU 194, OS/compiler 1,773, console 28. + +Host C now supports typed function-pointer declarations and calls, including local/file-scope pointers, nested pointer parameters, function-address relocations, copying, and parenthesized indirect calls. Empty `()` signatures accept unspecified call arguments; typed signatures enforce argument count and compatibility. B16/B32 positive and negative regressions cover these behaviors, including invalid casts between function and object pointers. Full suite: CPU 194, OS/compiler 1,793, console 28. + +Native bob32 application workflow: the RAM filesystem packs eight file slots into 4,096 words, allowing validated B32K v2 images larger than 511 words. `import32 HOST_PATH NAME` stores an image, `run NAME` or `run32 NAME` executes it from guest RAM, and B32S v2 snapshots preserve it; B32S v1 fixed-slot snapshots convert on restore. Integration tests import a 629-word image, execute it through both guest-name commands, save/restore, and execute again. Failure coverage checks missing, invalid and truncated images, storage-capacity exhaustion, checksum corruption and sparse-memory allocation failure. The expanded bob32 kernel now runs at `0x10000..0x1D115`, with native applications starting at `0x20000`. Resident compiler diagnostics include token context with the existing source location. Full suite: CPU 203, OS/compiler 1,813, console 28. diff --git a/tests/test_cpu.c b/tests/test_cpu.c new file mode 100644 index 0000000..4474a29 --- /dev/null +++ b/tests/test_cpu.c @@ -0,0 +1,380 @@ +/* CPU migration checks; include the real implementation rather than a model. */ +#ifndef _WIN32 +#define _POSIX_C_SOURCE 200809L +#endif +#define BOB_TESTING +#define main bob_emulator_main +#include "../main.c" +#undef main +#include +#define TEST_APP_BASE 0x20000u +static int checks; +static int storage_path(const char *path) { +#ifdef _WIN32 + return _putenv_s("BOB16_STORAGE",path); +#else + return *path?setenv("BOB16_STORAGE",path,1):unsetenv("BOB16_STORAGE"); +#endif +} +static void verify(int okay,const char *what) { + checks++;if(!okay){fprintf(stderr,"CPU check failed: %s\n",what);exit(1);} +} +static void reset_cpu(int wide) {memoryReset();memset(&cpu,0,sizeof(cpu));memset(&ram,0,sizeof(ram));cpu32=wide;programMode=false;application32=false;legacyProgram32=false;} +static void step(unsigned instruction) {ram.memory[cpu.pc]=instruction;cpuCycle();} +static void put16(FILE *f,unsigned value) {fputc(value&255,f);fputc((value>>8)&255,f);} +static void put32(FILE *f,uint32_t value) {put16(f,value);put16(f,value>>16);} +static int assembly_text(const char *text) { + FILE *f=tmpfile();if(!f)exit(1);fputs(text,f);rewind(f); + reset_cpu(0);int result=assembleSource(f);fclose(f);return result; +} +static int assembly_bytes(const unsigned char *data,size_t length) { + FILE *f=tmpfile();if(!f)exit(1); + if(fwrite(data,1,length,f)!=length){fclose(f);exit(1);} + rewind(f);reset_cpu(0);int result=assembleSource(f);fclose(f);return result; +} +static void bad_image(const char *executable,const unsigned char *bytes,size_t length) { + FILE *f=fopen("build/cpu-bad.b32","wb");if(!f)exit(1); + if(fwrite(bytes,1,length,f)!=length || fclose(f))exit(1); + char command[4096];snprintf(command,sizeof(command),"\"%s\" --load-fixture build/cpu-bad.b32 > build/cpu-bad.out 2>&1",executable); + verify(system(command)!=0,"invalid wide image rejected"); +} +int main(int argc,char **argv) { + if(argc>1 && !strcmp(argv[1],"--emulator"))return bob_emulator_main(argc-1,argv+1); + if(argc==3 && !strcmp(argv[1],"--load-fixture")){bootImage(argv[2]);return 0;} + if(argc==3 && !strcmp(argv[1],"--disk-argument-fixture")) { + int argument=argv[2][0]-'0';if(argument<0 || argument>2)return 2; + reset_cpu(1);bootMode=true;bootWords=1;bootDisk[0]=42; + cpu.regFile[0]=argument==0?0x10000:0x300;cpu.regFile[1]=0;cpu.regFile[2]=1; + cpu.regFile[argument]|=0x10000;step(0xf400); + return argument==0 && memoryRead(0x10000)!=42?1:0; + } + if(argc==2 && !strcmp(argv[1],"--puts-fixture")) { + reset_cpu(1);cpu.regFile[0]=0x10000; + memoryWrite(0x10000,0x10000);memoryWrite(0x10001,'b');memoryWrite(0x10002,'o'); + memoryWrite(0x10003,'b');memoryWrite(0x10004,'!');step(0xf200); + return cpu.ir==0xf200?0:1; + } + for(unsigned bits=1;bits<=16;bits++) { + verify(sext((int16_t)((1u<>(8*i))&255,old_snapshot)==EOF)return 1; + if(fseek(old_snapshot,16,SEEK_SET))return 1; + for(unsigned i=0;i>(8*b))&255,old_snapshot)==EOF)return 1; + if(fclose(old_snapshot))return 1; + ram.memory[0xf000]=0;ram.memory[0xf002]=0; + verify(snapshotService(0x300,1)==0 && ram.memory[0xf000]==0x12345678 && ram.memory[0xf002]=='b',"legacy fixed-slot B32S snapshot converts to packed filesystem layout"); + cpu32=false;ram.memory[0xf000]=42; + verify(snapshotService(0x300,1)==-2 && ram.memory[0xf000]==42,"legacy rejects wide snapshot without modifying RAM"); + cpu32=true;kernelIdentity++; + verify(snapshotService(0x300,1)==1,"wide snapshot reports changed kernel identity"); + verify(ram.memory[0x520]==0 && ram.memory[0x521]==1 && ram.memory[0xf000]=='b' && ram.memory[0xf003]=='!',"wide kernel change drops binaries and preserves text"); + kernelIdentity--; + if(storage_path(""))return 1; + uint32_t snapshot[SNAP_WORDS]={0}; + verify(snapshotValid(snapshot),"empty snapshot metadata"); + snapshot[0]='b';snapshot[1]='o';snapshot[2]='b';snapshot[3]='!';snapshot[192]=4;snapshot[208]=1; + snapshot[216]='b';snapshot[217]='o';snapshot[218]='b';snapshot[219]='!'; + verify(snapshotValid(snapshot),"valid text snapshot metadata"); + snapshot[218]=0;verify(!snapshotValid(snapshot),"text snapshot rejects embedded terminator");snapshot[218]='b'; + snapshot[220]=1;verify(!snapshotValid(snapshot),"snapshot rejects missing content terminator");snapshot[220]=0; + snapshot[192]=512;verify(!snapshotValid(snapshot),"snapshot rejects excessive length");snapshot[192]=4; + snapshot[208]=2;verify(!snapshotValid(snapshot),"snapshot rejects invalid used flag");snapshot[208]=1; + snapshot[200]=2;verify(snapshotValid(snapshot),"bob32 snapshots accept native program files"); + snapshot[200]=4;verify(!snapshotValid(snapshot),"snapshot rejects invalid kind");snapshot[200]=0; + memcpy(snapshot+24,snapshot,24*sizeof(uint32_t));snapshot[209]=1; + verify(!snapshotValid(snapshot),"snapshot rejects duplicate names");snapshot[209]=0; + verify(assembly_text(".stringz bob!\n.fill 1234\n")==0 && ram.memory[4]==0 && ram.memory[5]==0x1234,"string directive emits exactly one terminator"); + verify(assembly_text("add r0 r1 r2\r\n.fill ffff\r\n")==0 && ram.memory[1]==0xffff,"CRLF token separation"); + verify(assembly_text(".fill ffffg\n")<0,"fill rejects trailing text"); + const unsigned char embedded_nul[]={'.','f','i','l','l',' ','1',0,' ','x','\n'}; + verify(assembly_bytes(embedded_nul,sizeof(embedded_nul))<0,"assembly rejects embedded zero byte"); + verify(assembly_text(".fill 10000\n")<0,"fill rejects truncation"); + verify(assembly_text(".fill -1\n")<0,"fill rejects signed text"); + verify(assembly_text("nop\n.fill 1234\n")==0 && ram.memory[0]==0 && ram.memory[1]==0x1234,"documented nop assembles"); + verify(assembly_text("nop r0\n")<0,"nop rejects operands"); + char boundary_source[300];memset(boundary_source,' ',252);strcpy(boundary_source+252,"nop\r\n.fill 1234\n"); + verify(assembly_text(boundary_source)==0 && ram.memory[0]==0 && ram.memory[1]==0x1234,"exact-limit CRLF source line keeps following instruction"); + memset(boundary_source,' ',253);strcpy(boundary_source+253,"nop\r\n.fill 1234\n"); + verify(assembly_text(boundary_source)<0,"source line over the limit remains rejected"); + const char *bad_operands[]={"add r0 r1 r8\n","add r0 bogus\n","and r0 r1 1x\n","and r0 r9\n", + "not r0 r8\n","not r0 r1 ignored\n","not\n","ld r0 bogus\n","ld r8 0\n","ld xx 0\n", + "ldi r8 0\n","ldr r0 r8 0\n","ldr r8 r0 0\n","ldr r0 r1 --1\n", + "st r8 0\n","st xx 0\n","st r0 1x\n","sti r8 0\n","sti r0 bogus\n", + "str r8 r0 0\n","str r0 r8 0\n","str r0 r1 r8\n","br np 1x\n","jsr bogus\n","lea r0 bogus\n", + "trap nonsense\n","trap 12\n","trap 15\n", + "br nx 1\n","add r0 999999999999999999999\n"}; + for(unsigned i=0;i build/cpu-disk-argument.out 2>&1",argv[0]); + verify(system(command)==0,"wide boot disk trap writes to full-width destination"); + for(unsigned argument=1;argument<3;argument++) { + snprintf(command,sizeof(command),"\"%s\" --disk-argument-fixture %u > build/cpu-disk-argument.out 2>&1",argv[0],argument); + verify(system(command)!=0,"wide boot disk trap rejects truncated arguments"); + FILE *fault=fopen("build/cpu-disk-argument.out","rb");if(!fault)return 1; + char diagnostic[256];size_t used=fread(diagnostic,1,sizeof(diagnostic)-1,fault);fclose(fault);diagnostic[used]=0; + verify(strstr(diagnostic,"Invalid boot disk argument")!=NULL,"disk argument fixture reaches the intended trap fault"); + } + snprintf(command,sizeof(command),"\"%s\" --puts-fixture > build/cpu-puts.out",argv[0]); + verify(system(command)==0,"wide string trap preserves instruction state"); + FILE *output=fopen("build/cpu-puts.out","rb");if(!output)return 1; + unsigned char bytes[7];size_t length=fread(bytes,1,sizeof(bytes),output);fclose(output); +#ifdef _WIN32 + verify(length==7 && !memcmp(bytes,"\0bob!\r\n",7),"wide string terminator compares entire word"); +#else + verify(length==6 && !memcmp(bytes,"\0bob!\n",6),"wide string terminator compares entire word"); +#endif + FILE *f=fopen("build/cpu-wide.b32","wb");if(!f)return 1; + uint32_t words[]={0x4001,0,0x12345678};unsigned sum=0; + for(unsigned i=0;i<3;i++)sum+=words[i]; + fwrite("B32K",1,4,f);put16(f,1);put16(f,0x300);put16(f,0x300);put16(f,3);put16(f,sum);put16(f,sum>>16); + for(unsigned i=0;i<3;i++){put16(f,words[i]);put16(f,words[i]>>16);}fclose(f); + unsigned char image[29];f=fopen("build/cpu-wide.b32","rb");if(!f)return 1; + verify(fread(image,1,28,f)==28,"wide fixture length");fclose(f); + bad_image(argv[0],image,14);bad_image(argv[0],image,27); + image[12]^=1;bad_image(argv[0],image,28);image[12]^=1; + image[28]=0;bad_image(argv[0],image,29); + unsigned char entry=image[8];image[8]=0xff;image[9]=0xff;bad_image(argv[0],image,28);image[8]=entry;image[9]=3; + image[4]=2;bad_image(argv[0],image,28);image[4]=1; + bootImage("build/cpu-wide.b32"); + verify(cpu32 && bootDisk[2]==0x12345678,"wide image loader"); + for(unsigned i=0;i<6;i++)cpuCycle(); + verify(cpu.pc==0x300 && ram.memory[0x302]==0x12345678,"wide guest boot disk transfer"); + cpuCycle();verify(cpu.regFile[0]==0x12345678,"wide image native execution"); + f=fopen("build/cpu-wide-v2.b32","wb");if(!f)return 1; + uint32_t wide_words[]={0x1080,0x12345678};uint32_t wide_sum=wide_words[0]+wide_words[1]; + fwrite("B32K",1,4,f);put16(f,2);put16(f,24);put32(f,0x10000);put32(f,0x10000); + put32(f,2);put32(f,wide_sum);put32(f,wide_words[0]);put32(f,wide_words[1]);fclose(f); + bootImage("build/cpu-wide-v2.b32"); + verify(cpu32 && cpu.pc==0x10000 && memoryRead(0x10001)==0x12345678,"B32K v2 loads at a 32-bit origin and entry"); + cpuCycle();verify(cpu.pc==0x10001 && cpu.regFile[0]==0,"B32K v2 executes at a high address"); + unsigned char v2_image[33];f=fopen("build/cpu-wide-v2.b32","rb");if(!f)return 1; + verify(fread(v2_image,1,32,f)==32,"B32K v2 fixture length");fclose(f);v2_image[32]=0; + bad_image(argv[0],v2_image,23); + v2_image[4]=3;bad_image(argv[0],v2_image,32);v2_image[4]=2; + v2_image[6]=22;bad_image(argv[0],v2_image,32);v2_image[6]=24; + for(unsigned i=8;i<16;i++)v2_image[i]=0xff; + bad_image(argv[0],v2_image,32); + v2_image[8]=0;v2_image[9]=0;v2_image[10]=1;v2_image[11]=0; + v2_image[12]=0;v2_image[13]=0;v2_image[14]=1;v2_image[15]=0; + v2_image[12]=0;v2_image[13]=0;v2_image[14]=2;v2_image[15]=0;bad_image(argv[0],v2_image,32);v2_image[12]=0;v2_image[13]=0;v2_image[14]=1;v2_image[15]=0; + v2_image[16]=1;v2_image[17]=0;v2_image[18]=1;v2_image[19]=0;bad_image(argv[0],v2_image,32);v2_image[16]=2;v2_image[17]=0;v2_image[18]=0;v2_image[19]=0; + v2_image[31]^=1;bad_image(argv[0],v2_image,32);v2_image[31]^=1; + bad_image(argv[0],v2_image,33); + for(unsigned i=8;i<16;i++)v2_image[i]=0xff; + v2_image[8]=0xfe;v2_image[12]=0xfe; + f=fopen("build/cpu-wide-v2-edge.b32","wb");if(!f)return 1; + if(fwrite(v2_image,1,32,f)!=32 || fclose(f))return 1; + bootImage("build/cpu-wide-v2-edge.b32"); + verify(cpu.pc==0xfffffffeu && memoryRead(0xffffffffu)==0x12345678,"B32K v2 accepts the final two addressable words"); + cpuCycle();verify(cpu.pc==0xffffffffu,"B32K v2 executes across the top of the address space"); + snprintf(command,sizeof(command),"\"%s\" --emulator --boot build/cpu-wide-v2-edge.b32 --max-cycles 1 > build/cpu-v2-limit.out 2>&1",argv[0]); +#ifdef _WIN32 + verify(system(command)==2,"command-line B32K v2 boot honors cycle limit"); +#else + verify(system(command)==512,"command-line B32K v2 boot honors cycle limit"); +#endif + snprintf(command,sizeof(command),"\"%s\" --emulator --boot build/cpu-wide.b32 --max-cycles 1 > build/cpu-limit.out 2>&1",argv[0]); +#ifdef _WIN32 + verify(system(command)==2,"command-line cycle limit exit status"); +#else + verify(system(command)==512,"command-line cycle limit exit status"); +#endif + f=fopen("build/cpu-page-fail.b32","wb");if(!f)return 1; + fwrite("B32K",1,4,f);put16(f,2);put16(f,24);put32(f,0x20000);put32(f,0x20000); + put32(f,1);put32(f,0xf000);put32(f,0xf000);if(fclose(f))return 1; + reset_cpu(1);const char *page_fail_path="build/cpu-page-fail.b32"; + for(unsigned i=0;page_fail_path[i];i++)memoryWrite(0x100+i,page_fail_path[i]); + failNextSparsePageAllocation=1; + verify(runWideImageFromGuest(0x100)==-5 && memoryPage(0x20,0)==NULL && memoryRead(0x20000)==0, + "B32 app image allocation failure leaves its sparse region untouched"); + reset_cpu(1);ram.memory[0x300]=0xf000;ram.memory[0x301]=7; + ram.memory[0xf000]=0x4233324b;ram.memory[0xf001]=0x00180002;ram.memory[0xf002]=0x20000;ram.memory[0xf003]=0x20000; + ram.memory[0xf004]=1;ram.memory[0xf005]=0xe000;ram.memory[0xf006]=0xe000; + verify(runWidePackedFromGuest(0x300)==0,"native app loads and executes from packed guest RAM image"); + reset_cpu(1);ram.memory[0x300]=0xf000;ram.memory[0x301]=7; + ram.memory[0xf000]=0x4233324b;ram.memory[0xf001]=0x00180002;ram.memory[0xf002]=0x20000;ram.memory[0xf003]=0x20000; + ram.memory[0xf004]=1;ram.memory[0xf005]=0xe000;ram.memory[0xf006]=0; + verify(runWidePackedFromGuest(0x300)==-4,"native app checksum corruption rejected before execution"); + reset_cpu(1);ram.memory[0x300]=0xf000;ram.memory[0x301]=7; + ram.memory[0xf000]=0x4233324b;ram.memory[0xf001]=0x00180002;ram.memory[0xf002]=0x20000;ram.memory[0xf003]=0x20000; + ram.memory[0xf004]=1;ram.memory[0xf005]=0xe000;ram.memory[0xf006]=0xe000;failNextSparsePageAllocation=1; + verify(runWidePackedFromGuest(0x300)==-5 && memoryPage(0x10,0)==NULL,"native app reports insufficient sparse memory without partial load"); + f=fopen("build/cpu-import.b32","wb");if(!f)return 1; + fwrite("B32K",1,4,f);put16(f,2);put16(f,24);put32(f,0x20000);put32(f,0x20000);put32(f,1);put32(f,0xe000);put32(f,0xe000);if(fclose(f))return 1; + reset_cpu(1);const char *import_path="build/cpu-import.b32"; + for(unsigned i=0;import_path[i];i++)ram.memory[0x100+i]=import_path[i]; + ram.memory[0x300]=0x100;ram.memory[0x301]=0xf000;ram.memory[0x302]=7;ram.memory[0xf000]=99; + verify(importWideImageFromGuest(0x300)==-5 && ram.memory[0xf000]==99,"native image import reports insufficient filesystem capacity without overwriting it"); + ram.memory[0x302]=8; + verify(importWideImageFromGuest(0x300)==7 && ram.memory[0xf006]==0xe000,"native image import validates and packs a B32K v2 image"); + ram.memory[0x310]=0xf000;ram.memory[0x311]=7; + verify(runWidePackedFromGuest(0x310)==0,"imported native image executes from packed filesystem storage"); + bootImage("build/kernel.b16");verify(!cpu32,"legacy image selects compatibility mode"); + f=fopen("build/cpu-input.basm","w");if(!f)return 1; + fputs("lea r0 2\ntrap 2\ntrap 0\n.stringz bob!\n",f);fclose(f); + f=fopen("build/cpu-input.in","wb");if(!f)return 1; + for(int i=0;i<255;i++)fputc('x',f); + fputs("\r\n",f); + for(int i=0;i<300;i++)fputc('x',f); + fputs("\nbuild/cpu-input.basm\n",f);fclose(f); + snprintf(command,sizeof(command),"\"%s\" --emulator < build/cpu-input.in > build/cpu-input.out 2>&1",argv[0]); + verify(system(command)==0,"assembly prompt recovers after oversized file name"); + f=fopen("build/cpu-input.out","rb");if(!f)return 1; + char prompt_output[4096];size_t prompt_length=fread(prompt_output,1,sizeof(prompt_output)-1,f);fclose(f);prompt_output[prompt_length]=0; + verify(strstr(prompt_output,"Source file name exceeds 255 characters!") && strstr(prompt_output,"Starting execution!") && strstr(prompt_output,"bob!"),"oversized file name is consumed before next input"); + char *first_long=strstr(prompt_output,"Source file name exceeds 255 characters!"); + verify(first_long && !strstr(first_long+1,"Source file name exceeds 255 characters!"),"exact-limit CRLF filename is not reported as oversized"); + puts("bob!");printf("%d CPU checks passed.\n",checks);return 0; +} diff --git a/tests/test_os.c b/tests/test_os.c index e518da4..537951c 100644 --- a/tests/test_os.c +++ b/tests/test_os.c @@ -9,12 +9,19 @@ #else #define BOB "bob.exe" #endif +#ifdef BOB_VERIFY +#define BOB32 "build\\bob32-next.exe" +#else +#define BOB32 "bob32.exe" +#endif #define COMPILER "build\\bobcc.exe" #else #define BOB "./bob" +#define BOB32 "./bob32" #define COMPILER "./build/bobcc" #endif static int checks; +static void storage_path(const char *path); static void fail(const char *message) { fprintf(stderr,"Check failed: %s\n",message);exit(1); } static void check(int condition,const char *message) { checks++;if(!condition)fail(message); } static void write_text(const char *path,const char *text) { @@ -43,6 +50,139 @@ static void guest(const char *source) { check(system(BOB " --boot build/check.b16 --max-cycles 50000000 < build/check.in > build/check.out 2> build/check.err")==0,"guest execution"); char *output=read_text("build/check.out");check(!strcmp(output,"bob!\n"),"guest success marker");free(output); } +static void guest32(const char *source) { + write_text("build/wide-lib.c",source); + check(system("gcc -E -P -nostdinc -undef -DBOBC_LEGACY=0 -I kernel build/wide-lib.c -o build/wide-lib.i > build/compiler.log 2>&1")==0,"bob32 library guest preprocessing"); + check(system(COMPILER " build/wide-lib.i build/wide-lib.basm build/wide-lib.b32 --wide > build/compiler.log 2>&1")==0,"bob32 library guest compilation"); + write_text("build/check.in",""); + check(system(BOB32 " --boot build/wide-lib.b32 --max-cycles 50000000 < build/check.in > build/check.out 2> build/check.err")==0,"bob32 library guest execution"); + char *output=read_text("build/check.out");check(!strcmp(output,"bob!\n"),"bob32 library success marker");free(output); +} +static void native_string_library(void) { + guest32( + "#include \"bob.h\"\n" + "#include \"bob_string.h\"\n" + "int main(void){\n" + "char text[64]=\"Bob\";char output[16];char command[64]=\"notes \\\"my note\\\" escaped\\\\ token\";\n" + "char malformed[24]=\"broken \\\"quote\";char *found;char *cursor;char *token;int valid;int parsed;\n" + "if(bob_strlen(text)!=3||bob_strcpy(text,\"Bob\")!=text)return 1;\n" + "if(bob_strcat(text,\"!\")!=text||bob_strcmp(text,\"Bob!\"))return 2;\n" + "found=bob_strchr(text,'!');if(!found||found-text!=3)return 3;\n" + "if(!bob_isspace('\\t')||bob_isspace('x'))return 4;\n" + "parsed=bob_parse_int(\" \\t-2147483648 \",&valid);if(!valid||parsed!=(-2147483647-1))return 5;\n" + "if(bob_format_int(parsed,output,16)!=11||bob_strcmp(output,\"-2147483648\"))return 6;\n" + "if(bob_format_int(-42,output,3)!=-1)return 7;\n" + "if(bob_parse_int(\"0x2a\",&valid)!=42||!valid)return 8;\n" + "bob_parse_int(\"2147483648\",&valid);if(valid)return 9;\n" + "bob_parse_int(\"12x\",&valid);if(valid)return 10;\n" + "cursor=command;if(bob_token_next(&cursor,&token)!=1||bob_strcmp(token,\"notes\"))return 11;\n" + "if(bob_token_next(&cursor,&token)!=1||bob_strcmp(token,\"my note\"))return 12;\n" + "if(bob_token_next(&cursor,&token)!=1||bob_strcmp(token,\"escaped token\"))return 13;\n" + "if(bob_token_next(&cursor,&token)!=0)return 14;\n" + "cursor=malformed;if(bob_token_next(&cursor,&token)!=1)return 15;\n" + "if(bob_token_next(&cursor,&token)!=-1)return 16;\n" + "bob_puts(\"bob!\");return 0;}\n"); + write_text("build/string-app.c", + "#include \"bob.h\"\n#include \"bob_string.h\"\n" + "int main(void){char text[16]=\"Bob\";bob_strcat(text,\"!\");" + "if(bob_strlen(text)==4&&!bob_strcmp(text,\"Bob!\")){bob_puts(\"bob!\");return 0;}return 1;}\n"); + check(system("gcc -E -P -nostdinc -undef -DBOBC_LEGACY=0 -I kernel build/string-app.c -o build/string-app.i > build/compiler.log 2>&1")==0,"bob32 string app preprocessing"); + check(system(COMPILER " build/string-app.i build/string-app.basm build/string-app.b32 --wide-app > build/compiler.log 2>&1")==0,"bob32 string app compilation"); + storage_path("build/string-library-snapshot.b32"); + write_text("build/check.in","import32 build/string-app.b32 stringlib\nrun stringlib\nsave\nhalt\n"); + check(system(BOB32 " --boot build/kernel32.b32 --max-cycles 50000000 < build/check.in > build/check.out 2> build/check.err")==0,"bob32 stores and runs a native string-library app"); + char *output=read_text("build/check.out");contains(output,"Imported native app as stringlib");contains(output,"bob> bob!\nExit 0");contains(output,"Files saved to bob-files.b32");free(output); + write_text("build/check.in","restore yes\nrun stringlib\nhalt\n"); + check(system(BOB32 " --boot build/kernel32.b32 --max-cycles 50000000 < build/check.in > build/check.out 2> build/check.err")==0,"bob32 string-library app survives snapshot restore"); + output=read_text("build/check.out");contains(output,"Files restored;");contains(output,"bob> bob!\nExit 0");free(output); + write_text("build/argv-app.c", + "#include \"bob.h\"\n#include \"bob_string.h\"\n" + "int main(int argc,char **argv){if(argc!=5)return argc;" + "if(bob_strcmp(argv[1],\"Bob OS\")||bob_strcmp(argv[2],\"escaped token\")||bob_strcmp(argv[3],\"\"))return 2;" + "bob_puts(\"bob!\");return 0;}\n"); + check(system("gcc -E -P -nostdinc -undef -DBOBC_LEGACY=0 -I kernel build/argv-app.c -o build/argv-app.i > build/compiler.log 2>&1")==0,"bob32 argv app preprocessing"); + check(system(COMPILER " build/argv-app.i build/argv-app.basm build/argv-app.b32 --wide-app > build/compiler.log 2>&1")==0,"bob32 argv app compilation"); + write_text("build/check.in","import32 build/argv-app.b32 argvapp\nrun argvapp \"Bob OS\" escaped\\ token \"\"\nhalt\n"); + check(system(BOB32 " --boot build/kernel32.b32 --max-cycles 50000000 < build/check.in > build/check.out 2> build/check.err")==0,"bob32 passes quoted arguments to native apps"); + output=read_text("build/check.out");contains(output,"bob> bob!\nExit 0");free(output); + storage_path("build/snapshot.b16"); +} +static void wide_guest(void) { + write_text("build/wide-check.c", + "#include \"bob.h\"\n" + "#include \n" + "#include \n" + "int combine_values(int a,int b){return a+b;}\n" + "int double_value(int value){return value*2;}\n" + "int (*combine)(int,int)=combine_values;\n" + "int apply_value(int (*operation)(int),int value){return operation(value);}\n" + "int main(void) { int x=0x12345678; if(x+1!=0x12345679)return 1; " + "bool enabled=true; if(!enabled || false)return 10; enabled=false; if(enabled)return 11; " + "int values[3];size_t words=sizeof values;ptrdiff_t distance=&values[2]-&values[0];int *empty=NULL; " + "if(words!=3 || distance!=2 || empty!=NULL || (sizeof(int)-2)!=(size_t)-1)return 12; " + "if(combine(4,5)!=9)return 13; " + "int (*scale)(int (*)(int),int)=apply_value; if(scale(double_value,7)!=14)return 14; " + "if(-x!=-305419896)return 2; if((0x70000000+0x70000000)!=0xe0000000)return 3; " + "if(0x70000000*2!=0xe0000000)return 4; " + "if(0x70000000/7!=0x10000000 || 0x70000000%7)return 5; " + "if(-123456789/12345!=-10000 || -123456789%12345!=-6789)return 6; " + "if(0xf0000000u/3u!=0x50000000u || 0xf0000000u%3u)return 7; " + "if(0x80000000u>>1!=0x40000000u || (-8>>2)!=-2)return 8; " + "if((0xf0000000u>0x10000000u)==0)return 9; " + "bob_puts(\"bob!\"); return 0; }\n"); + check(system("gcc -E -P -nostdinc -undef -DBOBC_LEGACY=0 -I kernel build/wide-check.c -o build/wide-check.i > build/compiler.log 2>&1")==0,"wide guest preprocessing"); + check(system(COMPILER " build/wide-check.i build/wide-check.basm build/wide-check.b32 --wide > build/compiler.log 2>&1")==0,"wide guest compilation"); + FILE *image=fopen("build/wide-check.b32","rb");if(!image)fail("cannot read wide image"); + char magic[4];check(fread(magic,1,4,image)==4 && !memcmp(magic,"B32K",4),"wide compiler emits B32K"); + check(fgetc(image)==2 && fgetc(image)==0,"wide compiler emits B32K v2");fclose(image); + write_text("build/check.in",""); + check(system(BOB " --boot build/wide-check.b32 --max-cycles 50000000 < build/check.in > build/check.out 2> build/check.err")==0,"wide guest execution"); + char *output=read_text("build/check.out");check(!strcmp(output,"bob!\n"),"wide guest success marker");free(output); + write_text("build/wide-small.c","#include \"bob.h\"\nint main(void){bob_puts(\"bob!\");return 0;}\n"); + check(system("gcc -E -P -nostdinc -undef -DBOBC_LEGACY=0 -I kernel build/wide-small.c -o build/wide-small.i > build/compiler.log 2>&1")==0,"small wide guest preprocessing"); + check(system(COMPILER " build/wide-small.i build/wide-small.basm build/wide-small.b32 --wide > build/compiler.log 2>&1")==0,"small wide guest compilation"); + image=fopen("build/wide-small.b32","rb");if(!image)fail("cannot read small wide image"); + check(fseek(image,0,SEEK_END)==0 && ftell(image)<=24+511*4,"reachable helpers keep small bob32 app within one OS file");fclose(image); + check(system(BOB " --boot build/wide-small.b32 --max-cycles 50000000 < build/check.in > build/check.out 2> build/check.err")==0,"small wide guest execution"); + output=read_text("build/check.out");check(!strcmp(output,"bob!\n"),"small wide guest success marker");free(output); + check(system(BOB32 " --asm32 build/wide-small.basm < build/check.in > build/check.out 2> build/check.err")==0,"wide BASM direct assembly and execution"); + output=read_text("build/check.out");check(!strcmp(output,"bob!\n"),"wide BASM success marker");free(output); + write_text("build/wide-types.c", + "#include \"bob.h\"\n" + "int main(void){long a=7L;unsigned long b=0xffffffffUL;long long c=3LL;" + "if(sizeof(long)!=1 || sizeof(a)!=1 || sizeof(unsigned long*)!=1 || sizeof(char)!=1 || sizeof(int[3])!=3)return 1;" + "if(a+c!=10 || b>>1!=0x7fffffffUL)return 2;bob_puts(\"bob!\");return 0;}\n"); + check(system("gcc -E -P -nostdinc -undef -DBOBC_LEGACY=0 -I kernel build/wide-types.c -o build/wide-types.i > build/compiler.log 2>&1")==0,"wide type guest preprocessing"); + check(system(COMPILER " build/wide-types.i build/wide-types.basm build/wide-types.b32 --wide > build/compiler.log 2>&1")==0,"wide long type compilation"); + check(system(BOB " --boot build/wide-types.b32 --max-cycles 50000000 < build/check.in > build/check.out 2> build/check.err")==0,"wide type guest execution"); + output=read_text("build/check.out");check(!strcmp(output,"bob!\n"),"wide long and sizeof semantics");free(output); + write_text("build/wide-bad.c","int main(void){return 1lul;}\n"); + check(system("gcc -E -P -nostdinc -undef build/wide-bad.c -o build/wide-bad.i > build/compiler.log 2>&1")==0,"invalid wide suffix preprocessing"); + check(system(COMPILER " build/wide-bad.i build/wide-bad.basm build/wide-bad.b32 --wide > build/compiler.log 2>&1")!=0,"invalid mixed integer suffix rejected"); + output=read_text("build/compiler.log");contains(output,"invalid integer suffix");free(output); + write_text("build/wide-app.c","#include \"bob.h\"\nint main(void){bob_puts(\"bob!\");return 0;}\n"); + check(system("gcc -E -P -nostdinc -undef -DBOBC_LEGACY=0 -I kernel build/wide-app.c -o build/wide-app.i > build/compiler.log 2>&1")==0,"wide OS app preprocessing"); + check(system(COMPILER " build/wide-app.i build/wide-app.basm build/wide-app.b32 --wide-app > build/compiler.log 2>&1")==0,"wide OS app compilation"); + image=fopen("build/wide-app.b32","rb");if(!image)fail("cannot read wide OS app image"); + unsigned char app_header[24];check(fread(app_header,1,sizeof(app_header),image)==sizeof(app_header),"wide OS app header read");fclose(image); + check(!memcmp(app_header,"B32K",4) && app_header[8]==0 && app_header[9]==0 && app_header[10]==2 && app_header[11]==0,"wide OS app uses supervised high-memory origin"); + image=fopen("build/wide-app.b32","rb");if(!image)fail("cannot reopen wide app image"); + fseek(image,0,SEEK_END);long image_size=ftell(image);rewind(image);unsigned char *image_bytes=malloc((size_t)image_size);if(!image_bytes)fail("wide app allocation"); + check(fread(image_bytes,1,(size_t)image_size,image)==(size_t)image_size,"read wide app for large fixture");fclose(image); + uint32_t image_words=(uint32_t)image_bytes[16]|((uint32_t)image_bytes[17]<<8)|((uint32_t)image_bytes[18]<<16)|((uint32_t)image_bytes[19]<<24); + image_words+=600;for(int i=0;i<4;i++)image_bytes[16+i]=(unsigned char)(image_words>>(8*i)); + check(image_words>511,"native B32 fixture exceeds the former per-file limit"); + image=fopen("build/wide-large.b32","wb");if(!image)fail("create large B32 image"); + check(fwrite(image_bytes,1,(size_t)image_size,image)==(size_t)image_size,"write large image prefix"); + unsigned char zeros[2400]={0};check(fwrite(zeros,1,sizeof(zeros),image)==sizeof(zeros),"append large image payload");fclose(image);free(image_bytes); + image=fopen("build/wide-large.b32","rb");if(!image)fail("open large B32 image for truncated fixture"); + unsigned char short_header[24];check(fread(short_header,1,sizeof(short_header),image)==sizeof(short_header),"read truncated image header");fclose(image); + image=fopen("build/wide-truncated.b32","wb");if(!image)fail("create truncated B32 image"); + check(fwrite(short_header,1,sizeof(short_header),image)==sizeof(short_header),"write truncated image header");fclose(image); + write_text("build/check.in",""); + check(system(BOB32 " --asm32 build/wide-app.basm < build/check.in > build/check.out 2> build/check.err")==0,"wide .org BASM assembly and direct application execution"); + output=read_text("build/check.out");check(!strcmp(output,"bob!\n"),"wide-origin BASM application output");free(output); +} static void console_and_commands(void) { char *output=shell("help\necho bob!\nclear\nmem\nalloc 4\npoke 0xc000 -32768\npeek 0xc000\npoke 0 1\nhalt\n"); contains(output,"bob!\nbob16 OS:");contains(output,"help | echo TEXT");contains(output,"bob> bob!\n"); @@ -77,12 +217,34 @@ static void allocator_and_files(void) { output=shell(large);contains(output,"full 511 chars (text)");free(output); } static void resident_compiler(void) { + char oversized[2048];strcpy(oversized,"cc bob.c keep\nedit large.c\nint main(void){\n"); + for(int i=0;i<28;i++)strcat(oversized,"println(\"bob!\");\n"); + strcat(oversized,"return 0;}\n.\ncc large.c keep\nrun keep\ngo bob.c\nhalt\n"); + char *bounded=shell(oversized);contains(bounded,"C compile error near character"); + contains(bounded,"bob!\nExit 0");not_contains(bounded,"Program fault");free(bounded); + char *joined=shell("edit joined.c\nint main(void){println(\"bo\" /* join */ \"b\" \"\"\n\"!\");return 0;}\n.\ngo joined.c\nhalt\n"); + not_contains(joined,"compile error");contains(joined,"bob!\nExit 0");free(joined); + char *broken=shell("edit broken.c\nint main(void){println(\"bob!\n\");return 0;}\n.\ngo broken.c\n" + "edit broken.c\n:r 1 int main(void){int x='\n:r 2 ';return 0;}\n.\ngo broken.c\ngo bob.c\nhalt\n"); + int errors=0;const char *error=broken;while((error=strstr(error,"C compile error near character"))){errors++;error++;} + check(errors==2,"resident rejects literal line breaks");contains(broken,"bob!\nExit 0");free(broken); + char *escapes=shell("edit escapes.c\nint main(void){if('\\a'!=7 || '\\b'!=8 || '\\f'!=12)return 1;\n" + "if('\\r'!=13 || '\\v'!=11 || '\\?'!=63)return 2;println(\"bob!\");return 0;}\n.\ngo escapes.c\nhalt\n"); + not_contains(escapes,"compile error");contains(escapes,"bob!\nExit 0");free(escapes); + char *octal=shell("write octal.c int main(void){if(010!=8 || 077!=63 || 0177777!=0xffff)return 1;println(\"bob!\");return 0;}\ngo octal.c\nhalt\n"); + not_contains(octal,"compile error");contains(octal,"bob!\nExit 0");free(octal); + octal=shell("write bad.c int main(void){return 09;}\ngo bad.c\nwrite bad.c int main(void){return 0200000;}\ngo bad.c\ngo bob.c\nhalt\n"); + contains(octal,"C compile error near character");contains(octal,"bob!\nExit 0");free(octal); char *output=shell("cc bob.c bob\nrun bob\necho bob!\nhalt\n"); contains(output,"Compiled 42 words.");contains(output,"bob> bob!\nExit 0\nbob> bob!\n");free(output); output=shell("edit calc.c\nint main(void) { int n = 0; while (n < 3) { n = n + 1; }\nif (n == 3) { println(\"bob!\"); } else { return 1; } return 0; }\n.\ncc calc.c calc\nrun calc\nhalt\n"); not_contains(output,"compile error");contains(output,"bob> bob!\nExit 0");free(output); output=shell("write math.c int main(void) { int a = 6 * 7; if (a / 2 == 21) println(\"bob!\"); return a % 7; }\ncc math.c math\nrun math\nhalt\n"); not_contains(output,"compile error");contains(output,"bob> bob!\nExit 0");free(output); + output=shell("edit product.c\nint main(void){int high=32767;int low=-32767-1;int i=0;\n" + "while(i<64){if(high*high!=1)return 1;if(low*high!=low)return 2;i++;}\n" + "if(low*2!=0 || (-7)*9!=-63)return 3;println(\"bob!\");return 0;}\n.\ngo product.c\nhalt\n"); + not_contains(output,"compile error");not_contains(output,"Program timed out");contains(output,"bob!\nExit 0");free(output); output=shell("write bad.c int main(void) { int a = ; }\ncc bad.c bad\nrun bad\ncc bob.c bob\nrun bob\nhalt\n"); contains(output,"C compile error near character");contains(output,"Program not found.");contains(output,"bob> bob!\nExit 0");free(output); /* Verify both APIs and signed numeric formatting in resident-generated code. */ @@ -125,7 +287,7 @@ static void program_loading_and_recovery(void) { contains(output,"Command too long.");contains(output,"Program not found.");free(output); output=shell("load raw 0x4001 0xae01 98 0xf100 0x4001 0xae01 111 0xf100 0x4001 0xae01 98 0xf100 0x4001 0xae01 33 0xf100 0xe000\nrun raw\nhalt\n"); contains(output,"Loaded.");contains(output,"bob> bob!Exit 33");free(output); - output=shell("load bad 0x1001\nrun bad\nload spin 0x4601 0xb600 0x9000\nrun spin\necho bob!\nhalt\n"); + output=shell("load bad 0x1001\nrun bad\nload spin 0x4601 0xb600 0xa000\nrun spin\necho bob!\nhalt\n"); contains(output,"Program fault; shell restored.");contains(output,"Program timed out; shell restored.");contains(output,"bob> bob!\n");free(output); /* Load a program that tries to store to kernel address zero. */ output=shell("load guard 0x4201 0xae01 0 0x9040 0xe000\nrun guard\ncc bob.c bob\nrun bob\nhalt\n"); @@ -135,6 +297,236 @@ static void program_loading_and_recovery(void) { contains(output,"Program fault; shell restored.");contains(output,"bob> bob!\n");free(output); } static void host_compiler_and_runtime(void) { + guest("#include \n#include \"bob.h\"\nint main(void){bool enabled=true;if(!enabled||false)return 1;enabled=false;if(enabled)return 2;bob_puts(\"bob!\");return 0;}"); + guest("#include \n#include \"bob.h\"\nint main(void){int values[3];size_t words=sizeof values;ptrdiff_t distance=&values[2]-&values[0];int *empty=NULL;if(words!=3||distance!=2||empty!=NULL||(sizeof(int)-2)!=(size_t)-1)return 1;bob_puts(\"bob!\");return 0;}"); + guest("#include \"bob.h\"\nint sum(int a,int b){return a+b;}int (*combine)(int,int)=sum;int twice(int n){return n*2;}int apply(int (*fn)(int),int n){return fn(n);}int main(void){int (*operation)(int,int)=∑int (*scale)(int)=twice;int (*oldstyle)()=twice;if(combine(4,5)!=9||operation(2,3)!=5||scale(6)!=12||(*scale)(8)!=16||apply(*scale,7)!=14||oldstyle(5)!=10)return 1;operation=combine;if(operation(7,8)!=15)return 2;bob_puts(\"bob!\");return 0;}"); + char *joined_literal=malloc(40000);if(!joined_literal)fail("allocate joined literal fixture"); + char *joined_cursor=joined_literal;joined_cursor+=sprintf(joined_cursor,"#include \"bob.h\"\nchar *text="); + for(int i=0;i<9000;i++){memcpy(joined_cursor,"\"b\"",3);joined_cursor+=3;} + strcpy(joined_cursor,";int main(void){if(text[8999]!='b' || text[9000]!=0)return 1;bob_puts(\"bob!\");return 0;}"); + guest(joined_literal);free(joined_literal); + char *large_literal=malloc(10000);if(!large_literal)fail("allocate large literal fixture"); + char *literal_cursor=large_literal;literal_cursor+=sprintf(literal_cursor,"#include \"bob.h\"\nchar *text=\""); + memset(literal_cursor,'b',9000);literal_cursor+=9000; + strcpy(literal_cursor,"\";int main(void){if(text[8999]!='b' || text[9000]!=0)return 1;bob_puts(\"bob!\");return 0;}"); + guest(large_literal);free(large_literal); + guest("#include \"bob.h\"\nint x;_Bool a=&x,b=\"bob!\",c=(_Bool)&x,d=(int*)0; " + "_Bool values[2]={&x,(void*)0};int main(void){static _Bool s=&x; " + "if(!a || !b || !c || d || !values[0] || values[1] || !s)return 1;bob_puts(\"bob!\");return 0;}"); + guest("#include \"bob.h\"\nint (*p)[3]=(int (*)[3])0xc000+2; " + "int (*q)[3]=2+(int (*)[3])0xc000;int (*r)[3]=(int (*)[3])0xc009-1; " + "int distance=(int (*)[3])0xc009-(int (*)[3])0xc000; " + "int main(void){int (*base)[3]=(int (*)[3])0xc000; " + "if(p!=base+2 || q!=p || r!=p || distance!=3)return 1;bob_puts(\"bob!\");return 0;}"); + guest("#include \"bob.h\"\nint a=7,b=9;int *p=1?&a:&b;int *q=0?&a:&b; " + "int *nil=0?&a:0;char *text=sizeof(a)==1?\"bob!\":\"bad\"; " + "int main(void){static int *s=1?(0?&b:&a):0; " + "if(*p!=7 || *q!=9 || nil!=0 || *s!=7)return 1;bob_puts(text);return 0;}"); + guest("#include \"bob.h\"\nchar (*word)[5]=&\"bob!\";char (*end)[5]=&\"bob!\"+1; " + "char *last=&\"bob!\"[3];int main(void){static char (*saved)[5]=&\"bob!\"; " + "if(sizeof(*word)!=5 || (*word)[4]!=0 || (*saved)[3]!='!' || *last!='!')return 1; " + "if((*(end-1))[0]!='b')return 2;bob_puts(*saved);return 0;}"); + guest("#include \"bob.h\"\nint main(void){char (*p)[5]=&\"bob!\";int a[2]; " + "if(sizeof(&a)!=1 || sizeof(*p)!=5 || (*p)[3]!='!')return 1;bob_puts(*p);return 0;}"); + guest("#include \"bob.h\"\nint main(void){int x=0;int a[3]; " + "if(sizeof(sizeof(x++))!=1 || sizeof(sizeof(a))!=1 || x!=0)return 1;bob_puts(\"bob!\");return 0;}"); + guest("#include \"bob.h\"\nint main(void){int a[2][3]={{1,2,3},{4,5,6}};unsigned int i=1; " + "if(i[a][2]!=6 || sizeof(i[a])!=3 || sizeof(2[a[0]])!=1)return 1;bob_puts(\"bob!\");return 0;}"); + guest("#include \"bob.h\"\nint count;int f(int *p,int x){count++;return x;} " + "int main(void){int x;void *p=&x;if(sizeof(f(p,count++))!=1 || count!=0)return 1; " + "if(sizeof(bob_run(count++))!=1 || count!=0)return 2;bob_puts(\"bob!\");return 0;}"); + guest("#include \"bob.h\"\nint main(void){char word[]=\"bob!\";void *p=word;bob_puts(p);return 0;}"); + guest("#include \"bob.h\"\nint value=7;void *shared=&value;int *items[]={&value,1-1}; " + "int main(void){void *v=&value;int *p=v;_Bool b=p;int *a[2]={p,0}; " + "static int *saved=&value;if(*p!=7 || !b || a[1]!=0 || *saved!=7)return 1; " + "if(shared!=p || items[0]!=p || items[1]!=0)return 2;bob_puts(\"bob!\");return 0;}"); + guest("#include \"bob.h\"\nint read(int *p){return *p;}int null(int *p){return p==0;} " + "int generic(void *p){return read(p);}_Bool truth(_Bool b){return b;} " + "int main(void){int x=7;void *v=&x;if(read(v)!=7 || generic(&x)!=7 || !null(1-1))return 1; " + "if(!truth(&x) || truth((int*)0))return 2;bob_puts(\"bob!\");return 0;}"); + guest("#include \"bob.h\"\nint value=7;void *generic(void){return &value;} " + "int *returned(void){return generic();}int *empty(void){return 1-1;} " + "_Bool truth(void){return &value;}_Bool zero(void){return (int*)0;} " + "int main(void){if(*returned()!=7 || empty()!=0 || truth()!=1 || zero()!=0)return 1;bob_puts(\"bob!\");return 0;}"); + guest("#include \"bob.h\"\nint main(void){int x=7;int *p;void *v;_Bool flag; " + "p=&x;v=p;p=v;flag=p;if(*p!=7 || flag!=1)return 1; " + "p=1-1;flag=p;if(p!=0 || flag!=0 || sizeof(p=0)!=1)return 2; " + "bob_puts(\"bob!\");return 0;}"); + guest("#include \"bob.h\"\nint main(void){int x=7;int *p=&x,*empty=0;void *v=p; " + "if(p!=v || v!=p || p==0 || 0==p || empty!=1-1)return 1; " + "if(sizeof(p==v)!=1 || p!=p || empty!=(void*)0)return 2;bob_puts(\"bob!\");return 0;}"); + guest("#include \"bob.h\"\nint main(void){int low=-32768,high=32767,one=1,minus=-1; " + "for(int i=0;i<64;i++){if(low/one!=low || high/one!=high || high/minus!=-32767)return 1;} " + "if(-43/7!=-6 || 43/-7!=-6 || -43/-7!=6 || 43/7!=6)return 2; " + "if(-43%7!=-1 || 43%-7!=1 || -43%-7!=-1 || low%one!=0)return 3; " + "bob_puts(\"bob!\");return 0;}"); + guest("#include \"bob.h\"\nint depth=5;int leaf(void){return 7;} " + "int recurse(void){if(depth==0)return leaf();depth--;return recurse()+1;} " + "int main(void){int saved=42;int result=recurse(); " + "if(result!=12 || saved!=42 || leaf()!=7)return 1;bob_puts(\"bob!\");return 0;}"); + guest("#include \"bob.h\"\nint main(void){int n=0;int *p=&n; " + "if(!!n!=0 || !!p!=1 || !!(-32768)!=1 || !!0xffff!=1)return 1; " + "if(!!n++!=0 || n!=1 || !!n++!=1 || n!=2)return 2;bob_puts(\"bob!\");return 0;}"); + guest("#include \"bob.h\"\nint main(void){int high=32767,low=-32768;unsigned all=65535U; " + "for(int i=0;i<64;i++){if(high*high!=1 || low*high!=-32768)return 1;} " + "if(low*2!=0 || low*(-1)!=low || all*all!=1U || (-7)*9!=-63)return 2; " + "if(high*0!=0 || 0*high!=0 || (-1)*(-1)!=1)return 3;bob_puts(\"bob!\");return 0;}"); + guest("#include \"bob.h\"\nint main(void){int rows[2][2];int (*p)[]=&rows[0];int (*q)[2]=&rows[1]; " + "if(sizeof(*(1?p:q))!=2 || sizeof(*(0?q:p))!=2)return 1; " + "int x=7;int *v=1?&x:1-1;int *w=0?0:&x;void *generic=0?(void*)0:v; " + "if(*v!=7 || *w!=7 || generic!=v || (1?0:v)!=0)return 2;bob_puts(\"bob!\");return 0;}"); + guest("#include \"bob.h\"\nenum E{ZERO,ONE};int main(void){enum E rows[2][2]; " + "enum E (*first)[2]=&rows[0];int (*last)[2]=(int (*)[2])&rows[1]; " + "if(last-first!=1 || first-last!=-1 || sizeof(last-first)!=1)return 1; " + "enum E *a=&rows[0][0];int *b=(int*)&rows[0][1]; " + "if(b-a!=1 || a-b!=-1)return 2;bob_puts(\"bob!\");return 0;}"); + guest("#include \"bob.h\"\ntypedef int Word;enum E{ITEM=3};int const global=7; " + "unsigned const int high=65535U;char const message[]=\"bob!\"; " + "int inspect(int const value){Word const local=value;enum E const e=ITEM; " + "const const int *const const p=&global;return local+e+*p;} " + "int main(void){if(inspect(2)!=12 || high/3U!=21845U || sizeof(int const)!=1)return 1; " + "if(sizeof(unsigned const int)!=1 || sizeof(Word const)!=1)return 2; " + "bob_puts(message);return 0;}"); + guest("#include \"bob.h\"\nenum Choice{FIRST=1,SECOND=2};int main(void){unsigned value=65535U;int score=0; " + "switch(value){case 65535U:score++;break;default:return 1;} " + "enum Choice choice=SECOND;switch(choice){case FIRST:return 2;case SECOND:score++;break;} " + "_Bool flag=7;switch(flag){case 0:return 3;case 1:score++;break;} " + "if(score!=3)return 4;bob_puts(\"bob!\");return 0;}"); + guest("#include \"bob.h\"\ntypedef const int ReadOnly;const int global=7; " + "int inspect(ReadOnly value){ReadOnly local=value;return local+global;} " + "int main(void){if(inspect(2)!=9)return 1;bob_puts(\"bob!\");return 0;}"); + guest("#include \"bob.h\"\nint value=7;int * const pointer=&value; " + "int main(void){*pointer=8;if(value!=8)return 1;bob_puts(\"bob!\");return 0;}"); + guest("#include \"bob.h\"\ntypedef const int *ReadPointer;int first=7,second=8; " + "int main(void){ReadPointer pointer=&first;pointer=&second;if(*pointer!=8)return 1; " + "bob_puts(\"bob!\");return 0;}"); + guest("#include \"bob.h\"\nint value=7;int main(void){int *writable=&value;const int *read_only=writable; " + "read_only=&value;if(*read_only!=7)return 1;bob_puts(\"bob!\");return 0;}"); + guest("#include \"bob.h\"\nint main(void){const int values[2]={4,5};const int matrix[2][2]={{1,2},{3,4}}; " + "if(values[1]!=5 || matrix[1][0]!=3)return 1;bob_puts(\"bob!\");return 0;}"); + guest("#include \"bob.h\"\nint inspect(int * const value);int inspect(int *value){return *value;} " + "int main(void){int value=7;if(inspect(&value)!=7)return 1;bob_puts(\"bob!\");return 0;}"); + guest("#include \"bob.h\"\nint calls;void visit(void){calls++;} " + "int main(void){(void)42;visit();1?visit():visit();0?(void)7:visit(); " + "if((visit(),calls)!=4)return 1;bob_puts(\"bob!\");return 0;}"); + guest("#include \"bob.h\"\nint main(void){int rows[2][2];int (*p)[]=&rows[0];int (*q)[2]=&rows[1]; " + "if(!(pp) || p>=q || q<=p || sizeof(p=0)return 1; " + "if(!(lowlow) || !(low<=high) || !(high>=low))return 2; " + "if(highhigh || !(low<=low) || !(high>=high))return 3; " + "bob_puts(\"bob!\");return 0;}"); + guest("#include \"bob.h\"\nchar bytes[]=\"\\a\\f\\v\\?\\xff\\377\"; " + "int main(void){if(sizeof(bytes)!=7 || bytes[0]!=7 || bytes[1]!=12 || bytes[2]!=11 || bytes[3]!='?')return 1; " + "if(bytes[4]!=255 || bytes[5]!=255 || '\\xff'!=255 || '\\377'!=255)return 2; " + "bob_puts(\"bob!\");return 0;}"); + guest("#include \"bob.h\"\ntypedef int unsigned Word;typedef signed Integer; " + "signed int echo(int signed value);int signed echo(signed value){return value;} " + "int unsigned divide(unsigned int a,int unsigned b){return a/b;} " + "int main(void){Integer negative=-3;Word high=65535U;int signed a[2]={-1,-2}; " + "if(echo(negative)!=-3 || divide(high,3U)!=21845U || a[1]!=-2)return 1; " + "if(sizeof(signed)!=1 || sizeof(int unsigned)!=1 || ((int unsigned)-1>>15)!=1U)return 2; " + "bob_puts(\"bob!\");return 0;}"); + guest("#include \"bob.h\"\nunsigned int constant=65535U/3U;unsigned folded=65535U>>15; " + "unsigned mixed=((-1)<1U);typedef unsigned Word; " + "Word divide(Word a,Word b){return a/b;} " + "int main(void){Word high=65535U,low=3U;int negative=-1; " + "if(highlow) || high<=low || !(high>=low) || !(low>1)!=16384U)return 5;shift>>=15;if(shift!=1U)return 6; " + "high++;if(high!=0U)return 7;high--;if(high!=65535U || sizeof(Word)!=1)return 8; " + "if((Word)-1!=65535U || ((Word)negative/3U)!=21845U)return 9;bob_puts(\"bob!\");return 0;}"); + guest("#include \"bob.h\"\ntypedef _Bool Flag;Flag truth=42,zero=0,table[2][2]={{-2,0},{7,0}}; " + "Flag argument(Flag a,Flag b){return a==1 && b==0;}Flag returned(void){return -9;} " + "int main(void){Flag local=-7;Flag a[3]={3,0,-1};static Flag stored=99; " + "if(truth!=1 || zero!=0 || table[1][0]!=1 || table[0][1]!=0 || local!=1 || stored!=1)return 1; " + "if(a[0]!=1 || a[1]!=0 || a[2]!=1 || argument(42,0)!=1 || returned()!=1)return 2; " + "if((_Bool)-8!=1 || (_Bool)0!=0 || (_Bool)&local!=1 || sizeof(Flag)!=1)return 3; " + "if((local=17)!=1 || (local*=3)!=1 || (local-=1)!=0)return 4; " + "if(local++!=0 || local!=1 || ++local!=1 || local--!=1 || local!=0)return 5; " + "if(--local!=1 || local!=1)return 6;bob_puts(\"bob!\");return 0;}"); + guest("#include \"bob.h\"\nenum Mode{FIRST=-2,SECOND,WIDTH=3,LAST=WIDTH+2}; " + "typedef enum Mode Mode;enum Mode selected=LAST;int values[WIDTH]={1,2,3}; " + "int identify(Mode m){return m;} " + "int main(void){Mode m=FIRST;if(m!=-2 || SECOND!=-1 || LAST!=5 || sizeof(Mode)!=1)return 1; " + "if(identify(selected)!=5 || sizeof(values)!=3)return 2; " + "{enum Mode{FIRST=7,WIDTH=2};enum Mode local=FIRST;int a[WIDTH];if(local!=7 || sizeof(a)!=2)return 3;} " + "if(FIRST!=-2 || WIDTH!=3)return 4; " + "for(enum {BOUND=2} i=0;i>=2)!=-4 || i!=2 || a[1]!=-4)return 2; " + "x<<=y<<=1;if(x!=16 || y!=4)return 3; " + "x>>=1+1;if(x!=4)return 4;x<<=0;if(x!=4)return 5; " + "bob_puts(\"bob!\");return 0;}"); guest("#include \"bob.h\"\nint matrix[2][3]={{1,2,3},{4,5,6}}; " "int (*rows)[3]=matrix;int (*whole)[2][3]=&matrix;int (*incomplete)[]=(int (*)[])matrix; " "int (*selected[2])[3]={&matrix[1],matrix}; " @@ -316,6 +708,7 @@ static void compile_workflow(void) { contains(output,"C source file not found."); contains(output,"Usage: cc SOURCE [OUTPUT] | go SOURCE [OUTPUT]"); contains(output,"broken.c: line 2, column"); + contains(output,"near token '@'."); contains(output,"Use edit to fix the source."); /* Four successful runs above; neither failed go may execute stale app. */ int exits=0;for(char *p=output;(p=strstr(p,"Exit 0"))!=NULL;p+=6)exits++; @@ -341,6 +734,229 @@ static void storage_path(const char *path) { check(setenv("BOB16_STORAGE",path,1)==0,"set snapshot fixture path"); #endif } +static void wide_kernel_workflow(void) { + storage_path("build/wide-snapshot.b32");remove("build/wide-snapshot.b32"); + write_text("build/check.in","mem\nalloc 4\npoke 0xd000 77\npeek 0xd000\npoke 0xc000 88\npeek 0xc000\ngo bob.c\nedit compat.c\nint main(void) {\nint n=0x12345678;\nif(n+1!=0x12345679 || n*2!=0x2468ACF0 || n/3!=101806632 || n%3)return 1;\nprintln(\"bob!\");\nreturn 0;\n}\n.\ngo compat.c\ndelete compat.c\nedit tern.c\nint main(void) {\nint a=0;\nint b=1?2:3;\nint c=0?4:1?5:6;\nint d=1?7:a++;\nif(b==2&&c==5&&d==7&&a==0)println(\"bob!\");\nreturn 0;\n}\n.\ngo tern.c\ndelete tern.c\nedit loops.c\nint main(void) {\nint i=0;\nint calls=0;\ndo { i++; if(i==2)continue; calls++; if(i==4)break; } while(i<10);\ndo { calls++; } while(0);\nif(calls==4)println(\"bob!\");\nreturn 0;\n}\n.\ngo loops.c\ndelete loops.c\nedit assign.c\nint main(void) {\nint a=0; int b=1; int i=0;\nint x=(a=b=3);\na+=2; b<<=2; b>>=1;\nif(x==3&&a==5&&b==6&&((i=i+1)==1))println(\"bob!\");\nreturn 0;\n}\n.\ngo assign.c\ndelete assign.c\nedit funcs.c\nint main(void) {\nannounce();\nif(add(fact(5),2)==122)println(\"bob!\");\nreturn 0;\n}\nint announce(void) {\nprintln(\"bob!\");\nreturn 0;\n}\nint fact(int n) {\nif(n<2)return 1;\nreturn n*fact(n-1);\n}\nint add(int x,int y) {\nint value=x+y;\nreturn value;\n}\n.\ngo funcs.c\ndelete funcs.c\nedit scope.c\nint main(void) {\nint value=3;\n{int value=8;if(value!=8)return 1;}\n{int value=9;if(value!=9)return 2;}\nint count=99;\nfor(int count=0;count<2;count++){int inner=count;if(inner!=count)return 3;}\nif(value==3&&count==99)println(\"bob!\");\nreturn 0;\n}\n.\ngo scope.c\ndelete scope.c\nwrite hex.c int main(void){print_hex(4660);println(\"bob!\");return 0;}\ngo hex.c\nload old 0xD002 0xF200 0xF000 0x0062 0x006F 0x0062 0x0021 0x0000\nrun old\nedit note\nbob!\n.\nread note\nls\ncc bob.c app\nrun app\nsave\nhalt\n"); + check(system(BOB32 " --boot build/kernel32.b32 --max-cycles 50000000 < build/check.in > build/check.out 2> build/check.err")==0,"bob32 OS shell workflow"); + char *output=read_text("build/check.out");int successful_apps=0;const char *success_cursor=output; + while((success_cursor=strstr(success_cursor,"bob!\nExit 0"))){successful_apps++;success_cursor+=11;} + check(successful_apps==9,"B32 resident programs all complete successfully"); + contains(output,"bob32 OS:");contains(output,"Compiled 45 words.\nbob!\nExit 0"); + contains(output,"bob!\nExit 0"); + contains(output,"0x00001234bob!\nExit 0"); + contains(output,"Loaded.\nbob> bob!\nExit 33"); + contains(output,"0x0000D000: 0x0000004D (77)");contains(output,"poke is limited to heap RAM."); + contains(output,"bob!\n\n");contains(output,"Files saved to bob-files.b32");free(output); + FILE *snapshot=fopen("build/wide-snapshot.b32","rb");if(!snapshot)fail("bob32 snapshot missing"); + char magic[4];check(fread(magic,1,4,snapshot)==4 && !memcmp(magic,"B32S",4),"bob32 OS writes native snapshot format");fclose(snapshot); + write_text("build/check.in","restore yes\nread note\nrun app\nhalt\n"); + check(system(BOB32 " --boot build/kernel32.b32 --max-cycles 50000000 < build/check.in > build/check.out 2> build/check.err")==0,"bob32 snapshot restore workflow"); + output=read_text("build/check.out");contains(output,"Files restored;");contains(output,"bob!\n");contains(output,"bob> bob!\nExit 0");free(output); + write_text("build/check.in","go bob.c\nhalt\n"); + check(system(BOB32 " --asm32 build/kernel32.basm < build/check.in > build/check.out 2> build/check.err")==0,"full bob32 kernel BASM assembly and execution"); + output=read_text("build/check.out");contains(output,"bob32 OS:");contains(output,"Compiled 45 words.\nbob!\nExit 0");free(output); + write_text("build/check.in","run32 build/wide-app.b32\nrun32 build/missing-app.b32\ngo bob.c\nhalt\n"); + check(system(BOB32 " --boot build/kernel32.b32 --max-cycles 50000000 < build/check.in > build/check.out 2> build/check.err")==0,"bob32 OS runs a native wide C application"); + output=read_text("build/check.out");contains(output,"bob> bob!\nExit 0");contains(output,"Cannot read B32 app image.");contains(output,"bob!\nExit 0");free(output); + write_text("build/check.in","import32 build/wide-large.b32 native\nls\nrun native\nrun32 native\nsave\nhalt\n"); + check(system(BOB32 " --boot build/kernel32.b32 --max-cycles 50000000 < build/check.in > build/check.out 2> build/check.err")==0,"import, run and snapshot a native app from bob32 RAM files"); + output=read_text("build/check.out");contains(output,"Imported native app as native");contains(output,"native ");contains(output,"words (native bob32 image)");check(strstr(output,"bob> bob!\nExit 0") && strstr(strstr(output,"bob> bob!\nExit 0")+1,"bob!\nExit 0"),"run and run32 accept native guest filenames");contains(output,"Files saved to bob-files.b32");free(output); + write_text("build/check.in","restore yes\nrun native\nhalt\n"); + check(system(BOB32 " --boot build/kernel32.b32 --max-cycles 50000000 < build/check.in > build/check.out 2> build/check.err")==0,"restore and run native app stored in B32S"); + output=read_text("build/check.out");contains(output,"Files restored;");contains(output,"bob> bob!\nExit 0");free(output); + write_text("build/check.in","import32 build/missing.b32 missing\nimport32 build/wide-bad.b32 corrupt\nimport32 build/wide-truncated.b32 short\nrun absent\nhalt\n"); + write_text("build/wide-bad.b32","not a B32 image"); + check(system(BOB32 " --boot build/kernel32.b32 --max-cycles 50000000 < build/check.in > build/check.out 2> build/check.err")==0,"native image import errors preserve the shell"); + output=read_text("build/check.out");contains(output,"Cannot read host app image path.");contains(output,"Invalid, truncated, corrupt, or unsupported B32K app image.");contains(output,"Program not found.");free(output); + storage_path("build/snapshot.b16"); +} +static void wide_local_offset_limit(void) { + char source[4096] = "int main(void){"; + char input[8192] = "edit offsets.c\n"; + char piece[80]; + for (int i = 0; i < 33; i++) { + snprintf(piece, sizeof(piece), "{int v%d=%d;}\n", i, i); + strcat(source, piece); + } + strcat(source, "return 0;}\n"); + strcat(input, source); + strcat(input, ".\ncc offsets.c rejected\nhalt\n"); + write_text("build/check.in", input); + check(system(BOB32 " --boot build/kernel32.b32 --max-cycles 50000000 < build/check.in > build/check.out 2> build/check.err")==0,"B32 local offset limit shell workflow"); + char *output = read_text("build/check.out"); + contains(output, "C compile error"); + check(strstr(output, "Compiled ") == NULL, "B32 local frame offset overflow rejected"); + free(output); +} +static void wide_local_arrays(void) { + write_text("build/check.in", + "edit array.c\n" + "int main(void) {\n" + "int values[4]={1,2,},sum=0;\n" + "if(values[0]!=1||values[2]!=0)return 2;\n" + "for(int i=0;i<4;i++)values[i]=i+1;\n" + "values[0]++;\n" + "values[1]+=2;\n" + "values[2]<<=1;\n" + "for(int i=0;i<4;i++)sum+=values[i];\n" + "if(sum==16)println(\"bob!\");\n" + "return 0;\n" + "}\n" + ".\ncc array.c array\nrun array\n" + "edit inc.c\n" + "int main(void) {\n" + "int a[2]={4,7},old=a[0]++;\n" + "if(old!=4||a[0]!=5)return 1;\n" + "if(++a[1]!=8)return 2;\n" + "int down=a[1]--;\n" + "if(down!=8||a[1]!=7)return 3;\n" + "if(--a[1]!=6)return 4;\n" + "println(\"bob!\");\n" + "return 0;\n" + "}\n" + ".\ncc inc.c inc\nrun inc\n" + "edit excess.c\n" + "int main(void){int a[2]={1,2,3};return 0;}\n" + ".\ncc excess.c rejected\nhalt\n"); + check(system(BOB32 " --boot build/kernel32.b32 --max-cycles 50000000 < build/check.in > build/check.out 2> build/check.err")==0,"B32 local array shell workflow"); + char *output=read_text("build/check.out"); + contains(output,"Compiled ");contains(output,"bob!\nExit 0"); + char *first_success=strstr(output,"bob!\nExit 0"); + check(first_success && strstr(first_success+1,"bob!\nExit 0"),"B32 array prefix and postfix increment expressions execute"); + contains(output,"C compile error");free(output); +} +static void wide_array_parameters(void) { + write_text("build/check.in", + "edit arrays.c\n" + "int sum(int values[],int length);\n" + "int bump(int values[],int length);\n" + "int main(void){int values[3]={1,2,3};\n" + "int first=sum(values,3);\n" + "int next=bump(values,3);\n" + "if(first==6&&next==9&&sum(values,3)==9)println(\"bob!\");\n" + "return 0;}\n" + "int sum(int values[],int length){\n" + "int total=0;for(int i=0;i build/check.out 2> build/check.err")==0,"B32 array parameter shell workflow"); + char *output=read_text("build/check.out"); + contains(output,"bob> bob!\nExit 0"); + char *error=strstr(output,"C compile error"); + check(error && strstr(error+1,"C compile error") && strstr(strstr(error+1,"C compile error")+1,"C compile error") && + strstr(strstr(strstr(error+1,"C compile error")+1,"C compile error")+1,"C compile error"), + "B32 rejects array argument and declaration mismatches"); + free(output); +} +static void wide_resident_large_output(void) { + char input[8192] = "edit large.c\nint main(void){int a[1]={0};"; + for (int i = 0; i < 60; i++) { + strcat(input, "a[0]++;"); + if ((i == 6) || (i > 6 && (i - 6) % 9 == 8 && i < 59)) strcat(input, "\n"); + } + strcat(input, "\n"); + strcat(input, "if(a[0]==60)println(\"bob!\");return 0;}\n.\ncc large.c large\nrun large\nsave\nhalt\n"); + storage_path("build/wide-resident-large.b32");remove("build/wide-resident-large.b32"); + write_text("build/check.in", input); + check(system(BOB32 " --boot build/kernel32.b32 --max-cycles 50000000 < build/check.in > build/check.out 2> build/check.err")==0,"B32 resident compiler creates and snapshots large app"); + char *output=read_text("build/check.out"); + char *compiled=strstr(output,"Compiled "); + check(compiled && atoi(compiled+9)>511,"B32 resident compiler output exceeds 511 words"); + contains(output,"bob> bob!\nExit 0");contains(output,"Files saved to bob-files.b32");free(output); + write_text("build/check.in","restore yes\nrun large\nhalt\n"); + check(system(BOB32 " --boot build/kernel32.b32 --max-cycles 50000000 < build/check.in > build/check.out 2> build/check.err")==0,"B32 large resident app restores and runs from snapshot"); + output=read_text("build/check.out");contains(output,"Files restored;");contains(output,"bob> bob!\nExit 0");free(output); + storage_path("build/snapshot.b16"); +} +static void wide_function_prototypes(void) { + write_text("build/check.in", + "write bobs.c int main(void){println(\"Bob!\");return 0;}\n" + "go bobs.c\n" + "edit proto.c\n" + "int add(int a,int b);\n" + "int loose();\n" + "int unused(int);\n" + "int main(void){if(add(2,3)==5&&loose(4,5)==9)println(\"bob!\");return 0;}\n" + "int add(int a,int b){return a+b;}\n" + "int loose(int a,int b){return a+b;}\n" + ".\ncc proto.c proto\nrun proto\n" + "edit mismatch.c\n" + "int f(int a);\n" + "int f(int a,int b);\n" + "int main(void){return 0;}\n" + ".\ncc mismatch.c rejected\n" + "edit oldstyle_mismatch.c\n" + "int sum();\n" + "int main(void){return sum(1);}\n" + "int sum(int a,int b){return a+b;}\n" + ".\ncc oldstyle_mismatch.c rejected\nhalt\n"); + check(system(BOB32 " --boot build/kernel32.b32 --max-cycles 50000000 < build/check.in > build/check.out 2> build/check.err")==0,"B32 function prototype shell workflow"); + char *output=read_text("build/check.out"); + contains(output,"Compiled ");contains(output,"Bob!\nExit 0");contains(output,"bob!\nExit 0"); + char *errors=strstr(output,"C compile error"); + check(errors && strstr(errors+1,"C compile error"),"B32 no-prototype declaration checks eventual definition arity"); + free(output); +} +static void wide_function_pointers(void) { + write_text("build/check.in", + "edit pointer.c\n" + "int sum(int a,int b);\n" + "int main(void) {\n" + "int (*operation)(int,int)=sum;\n" + "int (*other)(int,int)=0;\n" + "other=operation;\n" + "operation=other;\n" + "if(operation(4,5)==9)println(\"bob!\");\n" + "return 0;\n" + "}\n" + "int sum(int a,int b){return a+b;}\n" + ".\ncc pointer.c pointer\nrun pointer\n" + "edit mismatch.c\n" + "int one(int a);\n" + "int two(int a,int b);\n" + "int main(void){int (*operation)(int)=two;return 0;}\n" + ".\ncc mismatch.c rejected\n" + "edit integer.c\n" + "int main(void){int value=7;int (*operation)(int)=value;return 0;}\n" + ".\ncc integer.c rejected\n" + "edit mismatch_assign.c\n" + "int one(int a);int two(int a,int b);\n" + "int main(void){int (*operation)(int)=one;operation=two;return 0;}\n" + ".\ncc mismatch_assign.c rejected\n" + "edit integer_assign.c\n" + "int main(void){int value=7;int (*operation)(int)=0;operation=value;return 0;}\n" + ".\ncc integer_assign.c rejected\nhalt\n"); + check(system(BOB32 " --boot build/kernel32.b32 --max-cycles 50000000 < build/check.in > build/check.out 2> build/check.err")==0,"B32 function pointer shell workflow"); + char *output=read_text("build/check.out"); + contains(output,"Compiled ");contains(output,"bob!\nExit 0"); + char *errors=strstr(output,"C compile error"); + int error_count=0; + while(errors){error_count++;errors=strstr(errors+1,"C compile error");} + check(error_count==4,"B32 function pointer rejects incompatible and non-function initializers and assignments"); + free(output); +} static void snapshot_mutate(int offset, int rehash) { FILE *file=fopen("build/snapshot.b16","rb");if(!file)fail("snapshot missing"); unsigned char bytes[8640];size_t count=fread(bytes,1,sizeof(bytes),file);fclose(file); @@ -405,7 +1021,271 @@ static void shell_editing(void) { contains(output,"Allocation failed. Use a positive size");contains(output,"Used 1/8 slots");free(output); } static void host_language_rejections(void) { + write_text("build/check.i","int main(void){return 0;}"); + write_text("build/check.basm","bob!\n");write_text("build/check.b16","bob!\n");write_text("build/check.map","bob!\n"); + const char *collisions[]={ + COMPILER " build/check.i build/check.b16 build/check.b16", + COMPILER " build/check.i build/check.map build/check.b16", + COMPILER " build/check.i build/check.basm build/check.map", + COMPILER " build/check.i build/check.i build/check.b16", + COMPILER " build/check.i build/check.basm build/check.i" +#ifdef _WIN32 + ,COMPILER " build/check.i build/./check.b16 build/check.b16" + ,COMPILER " build/check.i build/CHECK.B16 build/check.b16" +#endif + }; + for(unsigned i=0;i build/compiler.log 2>&1")!=0,"malformed literal rejected"); + char *log=read_text("build/compiler.log");contains(log,diagnostics[i]);free(log); + } + FILE *input=fopen("build/check.i","wb");if(!input)fail("cannot create zero-byte source"); + fputs("int main(void){return 0;}",input);fputc(0,input);fputs("invalid trailing source",input);fclose(input); + check(system(COMPILER " build/check.i build/check.basm build/check.b16 > build/compiler.log 2>&1")!=0,"source zero byte rejects silent truncation"); + char *log=read_text("build/compiler.log");contains(log,"zero byte in source");free(log); + char *prior=read_text("build/check.basm");check(!strcmp(prior,"bob!\n"),"input failures preserve assembly");free(prior); + prior=read_text("build/check.b16");check(!strcmp(prior,"bob!\n"),"input failures preserve binary");free(prior); + char *relocation_limit=malloc(20000);if(!relocation_limit)fail("allocate relocation limit fixture"); + char *cursor=relocation_limit;cursor+=sprintf(cursor,"int x;"); + for(int i=0;i<15;i++)cursor+=sprintf(cursor,"int a%d[4096];",i); + cursor+=sprintf(cursor,"int *p[4096]={"); + for(int i=0;i<4096;i++){memcpy(cursor,"&x,",3);cursor+=3;} + strcpy(cursor,"};int main(void){return 0;}"); + char *deep_expression=malloc(1024);if(!deep_expression)fail("allocate expression nesting fixture"); + cursor=deep_expression;cursor+=sprintf(cursor,"int a["); + for(int i=0;i<400;i++)*cursor++='('; + *cursor++='1'; + for(int i=0;i<400;i++)*cursor++=')'; + strcpy(cursor,"];int main(void){return 0;}"); const char *sources[]={ + relocation_limit, + deep_expression, + "int a[(int*)3];int main(void){return 0;}", + "int main(void){const int value=1;value=2;return 0;}", + "int main(void){const int value=1;value++;return 0;}", + "typedef const int ReadOnly;int main(void){ReadOnly value=1;value=2;return 0;}", + "int main(void){const int value=1;return sizeof(value=2);}", + "int update(const int value){value=2;return value;}int main(void){return 0;}", + "const int value=1;int main(void){value=2;return 0;}", + "int main(void){int value=1,other=2;int * const pointer=&value;pointer=&other;return 0;}", + "int main(void){int value=1;int * const pointer=&value;pointer++;return 0;}", + "int update(int * const pointer){int value=1;pointer=&value;return 0;}int main(void){return 0;}", + "typedef int * const Pointer;int main(void){int value=1,other=2;Pointer pointer=&value;pointer=&other;return 0;}", + "typedef int * Pointer;int main(void){int value=1,other=2;const Pointer pointer=&value;pointer=&other;return 0;}", + "int main(void){int value=1;const int *pointer=&value;*pointer=2;return 0;}", + "int main(void){int value=1;const int *pointer=&value;pointer[0]++;return 0;}", + "int main(void){int value=1;const int *pointer=&value;int *writable=pointer;return 0;}", + "int main(void){int value=1;const int **pointer=0;int **writable=pointer;return value;}", + "int inspect(int *value);int inspect(const int *value);int main(void){return 0;}", + "int *inspect(void);const int *inspect(void);int main(void){return 0;}", + "int main(void){const int values[2]={1,2};values[1]=3;return 0;}", + "int main(void){const int values[2]={1,2};values[1]++;return 0;}", + "int main(void){const int values[2]={1,2};int *writable=values;return 0;}", + "int main(void){const int values[2]={1,2};return sizeof(values[1]=3);}", + "const int value=1;int *writable=&value;int main(void){return 0;}", + "int main(void){const int value=1;int *writable=&value;return 0;}", + "int main(void){int * const pointer=0;int **writable=&pointer;return 0;}", + "int main(void){int value=1;const int *readonly=&value;int *writable=1?readonly:&value;return 0;}", + "enum E{value=(int*)3};int main(void){return 0;}", + "enum E{value=32768U};int main(void){return 0;}", + "int a[3]={[ (int*)1 ]=7};int main(void){return 0;}", + "int value(void);int a[value()];int main(void){return 0;}", + "int a[sizeof((int)(void)0)];int main(void){return 0;}", + "enum E{value=sizeof((int)(void)0)};int main(void){return 0;}", + "int main(void){int value=0;int a[2]={[value++]=1};return 0;}", + "int value(void);int main(void){switch(1){case value():return 0;}}", + "int main(void){int value=0;switch(1){case value++:return 0;}}", + "int main(void){void *p=(void*)0xc000;++*p;return 0;}", + "int main(void){void *p=(void*)0xc000;(*p)++;return 0;}", + "int main(void){int a[2];++a;return 0;}", + "int x=1,a;int *p=x?&a:0;int main(void){return 0;}", + "int a;char b;int *p=1?&a:&b;int main(void){return 0;}", + "int main(void){return sizeof(&1);}", + "int main(void){int x;return sizeof(&(x+1));}", + "int main(void){int x;return sizeof(&x++);}", + "int main(void){int x;return sizeof(&(int)x);}", + "int main(void){return sizeof(sizeof((void)0));}", + "int f(int x){return x;}int main(void){return sizeof(sizeof(f()));}", + "int main(void){void *p=0;return sizeof(sizeof(&p[0]));}", + "int main(void){int *p;return sizeof(sizeof(p=7));}", + "void f(void){}int main(void){int a[2];return sizeof(a[f()]);}", + "void f(void){}int main(void){int a[2];return sizeof(f()[a]);}", + "int main(void){void *p=0;return sizeof(&p[0]);}", + "int main(void){int (*p)[]=0;return sizeof(&p[0]);}", + "int f(int *p){return 0;}int main(void){return sizeof(f(7));}", + "int f(int x){return x;}int main(void){return sizeof(f());}", + "int f(void){return 0;}int main(void){return sizeof(f(1));}", + "int f(int *p){return 0;}int main(void){char x;return sizeof(f(&x));}", + "#include \"bob.h\"\nint main(void){int x;return sizeof(bob_run(&x));}", + "int main(void){bob_puts(7);return 0;}", + "int main(void){int x;bob_puts(&x);return 0;}", + "int main(void){char a[2];bob_gets(a,a);return 0;}", + "int main(void){char a[2];bob_snapshot(a,0);return 0;}", + "int main(void){int x;bob_putc(&x);return 0;}", + "int main(void){int x;return bob_run(&x);}", + "int main(void){int x;return bob_call(&x);}", + "int main(void){int *p=7;return 0;}", + "int main(void){int x;char *p=&x;return 0;}", + "int main(void){int x;int n=&x;return 0;}", + "int main(void){int *p[2]={0,7};return 0;}", + "int *p=7;int main(void){return 0;}", + "int x;char *p=&x;int main(void){return 0;}", + "int *p[2]={0,7};int main(void){return 0;}", + "int main(void){static int *p=7;return 0;}", + "void f(void){}int main(void){int x=f();return 0;}", + "int f(int *p){return 0;}int main(void){return f(7);}", + "int f(char *p){return 0;}int main(void){int x;return f(&x);}", + "int f(int n){return n;}int main(void){int x;return f(&x);}", + "int *f(void){return 7;}int main(void){return 0;}", + "int value;char *f(void){return &value;}int main(void){return 0;}", + "int value;int f(void){return &value;}int main(void){return 0;}", + "int main(void){int *p;p=7;return 0;}", + "int main(void){int *p;char *q;p=q;return 0;}", + "int main(void){int *p;int x;x=p;return 0;}", + "int main(void){int *p;return sizeof(p=7);}", + "int main(void){int *p;return p==7;}", + "int main(void){int *p;int zero=0;return p!=zero;}", + "int main(void){int *p;char *q;return p==q;}", + "int main(void){int *p;return sizeof(p==7);}", + "int x=1?1:(void)0;int main(void){return 0;}", + "int x=1||(void)0;int main(void){return 0;}", + "int x=0&&(void)0;int main(void){return 0;}", + "int x=(int)(void)0;int main(void){return 0;}", + "int main(void){int *p;char *q;1?p:q;return 0;}", + "int main(void){int *p;1?p:7;return 0;}", + "int main(void){int *p;int zero=0;1?p:zero;return 0;}", + "int main(void){int *p;char *q;return sizeof(1?p:q);}", + "enum A{X};enum B{Y};int main(void){enum A *a;enum B *b;return a-b;}", + "int main(void){int (*a)[2];int (*b)[3];return a-b;}", + "int main(void){int (*a)[2];int (*b)[];return a-b;}", + "int main(void){int *p;switch(p){}return 0;}", + "int main(void){int a[2];switch(a){}return 0;}", + "void f(void){}int main(void){switch(f()){}return 0;}", + "int main(void){switch(1){case (int*)0:break;}return 0;}", + "int main(void){switch(1){case (void)0:break;}return 0;}", + "void f(void){return 1;}int main(void){return 0;}", + "void f(void){}void g(void){return f();}int main(void){return 0;}", + "int f(void){return;}int main(void){return 0;}", + "void f(void){}int main(void){return f();}", + "void f(void){}int g(int x){return x;}int main(void){return g(f());}", + "void f(void){}void bob_putc(int);int main(void){bob_putc(f());return 0;}", + "void f(void){}int main(void){return f()+1;}", + "void f(void){}int main(void){return (int)f();}", + "void f(void){}int main(void){return sizeof((int)f());}", + "void f(void){}int main(void){return !f();}", + "void f(void){}int main(void){return f()&&1;}", + "void f(void){}int main(void){return 1||f();}", + "void f(void){}int main(void){int x;x=f();return 0;}", + "void f(void){}int main(void){int x;return sizeof(x=f());}", + "void f(void){}int main(void){return sizeof(f()+1);}", + "void f(void){}int main(void){1?f():1;return 0;}", + "void f(void){}int main(void){f()?1:2;return 0;}", + "void f(void){}int main(void){if(f())return 1;return 0;}", + "void f(void){}int main(void){while(f()){}return 0;}", + "void f(void){}int main(void){do{}while(f());return 0;}", + "void f(void){}int main(void){for(;f();){}return 0;}", + "int main(void){int *p;return p<1;}", + "int main(void){int *p;char *q;return p>=1;return 0;}", + "int main(void){int *p;return (int)(p<<1);}", + "int main(void){int *p;return sizeof(p>>1);}", + "int main(void){int *p;return (int)(p*2);}", + "int main(void){int *p;return sizeof(p|1);}", + "int main(void){int *p;return sizeof(~p);}", "void a[2];int main(void){return 0;}", "int a[2][];int main(void){return 0;}", "int main(void){return sizeof(int[]);}", @@ -443,6 +1323,7 @@ static void host_language_rejections(void) { "int f(int x,int x){return x;}int main(void){return f(1,2);}", "int main(void){switch(1){case 1:;case 1:return 0;}}", "int main(void){switch(1){default:;default:return 0;}}", + "case 1:return 0;", "int main(void){case 1:return 0;}", "int main(void){switch(1){default:continue;}return 0;}", "int a[1/0];int main(void){return 0;}", @@ -475,16 +1356,23 @@ static void host_language_rejections(void) { "int main(void){int a[4096][4096];return 0;}", "int main(void){int a[2],b[2];return sizeof(a+b);}", "int main(void){void *p;return sizeof(p+1);}", - "int main(void){int a[2];return sizeof(a[a]);}" + "int main(void){int a[2];return sizeof(a[a]);}", + "int one(int x){return x;}int two(int x,int y){return x+y;}int main(void){int (*p)(int)=two;return 0;}", + "int one(int x){return x;}int main(void){int (*p)(int)=one;return p(1,2);}", + "int main(void){int x=1;int (*p)(int)=&x;return 0;}", + "int main(void){int x;int (*p)(int)=(int (*)(int))&x;return 0;}" }; for(unsigned i=0;i build/compiler.log 2>&1")==0,"language rejection preprocessing"); check(system(COMPILER " build/check.i build/check.basm build/check.b16 > build/compiler.log 2>&1")!=0,"invalid C must fail compilation"); + if(i==0){char *diagnostic=read_text("build/compiler.log");contains(diagnostic,"code/relocation limit exceeded");free(diagnostic);} + if(i==1){char *diagnostic=read_text("build/compiler.log");contains(diagnostic,"expression nesting exceeds 256 levels");free(diagnostic);} char *prior=read_text("build/check.basm");check(!strcmp(prior,"bob!\n"),"failed compile preserves BASM output");free(prior); prior=read_text("build/check.b16");check(!strcmp(prior,"bob!\n"),"failed compile preserves binary output");free(prior); } + free(deep_expression);free(relocation_limit); } static void image_validation(void) { FILE *in=fopen("build/kernel.b16","rb");if(!in)fail("kernel image missing"); @@ -503,7 +1391,7 @@ static void basm_route(void) { } int main(void) { console_and_commands();input_bounds();allocator_and_files();resident_compiler(); - compiler_extensions();editor_and_aliases(); - program_loading_and_recovery();host_compiler_and_runtime();host_language_rejections();file_management();compile_workflow();usability();persistence();shell_editing();image_validation();basm_route(); + compiler_extensions();wide_guest();editor_and_aliases(); + program_loading_and_recovery();native_string_library();host_compiler_and_runtime();host_language_rejections();file_management();compile_workflow();usability();persistence();shell_editing();image_validation();basm_route();wide_kernel_workflow();wide_local_arrays();wide_array_parameters();wide_resident_large_output();wide_function_prototypes();wide_function_pointers();wide_local_offset_limit(); printf("bob!\n%d checks passed.\n",checks);return 0; } diff --git a/tools/arithmetic.c b/tools/arithmetic.c index 0a79bce..12bc6d8 100644 --- a/tools/arithmetic.c +++ b/tools/arithmetic.c @@ -5,13 +5,17 @@ int __cmp_ge(int a, int b) { return a >= b; } int __cmp_eq(int a, int b) { return a == b; } int __cmp_ne(int a, int b) { return a != b; } int __mul(int a, int b) { - int result; result = 0; - if (b > 0) b = -b; - else a = -a; - while (b < 0) { result = result + a; b++; } + int result; int bit; result = 0; bit = 1; + /* The guest uses wrapping 16-bit words. Each bit contributes its shifted + multiplicand; the mask wraps to zero after exactly sixteen steps. */ + while (bit) { + if (b & bit) result = result + a; + a = a + a; bit = bit + bit; + } return result; } int __divneg(int a, int b) { + if(b == -1)return -a; int q; q = 0; while (a <= b) { a = a - b; q++; } return q; @@ -19,7 +23,7 @@ int __divneg(int a, int b) { int __div(int a, int b) { int negative; int q; if (b == 0) return 0; - negative = (a < 0) != (b < 0); + negative = (a ^ b) < 0; if (a > 0) a = -a; if (b > 0) b = -b; q = __divneg(a, b); diff --git a/tools/arithmetic32.c b/tools/arithmetic32.c new file mode 100644 index 0000000..8bf8688 --- /dev/null +++ b/tools/arithmetic32.c @@ -0,0 +1,75 @@ +/* bob32 arithmetic helpers. All results use native 32-bit wraparound. */ +int __cmp_lt(int a, int b) { return a < b; } +int __cmp_gt(int a, int b) { return a > b; } +int __cmp_le(int a, int b) { return a <= b; } +int __cmp_ge(int a, int b) { return a >= b; } +int __cmp_eq(int a, int b) { return a == b; } +int __cmp_ne(int a, int b) { return a != b; } +int __mul(int a, int b) { + int result=0, bit=1, i=0; + while(i<32) { + if(b & bit) result=result+a; + a=a+a; bit=bit+bit; i++; + } + return result; +} +int __u_lt(int a, int b) { + if(a<0) { if(b>=0) return 0; } + else if(b<0) return 1; + return a31) return 0; + while(b>0) { a=a+a; b--; } + return a; +} +int __shr(int a, int b) { + int low; + if(b<0 || b>31) return 0; + while(b>0) { + low=a&1; + if(a<0) a=-1073741824+((a&2147483647)-low)/2; + else a=(a-low)/2; + b--; + } + return a; +} +int __u_shr(int a, int b) { + if(b<0 || b>31) return 0; + while(b>0) { a=__shr(a,1)&2147483647; b--; } + return a; +} diff --git a/tools/bobcc.c b/tools/bobcc.c index 309a522..d73e8a8 100644 --- a/tools/bobcc.c +++ b/tools/bobcc.c @@ -1,5 +1,5 @@ -/* BOB-16 C subset compiler. Host tool, written entirely in C. - Input is C preprocessed by GCC; output is native bob16 BASM and B16K. */ +/* BOB C subset compiler. Host tool, written entirely in C. + Input is C preprocessed by GCC; output can target bob16 or native bob32. */ #include #include #include @@ -9,40 +9,85 @@ enum { T_ID=256, T_NUM, T_STR, T_EQ, T_NE, T_LE, T_GE, T_AND, T_OR, T_INC, T_DEC, T_SHL, T_SHR, T_ADDEQ, T_SUBEQ, T_MULEQ, T_DIVEQ, - T_MODEQ, T_ANDEQ, T_OREQ, T_XOREQ }; + T_MODEQ, T_ANDEQ, T_OREQ, T_XOREQ, T_SHLEQ, T_SHREQ }; enum { N_NUM=1, N_STR, N_ID, N_BINARY, N_UNARY, N_ASSIGN, N_CALL, N_INDEX, N_BLOCK, N_DECL, N_IF, N_WHILE, N_FOR, N_RETURN, N_BREAK, N_CONTINUE, N_EMPTY, N_CAST, N_FUNCTION, N_DO, N_CONDITIONAL, N_SIZEOF, N_LABEL, N_GOTO, N_SWITCH, N_CASE, N_DECL_GROUP, N_PROTOTYPE }; typedef struct Node Node; -struct Node { int kind, op, value, type, count; char *name; Node *a,*b,*c,*d,*next; }; +struct Node { int kind, op, value, type, count, storage, readonly; char *name; Node *a,*b,*c,*d,*next; }; typedef struct { int type, number, line; char *text; } Token; static Token tokens[65536]; static int ntokens, at; +static int expression_depth; static int parsing_parameter; +static int parsing_file_object; +static int parsing_external; +static int unsigned_helpers; +static int parsing_switch_depth; +static int parsed_const_base; +static int parsed_const_object; +static int parsed_const_alias_object; +typedef struct {char *name;int type,alias,readonly,object_readonly;} ParserBinding; +static ParserBinding parser_bindings[4096]; +static int parser_binding_count,parsing_types; +static int parser_scope_base,parser_body_scope=-1; +typedef struct {char *name;int type;} EnumTag; +static EnumTag enum_tags[4096]; +static int enum_tag_count,enum_scope_base,enum_serial; +static void error(const char *fmt,...); +static int composite_type(int a,int b); +static int function_index(const char *name); /* Interned pointer descriptors retain pointee type and indirection depth. Primitive IDs remain int=0, void=3, char=4; array objects still use kind 2. */ -typedef struct { int kind,base,count; } PointerType; +typedef struct { int kind,base,count,qualifiers; } PointerType; +typedef struct { int count,unspecified,parameters[32]; } FunctionType; static PointerType pointer_types[4096]; static int npointer_types; -static int derived_type(int kind,int base,int count) { - for(int i=0;i32)error("function pointer has more than 32 parameters"); + for(int i=0;icount!=count || f->unspecified!=unspecified)continue; + int same=1;for(int j=0;jparameters[j]!=parameters[j])same=0; + if(same)return i; + } + if(nfunction_types==1024)error("too many function pointer signatures"); + int index=nfunction_types++; + function_types[index].count=count;function_types[index].unspecified=unspecified; + for(int i=0;i=16 && type<16+npointer_types;} static int is_pointer(int type) {return is_derived(type) && pointer_types[type-16].kind==1;} static int is_array(int type) {return is_derived(type) && pointer_types[type-16].kind==2;} +static int is_enum(int type) {return is_derived(type) && pointer_types[type-16].kind==3;} +static int is_function(int type) {return is_derived(type) && pointer_types[type-16].kind==4;} +static int is_function_pointer(int type) {return is_pointer(type) && is_function(pointer_types[type-16].base);} static int type_size(int type); static int expression_type(Node *n); +static void assignment_compatible(int target,Node *value); static int decay_type(int type); +static int global_address(Node *n,const char **name,int *offset); static void binary_typed(int op,int left,int right); static Node *top, **top_tail=⊤ -static uint16_t code[65536]; -static int ncode, legacy, serial, return_label; -enum { ORIGIN=0x300, MAX_SYMBOLS=4096 }; +static uint32_t code[65536]; +static int ncode, legacy, wide, serial, return_label; +static uint32_t origin=0x300; +static int wide_app; +enum { MAX_SYMBOLS=4096 }; typedef struct { char *name; int address; } Label; static Label labels[MAX_SYMBOLS]; static int nlabels; @@ -52,12 +97,15 @@ static int nfixups; typedef struct { int index, length, flags; char *target; } Jump; static Jump jumps[65536]; static int njumps; -typedef struct { char *name; int type,count,offset; Node *init; int base; } Variable; +typedef struct { char *name; int type,count,offset; Node *init; int base,readonly; } Variable; static Variable globals[MAX_SYMBOLS], locals[MAX_SYMBOLS]; static int nglobals, nlocals; +static int global_defined[MAX_SYMBOLS]; +static int global_visible[MAX_SYMBOLS]; +static int global_linkage[MAX_SYMBOLS]; static int scope_base, function_body; static const char *current_function; -typedef struct { char *name; Node *node; int nargs; } Function; +typedef struct { char *name; Node *node; int nargs, reachable; } Function; static Function functions[MAX_SYMBOLS]; static int nfunctions; typedef struct { char *name; char *value; int length; } String; @@ -66,6 +114,7 @@ static int nstrings; static int loop_step[64], loop_end[64], loop_depth; static int break_targets[64], break_depth; static int compiling_compare_helper; +static int current_return_type; static void error(const char *fmt, ...) { va_list args; fprintf(stderr,"bobcc: line %d: ", tokens[at].line); @@ -82,7 +131,11 @@ static Node *node(int kind,Node *a,Node *b) { Node *n=allocate(sizeof(*n)); n->k static int escaped(const char **p) { int ch=(unsigned char)*(*p)++; if(ch!='\\') return ch; + if(!**p)error("unterminated escape"); ch=(unsigned char)*(*p)++; + if(ch=='a') return '\a'; + if(ch=='f') return '\f'; + if(ch=='v') return '\v'; if(ch=='n') return '\n'; if(ch=='r') return '\r'; if(ch=='t') return '\t'; @@ -91,11 +144,21 @@ static int escaped(const char **p) { int value=ch-'0'; for(int i=0;i<2&&**p>='0'&&**p<='7';i++) value=value*8+(*(*p)++-'0'); return value; } if(ch=='x') { int value=0, digits=0; while(isxdigit((unsigned char)**p)) { - int c=tolower((unsigned char)*(*p)++);value=value*16+(isdigit(c)?c-'0':c-'a'+10);digits++; + int c=tolower((unsigned char)*(*p)++),digit=isdigit(c)?c-'0':c-'a'+10; + if(value>(255-digit)/16)error("escape outside byte range"); + value=value*16+digit;digits++; } if(!digits) error("invalid escape");return value; } - if(ch=='\\'||ch=='\''||ch=='"') return ch; + if(ch=='\\'||ch=='\''||ch=='"'||ch=='?') return ch; error("unsupported escape"); return 0; } +static int valid_integer_suffix(const char *suffix,size_t length) { + static const char *valid[]={"u","l","ul","lu","ll","ull","llu"}; + for(size_t i=0;itext=allocate((size_t)(p-start)+1);memcpy(t->text,start,(size_t)(p-start));t->type=T_ID; } else if(isdigit((unsigned char)*p)) { - char *end; unsigned long value=strtoul(p,&end,0); - if(end==p||value>65535)error("integer outside 16-bit range"); - p=end;t->type=T_NUM;t->number=(int)value; + char *end; unsigned long long value=strtoull(p,&end,0); + if(end==p||value>(wide?UINT32_MAX:65535u))error("integer outside target range"); + p=end;t->type=T_NUM;t->number=(int32_t)value; + const char *suffix=p;int unsigned_suffix=0,long_suffix=0;size_t suffix_length=0; + while(*p=='u'||*p=='U'||*p=='l'||*p=='L') { + if(*p=='u'||*p=='U')unsigned_suffix++; + else long_suffix++; + suffix_length++;p++; + } + if(!valid_integer_suffix(suffix,suffix_length))error("invalid integer suffix"); + if(!wide && long_suffix)error("long integer suffix requires --wide"); + if(unsigned_suffix || (wide && value>INT32_MAX)){t->text=copy("u");unsigned_helpers=1;} if(isalpha((unsigned char)*p)) error("integer suffixes unsupported"); + if(isdigit((unsigned char)*p) || *p=='_')error("malformed integer literal"); } else if(*p=='"'||*p=='\'') { - int quote=*p++, count=0; char buffer[8192]; - while(*p&&*p!=quote) { if(count>=8190)error("string too long");int ch=escaped(&p); - if(ch<0||ch>127)error("only ASCII strings supported"); + int quote=*p++, count=0;size_t capacity=64;char *buffer=allocate(capacity); + while(*p&&*p!=quote) { if(*p=='\n' || *p=='\r')error("newline in literal");int ch=escaped(&p); + if(ch<0||ch>255)error("escape outside byte range"); + if((size_t)count+1>=capacity) { + capacity*=2;char *grown=realloc(buffer,capacity); + if(!grown)error("out of memory"); + buffer=grown; + } buffer[count++]=(char)ch; } if(*p!=quote)error("unterminated string"); p++;buffer[count]=0; - if(quote=='\'') { if(count!=1)error("character literal must contain one character");t->type=T_NUM;t->number=(unsigned char)buffer[0]; } - else { t->type=T_STR;t->number=count;t->text=allocate((size_t)count+1);memcpy(t->text,buffer,(size_t)count+1); } + if(quote=='\'') { if(count!=1)error("character literal must contain one character");t->type=T_NUM;t->number=(unsigned char)buffer[0];free(buffer); } + else { t->type=T_STR;t->number=count;t->text=buffer; } } else { - const char *pairs[]={"==","!=","<=",">=","&&","||","++","--","<<",">>","+=","-=","*=","/=","%=","&=","|=","^="}; - int kinds[]={T_EQ,T_NE,T_LE,T_GE,T_AND,T_OR,T_INC,T_DEC,T_SHL,T_SHR,T_ADDEQ,T_SUBEQ,T_MULEQ,T_DIVEQ,T_MODEQ,T_ANDEQ,T_OREQ,T_XOREQ}; - int matched=0;for(int i=0;i<18;i++)if(p[0]==pairs[i][0]&&p[1]==pairs[i][1]) { t->type=kinds[i];p+=2;matched=1;break; } + const char *pairs[]={"<<=",">>=","==","!=","<=",">=","&&","||","++","--","<<",">>","+=","-=","*=","/=","%=","&=","|=","^="}; + int kinds[]={T_SHLEQ,T_SHREQ,T_EQ,T_NE,T_LE,T_GE,T_AND,T_OR,T_INC,T_DEC,T_SHL,T_SHR,T_ADDEQ,T_SUBEQ,T_MULEQ,T_DIVEQ,T_MODEQ,T_ANDEQ,T_OREQ,T_XOREQ}; + int matched=0;for(int i=0;i<20;i++) {size_t length=strlen(pairs[i]);if(!strncmp(p,pairs[i],length)) { t->type=kinds[i];p+=length;matched=1;break; }} if(!matched)t->type=(unsigned char)*p++; } } @@ -137,11 +215,49 @@ static int is(const char *s) { return tok()==T_ID&&!strcmp(tokens[at].text,s); } static int take(int t) { if(tok()!=t)return 0;at++;return 1; } static void expect(int t) { if(!take(t))error("expected token %d, got %d",t,tok()); } static char *identifier(void) { if(tok()!=T_ID)error("expected identifier");return tokens[at++].text; } -static int type_start(void) { return is("int")||is("char")||is("void")||is("const"); } +static int typedef_type(void) { + if(tok()!=T_ID)return -1; + for(int i=parser_binding_count-1;i>=0;i--)if(!strcmp(parser_bindings[i].name,tokens[at].text)) + return parser_bindings[i].alias==1?parser_bindings[i].type:-1; + return -1; +} +static int parse_enum_type(void); +static int type_start(void) { return is("int")||is("long")||is("char")||is("void")||is("_Bool")||is("signed")||is("unsigned")||is("const")||is("enum")||typedef_type()>=0; } static int parse_base_type(void) { - if(is("const"))at++; - if(!is("int")&&!is("char")&&!is("void"))error("only int, char, void and pointers supported"); - int result=is("void")?3:is("char")?4:0;at++; + int qualified=0;parsed_const_alias_object=0; + while(is("const")){at++;qualified=1;} + if(is("int") || is("long") || is("signed") || is("unsigned")) { + int seen_int=0,long_count=0,sign=0; + while(is("int") || is("long") || is("signed") || is("unsigned") || is("const")) { + if(is("const")){at++;qualified=1;continue;} + if(is("int")){if(seen_int)error("duplicate int specifier");seen_int=1;} + else if(is("long")){if(++long_count>2)error("too many long specifiers");} + else {if(sign)error("duplicate or conflicting sign specifier");sign=is("unsigned")?2:1;} + at++; + } + if(long_count && !wide)error("long integer types require --wide"); + if(is("char") || is("void") || is("_Bool"))error("unsupported integer specifier combination"); + parsed_const_base=qualified; + if(sign==2){unsigned_helpers=1;return 6;} + return 0; + } + if(is("enum")){int result=parse_enum_type();while(is("const")){at++;qualified=1;}parsed_const_base=qualified;return result;} + int alias=typedef_type();if(alias>=0){ + int explicit_qualified=qualified; + for(int i=parser_binding_count-1;i>=0;i--)if(!strcmp(parser_bindings[i].name,tokens[at].text)){ + if(parser_bindings[i].alias==1){ + qualified|=parser_bindings[i].readonly; + parsed_const_alias_object=parser_bindings[i].object_readonly; + } + break; + } + at++;while(is("const")){at++;qualified=1;explicit_qualified=1;} + if(explicit_qualified && (is_pointer(alias)||is_array(alias)))parsed_const_alias_object=1; + parsed_const_base=qualified;return alias; + } + if(!is("int")&&!is("char")&&!is("void")&&!is("_Bool"))error("unsupported base type"); + int result=is("void")?3:is("char")?4:is("_Bool")?5:0;at++;while(is("const")){at++;qualified=1;} + parsed_const_base=qualified; return result; } static int parse_declarator(int base,char **name,int abstract); @@ -159,15 +275,27 @@ static Node *primary(void) { if(take('(')) { if(type_start()) { int type=parse_type();if(type==3)error("sizeof void is invalid");expect(')'); - n=node(N_NUM,NULL,NULL);n->value=type_size(type); - } else {n=node(N_SIZEOF,expression(0),NULL);expect(')');} - } else n=node(N_SIZEOF,expression(13),NULL); + n=node(N_NUM,NULL,NULL);n->type=6;n->value=type_size(type); + } else {n=node(N_SIZEOF,expression(0),NULL);n->type=6;expect(')');} + } else {n=node(N_SIZEOF,expression(13),NULL);n->type=6;} } - else if(tok()==T_NUM) { n=node(N_NUM,NULL,NULL);n->value=tokens[at++].number; } + else if(tok()==T_NUM) { n=node(N_NUM,NULL,NULL);n->type=tokens[at].text?6:0;n->value=tokens[at++].number; } else if(tok()==T_STR) { n=node(N_STR,NULL,NULL);n->name=tokens[at].text;n->value=tokens[at++].number; - while(tok()==T_STR) { size_t a=(size_t)n->value,b=(size_t)tokens[at].number;char *s=allocate(a+b+1); - memcpy(s,n->name,a);memcpy(s+a,tokens[at++].text,b+1);n->name=s;n->value=(int)(a+b); } } - else if(tok()==T_ID) { n=node(N_ID,NULL,NULL);n->name=identifier(); } + if(tok()==T_STR) { + size_t length=(size_t)n->value;int end=at; + while(tokens[end].type==T_STR){length+=(size_t)tokens[end].number;end++;} + char *joined=allocate(length+1);size_t position=(size_t)n->value; + memcpy(joined,n->name,position); + while(atname=joined;n->value=(int)length; + } } + else if(tok()==T_ID) { + n=node(N_ID,NULL,NULL);n->name=identifier(); + for(int i=parser_binding_count-1;i>=0;i--)if(!strcmp(parser_bindings[i].name,n->name)) { + if(parser_bindings[i].alias==3){n->kind=N_NUM;n->value=parser_bindings[i].type;} + break; + } + } else if(take('(')) { if(type_start()) { int type=parse_type();if(is_array(type))error("cast to array type");expect(')');n=node(N_CAST,expression(13),NULL);n->type=type; } else { n=expression(0);expect(')'); } @@ -177,8 +305,14 @@ static Node *primary(void) { while(1) { if(take('[')) { n=node(N_INDEX,n,expression(0));expect(']'); } else if(take('(')) { - if(n->kind!=N_ID)error("function pointers unsupported"); - Node *call=node(N_CALL,NULL,NULL);call->name=n->name; + Node *call=node(N_CALL,NULL,NULL);int indirect=0; + if(n->kind==N_ID) { + for(int i=parser_binding_count-1;i>=0;i--)if(!strcmp(parser_bindings[i].name,n->name)) { + indirect=parser_bindings[i].alias==0 && is_function_pointer(parser_bindings[i].type);break; + } + } else indirect=is_function_pointer(decay_type(expression_type(n))); + if(indirect)call->d=n;else if(n->kind==N_ID)call->name=n->name; + else error("called expression is not a function pointer"); Node **tail=&call->a;if(tok()!=')')do { *tail=expression(1);tail=&(*tail)->next; }while(take(',')); expect(')');n=call; } else if(tok()==T_INC||tok()==T_DEC) { int op=tokens[at++].type;n=node(N_UNARY,n,NULL);n->op=op;n->value=1; } @@ -188,7 +322,7 @@ static Node *primary(void) { } static int precedence(int op) { switch(op) { - case '=':case T_ADDEQ:case T_SUBEQ:case T_MULEQ:case T_DIVEQ:case T_MODEQ:case T_ANDEQ:case T_OREQ:case T_XOREQ:return 1; + case '=':case T_ADDEQ:case T_SUBEQ:case T_MULEQ:case T_DIVEQ:case T_MODEQ:case T_ANDEQ:case T_OREQ:case T_XOREQ:case T_SHLEQ:case T_SHREQ:return 1; case ',':return 0; case T_OR:return 3;case T_AND:return 4;case '|':return 5;case '^':return 6;case '&':return 7; case T_EQ:case T_NE:return 8;case '<':case '>':case T_LE:case T_GE:return 9; @@ -197,6 +331,7 @@ static int precedence(int op) { } } static Node *expression(int minimum) { + if(++expression_depth>256)error("expression nesting exceeds 256 levels"); Node *left=primary();int op,level; while(1) { if(tok()=='?' && minimum<=2) { @@ -206,35 +341,61 @@ static Node *expression(int minimum) { level=precedence(op=tok());if(levelop=op;left=n; } - return left; + expression_depth--;return left; } static int constant(Node *n) { - if(n->kind==N_NUM)return (int16_t)n->value; - if(n->kind==N_CAST && n->type!=3)return constant(n->a); - if(n->kind==N_CONDITIONAL)return constant(n->a)?constant(n->b):constant(n->c); + if(n->kind==N_NUM)return wide?(int32_t)(uint32_t)n->value:(int16_t)n->value; + if(n->kind==N_SIZEOF)return type_size(expression_type(n->a)); + if(n->kind==N_CAST && n->type!=3){expression_type(n); + if(n->type==5 && is_pointer(decay_type(expression_type(n->a)))) { + const char *target=NULL;int offset=0; + if(global_address(n->a,&target,&offset))return 1; + } + int value=constant(n->a);return n->type==5?value!=0:value;} + if(n->kind==N_CONDITIONAL){expression_type(n);return constant(n->a)?constant(n->b):constant(n->c);} if(n->kind==N_UNARY) { + expression_type(n); int a=constant(n->a); - if(n->op=='-')return (int16_t)-a; + if(n->op=='-')return wide?(int32_t)(0u-(uint32_t)a):(int16_t)-a; if(n->op=='+')return a; if(n->op=='!')return !a; - if(n->op=='~')return (int16_t)~a; + if(n->op=='~')return wide?(int32_t)~(uint32_t)a:(int16_t)~a; } if(n->kind==N_BINARY) { + expression_type(n); int a=constant(n->a); if(n->op==T_AND && !a)return 0; if(n->op==T_OR && a)return 1; int b=constant(n->b); + int left=decay_type(expression_type(n->a)),right=decay_type(expression_type(n->b)); + if(n->op=='+' || n->op=='-') { + if(is_pointer(left) && is_pointer(right)) + return (int16_t)(a-b)/type_size(pointer_types[left-16].base); + if(is_pointer(left))return (int16_t)(n->op=='+'?a+b*type_size(pointer_types[left-16].base):a-b*type_size(pointer_types[left-16].base)); + if(is_pointer(right))return (int16_t)(b+a*type_size(pointer_types[right-16].base)); + } + int unsigned_result=expression_type(n->a)==6 || expression_type(n->b)==6; + if(unsigned_result && (n->op=='/' || n->op=='%' || n->op=='<' || n->op=='>' || n->op==T_LE || n->op==T_GE)) { + uint32_t x=wide?(uint32_t)a:(uint16_t)a,y=wide?(uint32_t)b:(uint16_t)b; + if((n->op=='/' || n->op=='%') && !y)error("division by zero in constant expression"); + if(n->op=='/')return wide?(int32_t)(x/y):(int16_t)(x/y); + if(n->op=='%')return wide?(int32_t)(x%y):(int16_t)(x%y); + if(n->op=='<')return xop=='>')return x>y; + return n->op==T_LE?x<=y:x>=y; + } switch(n->op) { - case '+':return (int16_t)(a+b);case '-':return (int16_t)(a-b); - case '*':return (int16_t)(a*b); - case '/':case '%':if(!b)error("division by zero in constant expression");return (int16_t)(n->op=='/'?a/b:a%b); + case '+':return wide?(int32_t)((uint32_t)a+(uint32_t)b):(int16_t)(a+b);case '-':return wide?(int32_t)((uint32_t)a-(uint32_t)b):(int16_t)(a-b); + case '*':return wide?(int32_t)((uint32_t)a*(uint32_t)b):(int16_t)(a*b); + case '/':case '%':if(!b)error("division by zero in constant expression");return wide?(n->op=='/'?a/b:a%b):(int16_t)(n->op=='/'?a/b:a%b); case '&':return a&b;case '|':return a|b;case '^':return a^b; case T_EQ:return a==b;case T_NE:return a!=b; case '<':return a':return a>b;case T_LE:return a<=b;case T_GE:return a>=b; case T_AND:return !!b;case T_OR:return !!b; case T_SHL:case T_SHR: - if(b<0 || b>=16)error("invalid constant shift count"); - if(n->op==T_SHL)return (int16_t)((uint32_t)(uint16_t)a<=(wide?32:16))error("invalid constant shift count"); + if(n->op==T_SHL)return wide?(int32_t)((uint32_t)a<a)==6)return wide?(int32_t)((uint32_t)a>>b):(int16_t)((uint16_t)a>>b); if(!b)return a; return (int16_t)(((uint16_t)a>>b)|(a<0?(0xffffu<<(16-b)):0)); default:break; @@ -242,35 +403,126 @@ static int constant(Node *n) { } error("initializer/array size must be constant");return 0; } -typedef struct {int kind,count;} DeclaratorPart; +static int constant_integer_syntax(Node *n) { + if(n->kind==N_NUM || n->kind==N_SIZEOF)return 1; + if(n->kind==N_CAST) { + if(is_pointer(n->type) || n->type==3)return 0; + int source=decay_type(expression_type(n->a)); + return source!=3 && !is_pointer(source) && constant_integer_syntax(n->a); + } + if(n->kind==N_UNARY) { + if(n->op!='+' && n->op!='-' && n->op!='!' && n->op!='~')return 0; + int operand=decay_type(expression_type(n->a)); + return operand!=3 && !is_pointer(operand) && constant_integer_syntax(n->a); + } + if(n->kind==N_BINARY) { + if(n->op==',')return 0; + int left=decay_type(expression_type(n->a)),right=decay_type(expression_type(n->b)); + return left!=3 && right!=3 && !is_pointer(left) && !is_pointer(right) && + constant_integer_syntax(n->a) && constant_integer_syntax(n->b); + } + if(n->kind==N_CONDITIONAL) { + int condition=decay_type(expression_type(n->a)); + int yes=decay_type(expression_type(n->b)),no=decay_type(expression_type(n->c)); + return condition!=3 && !is_pointer(condition) && yes!=3 && no!=3 && !is_pointer(yes) && !is_pointer(no) && + constant_integer_syntax(n->a) && constant_integer_syntax(n->b) && constant_integer_syntax(n->c); + } + return 0; +} +static int integer_constant(Node *n) { + int type=decay_type(expression_type(n)); + if(type==3 || is_pointer(type) || !constant_integer_syntax(n))error("integer constant expression required"); + return constant(n); +} +static int parse_enum_type(void) { + at++;char *tag=tok()==T_ID?identifier():NULL; + if(tok()!='{') { + if(tag)for(int i=enum_tag_count-1;i>=0;i--)if(!strcmp(enum_tags[i].name,tag))return enum_tags[i].type; + error("enum tag must already be defined"); + } + int type=derived_type(3,0,++enum_serial,0); + if(tag) { + for(int i=enum_scope_base;i32)error("declarator nesting exceeds 32 levels"); - int pointers=0; - while(take('*')) {pointers++;if(is("const"))at++;if(pointers>64)error("too many pointer levels");} + int pointers=0,pointer_const[64]={0},grouped=0; + while(take('*')) {int index=pointers++;while(is("const")){at++;pointer_const[index]=1;}if(pointers>64)error("too many pointer levels");} if(tok()==T_ID) {*name=identifier();} - else if(take('(')) {declarator_parts(parts,length,name,abstract,depth+1);expect(')');} + else if(take('(')) {grouped=1;declarator_parts(parts,length,name,abstract,depth+1);expect(')');} else if(!abstract)error("expected declarator name"); - while(take('[')) { - int empty=tok()==']',bound=empty?0:constant(expression(1));expect(']'); - if(!empty && (bound<1 || bound>4096))error("array length must be 1..4096"); - if(*length==64)error("declarator exceeds 64 derived types"); - parts[(*length)++]=(DeclaratorPart){2,bound}; + while(1) { + if(take('[')) { + int empty=tok()==']',bound=empty?0:integer_constant(expression(1));expect(']'); + if(!empty && (bound<1 || bound>4096))error("array length must be 1..4096"); + if(*length==64)error("declarator exceeds 64 derived types"); + parts[(*length)++]=(DeclaratorPart){2,bound,0}; + } else if(grouped && tok()=='(') { + int signature=parse_function_signature(); + if(*length==64)error("declarator exceeds 64 derived types"); + parts[(*length)++]=(DeclaratorPart){4,signature,0};grouped=0; + } else break; } while(pointers--) { if(*length==64)error("declarator exceeds 64 derived types"); - parts[(*length)++]=(DeclaratorPart){1,1}; + parts[(*length)++]=(DeclaratorPart){1,1,pointer_const[pointers]}; } } static int parse_declarator(int base,char **name,int abstract) { DeclaratorPart parts[64];int length=0,dimensions=0;*name=NULL; + int base_const=parsed_const_base && !is_pointer(base) && !is_array(base); declarator_parts(parts,&length,name,abstract,0); + parsed_const_object=length && parts[0].kind==1 && parts[0].readonly; while(length--) { - if(parts[length].kind==1)base=pointer_to(base); - else { + if(parts[length].kind==1) {base=base_const?pointer_to_const(base):pointer_to(base);base_const=0;} + else if(parts[length].kind==4) { + if(is_array(base) || is_function(base))error("function cannot return an array or function"); + base=function_type(base,parts[length].count); + } else { if(++dimensions>16)error("too many array dimensions"); if(base==3)error("array of void"); + if(is_function(base))error("array of functions"); if(is_array(base) && !pointer_types[base-16].count)error("incomplete array element type"); - base=array_of(base,parts[length].count); + base=base_const?array_of_const(base,parts[length].count):array_of(base,parts[length].count);base_const=0; } } if(!*name)*name=copy(""); @@ -295,7 +547,7 @@ static int initializer_list(int element,int count,int aggregate,Node ***tail) { int current=array_of(element,count?count:4096/stride);position=0; do { if(!is_array(current))error("too many array designators"); - expect('[');int index=constant(expression(1));expect(']'); + expect('[');int index=integer_constant(expression(1));expect(']'); if(index<0 || index>=pointer_types[current-16].count)error("array designator out of bounds"); current=pointer_types[current-16].base;position+=index*type_size(current); } while(tok()=='['); @@ -336,15 +588,27 @@ static int initializer_list(int element,int count,int aggregate,Node ***tail) { } static Node *declaration(int type,char *name) { Node *n=node(N_DECL,NULL,NULL);n->name=name;n->type=type;n->count=1;n->op=type; + n->readonly=parsed_const_object || parsed_const_alias_object || + (is_array(type)?pointer_types[type-16].qualifiers:(parsed_const_base && !is_pointer(type))); + n->storage=parsing_external; int inferred=0,braced=0; if(is_array(type)){n->type=2;n->count=pointer_types[type-16].count;n->op=pointer_types[type-16].base;inferred=!n->count;} if(type==3)error("void variable"); + int binding=-1; + if(*name) { + for(int i=parser_scope_base;ireadonly,0}; + } if(parsing_parameter) { if(tok()=='=')error("parameter cannot have an initializer"); if(n->type==2){n->type=pointer_to(n->op);n->count=1;} + if(binding>=0)parser_bindings[binding].type=n->type; return n; } if(take('=')) { + if(parsing_external==1 && !parsing_file_object)error("block extern cannot have initializer"); if(tok()=='{') { Node **tail=&n->a;braced=1;initializer_list(n->type==2?n->op:n->type,n->type==2?n->count:1,n->type==2,&tail); } else n->a=expression(1); } @@ -359,31 +623,62 @@ static Node *declaration(int type,char *name) { int elements=0;for(Node *value=n->a;value;value=value->next)elements++; int stride=type_size(n->op);n->count=(elements+stride-1)/stride; } - if(inferred && (!n->a || n->count<1 || n->count>4096))error("inferred array needs 1..4096 initialized elements"); - if(n->type==2 && type_size(array_of(n->op,n->count))>4096)error("array storage exceeds 4096 words"); + if(inferred && (!n->a || n->count<1 || n->count>4096) && !((parsing_file_object || parsing_external==1) && !n->a))error("inferred array needs 1..4096 initialized elements"); + if(n->type==2 && n->count && type_size(array_of(n->op,n->count))>4096)error("array storage exceeds 4096 words"); + if(binding>=0) { + int actual=n->type==2?(n->readonly?array_of_const(n->op,n->count):array_of(n->op,n->count)):n->type; + if(parsing_file_object)for(int i=binding-1;i>=0;i--)if(!strcmp(parser_bindings[i].name,name)) { + int merged=composite_type(parser_bindings[i].type,actual); + if(merged<0)error("conflicting object type for %s",name); + actual=merged;break; + } + parser_bindings[binding].type=actual; + } return n; } static Node *declaration_group(int base) { - Node *group=node(N_DECL_GROUP,NULL,NULL);Node **tail=&group->a; + Node *group=node(N_DECL_GROUP,NULL,NULL);Node **tail=&group->a;int qualified=parsed_const_base,alias_object=parsed_const_alias_object; do { char *name;int type=parse_declarator(base,&name,0); + parsed_const_base=qualified;parsed_const_alias_object=alias_object; *tail=declaration(type,name);tail=&(*tail)->next; } while(take(',')); return group; } static Node *statement(void) { - if(is("switch")) {at++;expect('(');Node *n=node(N_SWITCH,expression(0),NULL);expect(')');n->b=statement();return n;} + if(is("typedef")) { + at++;int base=parse_base_type(),qualified=parsed_const_base; + do { + char *name;int type=parse_declarator(base,&name,0); + for(int i=parser_scope_base;ib=statement();parsing_switch_depth--;return n;} if(is("case") || is("default")) { + if(!parsing_switch_depth)error("case/default outside switch"); Node *n=node(N_CASE,NULL,NULL);n->type=is("default");at++; - if(!n->type)n->count=constant(expression(1)); + if(!n->type){Node *value=expression(1);n->count=integer_constant(value);} expect(':');n->b=statement();return n; } if(tok()==T_ID && tokens[at+1].type==':') { Node *n=node(N_LABEL,NULL,NULL);n->name=identifier();expect(':');n->b=statement();return n; } if(is("goto")) {at++;Node *n=node(N_GOTO,NULL,NULL);n->name=identifier();expect(';');return n;} - if(take('{')) { Node *n=node(N_BLOCK,NULL,NULL);Node **tail=&n->a; - while(tok()&&tok()!='}') { *tail=statement();tail=&(*tail)->next; }expect('}');return n; } + if(take('{')) { int saved=parser_binding_count,base=parser_scope_base,tags=enum_tag_count,tagbase=enum_scope_base;Node *n=node(N_BLOCK,NULL,NULL);Node **tail=&n->a; + if(parser_body_scope<0)enum_scope_base=tags; + parser_scope_base=parser_body_scope>=0?parser_body_scope:saved;parser_body_scope=-1; + while(tok()&&tok()!='}') { *tail=statement();tail=&(*tail)->next; }expect('}');parser_binding_count=saved;parser_scope_base=base;enum_tag_count=tags;enum_scope_base=tagbase;return n; } if(is("if")) { at++;expect('(');Node *n=node(N_IF,expression(0),NULL);expect(')');n->b=statement();if(is("else")){at++;n->c=statement();}return n; } if(is("while")) { at++;expect('(');Node *n=node(N_WHILE,expression(0),NULL);expect(')');n->b=statement();return n; } if(is("do")) { @@ -392,6 +687,7 @@ static Node *statement(void) { at++;expect('(');n->a=expression(0);expect(')');expect(';');return n; } if(is("for")) { + int saved=parser_binding_count,base=parser_scope_base,tags=enum_tag_count,tagbase=enum_scope_base;parser_scope_base=saved;enum_scope_base=tags; at++;expect('(');Node *n=node(N_FOR,NULL,NULL); if(type_start()) { int base=parse_base_type();n->a=declaration_group(base); } else if(tok()!=';')n->a=expression(0); @@ -399,52 +695,79 @@ static Node *statement(void) { if(tok()!=';')n->b=expression(0); expect(';'); if(tok()!=')')n->c=expression(0); - expect(')');n->d=statement();return n; + expect(')');n->d=statement();parser_binding_count=saved;parser_scope_base=base;enum_tag_count=tags;enum_scope_base=tagbase;return n; } if(is("return")) { at++;Node *n=node(N_RETURN,NULL,NULL);if(tok()!=';')n->a=expression(0);expect(';');return n; } if(is("break")||is("continue")) { int kind=is("break")?N_BREAK:N_CONTINUE;at++;expect(';');return node(kind,NULL,NULL); } - if(type_start()) {int base=parse_base_type();Node *n=declaration_group(base);expect(';');return n;} + if(type_start()) {int base=parse_base_type();if(is_enum(base) && take(';'))return node(N_EMPTY,NULL,NULL);Node *n=declaration_group(base);expect(';');return n;} if(take(';'))return node(N_EMPTY,NULL,NULL); Node *n=expression(0);expect(';');return n; } static void parse(void) { + parsing_types=1; while(tok()) { - int base=parse_base_type();char *name;int type=parse_declarator(base,&name,0);Node *n; + if(is("typedef")){statement();continue;} + int storage=is("extern")?1:is("static")?2:0;if(storage)at++; + int external=storage==1; + int base=parse_base_type(),base_const=parsed_const_base,base_alias_object=parsed_const_alias_object;if(is_enum(base) && !storage && take(';'))continue; + char *name;int type=parse_declarator(base,&name,0);parsed_const_base=base_const;parsed_const_alias_object=base_alias_object;Node *n; if(take('(')) { + for(int i=parser_scope_base;iname=name;n->type=type;Node **tail=&n->a; + n=node(N_FUNCTION,NULL,NULL);n->name=name;n->type=type;n->storage=storage;Node **tail=&n->a; n->op=tok()==')'; if(is("void")&&tokens[at+1].type==')')at++; - else if(tok()!=')')do { char *p;int t=parse_declarator(parse_base_type(),&p,1); + else if(tok()!=')')do { char *p;int parameter_base=parse_base_type(),parameter_const=parsed_const_base,parameter_alias_object=parsed_const_alias_object; + int t=parse_declarator(parameter_base,&p,1);parsed_const_base=parameter_const;parsed_const_alias_object=parameter_alias_object; + if(t==3 && !*p && tail==&n->a && tok()==')')break; parsing_parameter=1;*tail=declaration(t,p);parsing_parameter=0;tail=&(*tail)->next; }while(take(',')); expect(')'); - if(take(';'))n->kind=N_PROTOTYPE; - else {n->b=statement();if(n->b->kind!=N_BLOCK)error("expected function body");} - } else { - n=declaration(type,name);*top_tail=n;top_tail=&n->next; - while(take(',')) { - type=parse_declarator(base,&name,0);n=declaration(type,name);*top_tail=n;top_tail=&n->next; + int parameters[32],parameter_count=0; + for(Node *parameter=n->a;parameter;parameter=parameter->next) { + if(parameter_count==32)error("function has more than 32 parameters"); + parameters[parameter_count++]=parameter->type; } - expect(';');continue; + n->count=function_signature(parameters,parameter_count,n->op); + parser_bindings[function_binding].type=function_type(n->type,n->count); + if(take(';'))n->kind=N_PROTOTYPE; + else {parser_body_scope=saved;n->b=statement();if(n->b->kind!=N_BLOCK)error("expected function body");} + parser_binding_count=saved;parser_scope_base=scope;enum_tag_count=tags;enum_scope_base=tagbase; + } else { + parsing_file_object=1; + n=declaration(type,name);n->value=external;n->storage=storage;*top_tail=n;top_tail=&n->next; + while(take(',')) { + type=parse_declarator(base,&name,0);parsed_const_base=base_const;parsed_const_alias_object=base_alias_object;n=declaration(type,name);n->value=external;n->storage=storage;*top_tail=n;top_tail=&n->next; + } + expect(';');parsing_file_object=0;continue; } *top_tail=n;top_tail=&n->next; } + parsing_types=0; +} +static void emit(int value) { if(ncode>=65536)error("code too large");code[ncode++]=(uint32_t)value; } +static void emit_relocation(const char *name,int offset) { + if(ncode>=65536 || nfixups>=65536)error("code/relocation limit exceeded"); + fixups[nfixups++]=(Fixup){ncode,copy(name),offset};emit(0); } -static void emit(int value) { if(ncode>=65536)error("code too large");code[ncode++]=(uint16_t)value; } static void define(const char *name) { for(int i=0;i=-64 && value<=63) { emit(0x2180|reg<<9); if(value)emit(0x1180|reg<<9|(value&127)); return; } emit(0x4001|reg<<9);emit(0xae01); - if(name) { fixups[nfixups++]=(Fixup){ncode,copy(name),0};emit(0); }else emit(value); + if(name)emit_relocation(name,0);else emit(value); } static void move(int dst,int src) { emit(0x1080|dst<<9|src<<4); } static void addi(int reg,int value) { @@ -453,8 +776,13 @@ static void addi(int reg,int value) { } static void push(int reg) { addi(6,-1);emit(0x9000|reg<<9|6<<6); } static void pop(int reg) { emit(0x6000|reg<<9|6<<6);addi(6,1); } +static Jump *add_jump(int index,int length,int flags,const char *target) { + if(njumps>=65536)error("too many jumps"); + jumps[njumps]=(Jump){index,length,flags,copy(target)}; + return &jumps[njumps++]; +} static void jump_name(const char *name) { - jumps[njumps++]=(Jump){ncode,4,7,copy(name)}; + add_jump(ncode,4,7,name); literal(3,0,name);emit(0xb600); } static void jump(int id) {jump_name(label_name(id));} @@ -468,7 +796,7 @@ static void branch(int flags,int id) { jumps[njumps-1].index=start;jumps[njumps-1].length=5;jumps[njumps-1].flags=flags; } static void call(const char *name) { - jumps[njumps++]=(Jump){ncode,4,8,copy(name)}; + add_jump(ncode,4,8,name); literal(3,0,name);emit(legacy?0xcb00:0xc300); } static int symbol_address(const char *name) { @@ -482,14 +810,14 @@ static void compact_jumps(void) { for(int i=0;ilength==1)continue; int start=j->index,old=j->length,removed=old-1; - int target=symbol_address(j->target)-ORIGIN; + int target=symbol_address(j->target)-origin; if(target>start)target-=removed; int offset=target-start-1; int range=j->flags==8?1024:256; if(offset < -range || offset >= range)continue; memmove(code+start+1,code+start+old,(size_t)(ncode-start-old)*sizeof(*code)); ncode-=removed; - for(int k=0;kORIGIN+start)labels[k].address-=removed; + for(int k=0;korigin+(uint32_t)start)labels[k].address-=removed; int out=0; for(int k=0;ktarget)-ORIGIN-j->index-1; + Jump *j=&jumps[i];int offset=symbol_address(j->target)-origin-j->index-1; int range=j->flags==8?1024:256; if(offset < -range || offset >= range)error("relative transfer out of range"); - if(j->flags==8)code[j->index]=(uint16_t)((legacy?0xc000:0xc800)|(offset&2047)); - else code[j->index]=(uint16_t)(0xa000|j->flags<<9|(offset&511)); + if(j->flags==8)code[j->index]=(uint32_t)((legacy?0xc000:0xc800)|(offset&2047)); + else code[j->index]=(uint32_t)(0xa000|j->flags<<9|(offset&511)); } } static void negate(int reg) { emit(0x3100|reg<<9);addi(reg,1); } -static int fresh(void) { return ++serial; } +static int fresh(void) { + if(serial>=65535)error("generated label limit exceeded"); + return ++serial; +} +static Variable *variable_lookup(const char *name,int *global) { + for(int i=nlocals-1;i>=0;i--)if(!strcmp(locals[i].name,name)){ + if(locals[i].offset>=65536){*global=1;return &globals[locals[i].offset-65536];} + *global=0;return &locals[i]; + } + for(int i=0;i=0;i--)if(!strcmp(locals[i].name,name)){*global=0;return &locals[i];} - for(int i=0;ikind==N_ID) { int global;Variable *v=variable(n->name,&global); - if(global)literal(0,0,named("g.",n->name));else { move(0,5);addi(0,v->offset); } } + if(global)literal(0,0,named("g.",v->name));else { move(0,5);addi(0,v->offset); } } + else if(n->kind==N_STR)expr(n); else if(n->kind==N_INDEX) { int a=decay_type(expression_type(n->a)),b=decay_type(expression_type(n->b)); if(!is_pointer(a) && !is_pointer(b))error("subscript requires pointer/array"); @@ -553,6 +893,7 @@ static const char *helper(int op) { static void binary(int op) { if(op=='+')emit(0x1010);else if(op=='-'){negate(0);emit(0x1010);} else if(op=='&')emit(0x2010); + else if(wide && (op=='|' || op=='^')) {push(0);push(1);call(named("fn.",op=='|'?"__or":"__xor"));addi(6,2);} else if(helper(op)) { push(0);push(1);call(named("fn.",helper(op)));addi(6,2); } else if(!compiling_compare_helper) { push(0);push(1); @@ -560,7 +901,20 @@ static void binary(int op) { call(named("fn.",name));addi(6,2); } else compare(op); } -static void args_reverse(Node *arg) { if(!arg)return;args_reverse(arg->next);expr(arg);push(0); } +static void convert_value(int type) {if(type==5){literal(1,0,NULL);compare(T_NE);}} +static void args_reverse(Node *arg,Node *parameter) { + if(!arg)return; + assignment_compatible(parameter->type,arg); + args_reverse(arg->next,parameter->next);expr(arg);convert_value(parameter->type);push(0); +} +static void args_reverse_signature(Node *arg,FunctionType *signature,int index) { + if(!arg)return; + if(!signature->unspecified && index>=signature->count)error("wrong argument count for function pointer"); + int type=signature->unspecified?0:signature->parameters[index]; + if(!signature->unspecified)assignment_compatible(type,arg); + args_reverse_signature(arg->next,signature,index+1); + expr(arg);if(!signature->unspecified)convert_value(type);push(0); +} static const char *string_label(Node *n) { for(int i=0;ivalue && !memcmp(strings[i].value,n->name,(size_t)n->value))return strings[i].name; if(nstrings==4096)error("too many strings"); @@ -568,10 +922,13 @@ static const char *string_label(Node *n) { } static int global_address(Node *n,const char **name,int *offset); static int global_object_address(Node *n,const char **name,int *offset) { - if(n->kind==N_ID) { + if(n->kind==N_STR) { + *name=string_label(n);*offset=0;return 1; + } else if(n->kind==N_ID) { for(int i=0;iname)) { *name=named("g.",n->name);*offset=0;return 1; } + if(function_index(n->name)>=0) {*name=named("fn.",n->name);*offset=0;return 1;} } else if(n->kind==N_INDEX) { Node *base=n->a,*index=n->b; int type=decay_type(expression_type(base)); @@ -585,6 +942,11 @@ static int global_object_address(Node *n,const char **name,int *offset) { } static int global_address(Node *n,const char **name,int *offset) { if(n->kind==N_STR){*name=string_label(n);*offset=0;return 1;} + if(n->kind==N_ID && function_index(n->name)>=0) {*name=named("fn.",n->name);*offset=0;return 1;} + if(n->kind==N_CONDITIONAL) { + expression_type(n); + return global_address(constant(n->a)?n->b:n->c,name,offset); + } if(n->kind==N_CAST && is_pointer(n->type))return global_address(n->a,name,offset); if(n->kind==N_BINARY && (n->op=='+' || n->op=='-')) { if(global_address(n->a,name,offset)){ @@ -602,60 +964,231 @@ static int global_address(Node *n,const char **name,int *offset) { return 0; } static int decay_type(int type) { - if(is_derived(type) && pointer_types[type-16].kind==2)return pointer_to(pointer_types[type-16].base); + if(is_derived(type) && pointer_types[type-16].kind==2) + return pointer_types[type-16].qualifiers?pointer_to_const(pointer_types[type-16].base):pointer_to(pointer_types[type-16].base); + if(is_function(type))return pointer_to(type); return type; } +static int compound_operator(int op) { + switch(op) { + case T_ADDEQ:return '+';case T_SUBEQ:return '-';case T_MULEQ:return '*'; + case T_DIVEQ:return '/';case T_MODEQ:return '%';case T_ANDEQ:return '&'; + case T_OREQ:return '|';case T_XOREQ:return '^';case T_SHLEQ:return T_SHL; + case T_SHREQ:return T_SHR;default:error("unknown compound assignment");return 0; + } +} +static int modifiable_type(Node *n) { + if(n->kind!=N_ID && n->kind!=N_INDEX && !(n->kind==N_UNARY && n->op=='*'))error("modifiable lvalue required"); + int type=expression_type(n); + if(type==3 || is_array(type))error("object is not assignable"); + if(n->kind==N_UNARY) { + int pointer=decay_type(expression_type(n->a)); + if(is_pointer(pointer) && pointer_types[pointer-16].qualifiers)error("modification through pointer to const object"); + } else if(n->kind==N_INDEX) { + int pointer=decay_type(expression_type(n->a)); + if(!is_pointer(pointer))pointer=decay_type(expression_type(n->b)); + if(is_pointer(pointer) && pointer_types[pointer-16].qualifiers)error("modification through pointer to const object"); + } + if(n->kind==N_ID) { + int readonly=0; + if(parsing_types) { + for(int i=parser_binding_count-1;i>=0;i--)if(!strcmp(parser_bindings[i].name,n->name)) { + readonly=parser_bindings[i].readonly;break; + } + } else {int global;readonly=variable(n->name,&global)->readonly;} + if(readonly)error("assignment to const object %s",n->name); + } + return type; +} +static void compound_constraints(int op,int left,int right) { + if(right==3)error("assignment from void expression"); + right=decay_type(right); + if(left==3 || right==3)error("void operand in compound assignment"); + if(is_pointer(left)) { + if((op!='+' && op!='-') || is_pointer(right))error("pointer compound assignment requires integer offset"); + type_size(pointer_types[left-16].base); + } else if(is_pointer(right))error("integer compound assignment has pointer operand"); +} +static int discards_pointer_qualifiers(int target,int source) { + if(!is_pointer(target) || !is_pointer(source))return 0; + PointerType to=pointer_types[target-16],from=pointer_types[source-16]; + if(from.qualifiers & ~to.qualifiers)return 1; + if(is_pointer(to.base) && is_pointer(from.base))return discards_pointer_qualifiers(to.base,from.base); + return 0; +} +static void assignment_compatible(int target,Node *value) { + int source=decay_type(expression_type(value)); + if(source==3)error("assignment from void expression"); + if(is_pointer(target)) { + if(is_pointer(source)) { + if(is_function_pointer(target)!=is_function_pointer(source)) + error("cannot convert between function and object pointers"); + if(discards_pointer_qualifiers(target,source)) + error("pointer assignment discards const qualifier"); + if(pointer_types[target-16].base!=3 && pointer_types[source-16].base!=3 && composite_type(target,source)<0) + error("assignment has incompatible pointer types in %s",current_function ? current_function : "initializer"); + } else if(!constant_integer_syntax(value) || constant(value)!=0)error("pointer assignment requires null integer constant"); + } else if(is_pointer(source) && target!=5)error("pointer assignment to integer requires a cast"); +} +static int object_readonly(Node *n) { + if(n->kind==N_ID) { + if(parsing_types) { + for(int i=parser_binding_count-1;i>=0;i--)if(!strcmp(parser_bindings[i].name,n->name))return parser_bindings[i].readonly; + return 0; + } + int global;Variable *v=variable_lookup(n->name,&global); + if(v)return v->readonly; + if(function_index(n->name)>=0)return 0; + error("unknown variable %s",n->name); + } + if(n->kind==N_UNARY && n->op=='*') { + int pointer=decay_type(expression_type(n->a)); + return is_pointer(pointer) && pointer_types[pointer-16].qualifiers; + } + if(n->kind==N_INDEX) { + int pointer=decay_type(expression_type(n->a)); + if(!is_pointer(pointer))pointer=decay_type(expression_type(n->b)); + return is_pointer(pointer) && pointer_types[pointer-16].qualifiers; + } + return 0; +} static int expression_type(Node *n) { switch(n->kind) { - case N_NUM:return 0; + case N_NUM:return n->type; case N_STR:return array_of(4,n->value+1); - case N_ID:{int global;Variable *v=variable(n->name,&global);return v->type==2?array_of(v->base,v->count):v->type;} - case N_CAST:return n->type; - case N_SIZEOF:return 0; - case N_CALL: - for(Node *d=top;d;d=d->next)if((d->kind==N_FUNCTION || d->kind==N_PROTOTYPE) && !strcmp(d->name,n->name))return d->type; + case N_ID:{ + if(parsing_types) { + for(int i=parser_binding_count-1;i>=0;i--)if(!strcmp(parser_bindings[i].name,n->name)) { + if(parser_bindings[i].alias==1)error("typedef name used as an object"); + if(parser_bindings[i].alias==2)return parser_bindings[i].type; + return parser_bindings[i].type; + } + error("undeclared object in constant sizeof: %s",n->name); + } + int global;Variable *v=variable_lookup(n->name,&global); + if(v)return v->type==2?(v->readonly?array_of_const(v->base,v->count):array_of(v->base,v->count)):v->type; + Function *f=function(n->name);return function_type(f->node->type,f->node->count); + } + case N_CAST:{ + int source=decay_type(expression_type(n->a)); + if(n->type!=3 && source==3)error("cannot cast void expression to a value"); + if(is_pointer(n->type) && is_pointer(source) && is_function_pointer(n->type)!=is_function_pointer(source)) + error("cannot cast between function and object pointers"); + return n->type; + } + case N_SIZEOF:type_size(expression_type(n->a));return 6; + case N_CALL: { + if(n->d) { + int pointer=decay_type(expression_type(n->d)); + if(!is_function_pointer(pointer))error("called expression is not a function pointer"); + int ftype=pointer_types[pointer-16].base; + FunctionType *signature=&function_types[pointer_types[ftype-16].count]; + Node *argument=n->a;int index=0; + if(!signature->unspecified) { + while(argument && indexcount) { + assignment_compatible(signature->parameters[index++],argument);argument=argument->next; + } + if(argument || index!=signature->count)error("wrong argument count for function pointer"); + } + return pointer_types[ftype-16].base; + } + Node *declaration=NULL; + for(Node *d=top;d;d=d->next)if((d->kind==N_FUNCTION || d->kind==N_PROTOTYPE) && !strcmp(d->name,n->name)) { + if(!declaration || d->kind==N_FUNCTION || (declaration->kind!=N_FUNCTION && d->a))declaration=d; + } + if(declaration) { + Node *d=declaration; + /* Check constraints even when sizeof suppresses evaluation. */ + if(!strcmp(n->name,"bob_address"))return d->type; + Node *argument=n->a,*parameter=d->a; + while(argument && parameter) { + assignment_compatible(parameter->type,argument); + argument=argument->next;parameter=parameter->next; + } + if(argument || parameter)error("wrong argument count for %s",n->name); + return d->type; + } error("unknown function in sizeof: %s",n->name);return 0; + } case N_INDEX:{ int t=decay_type(expression_type(n->a)),other=decay_type(expression_type(n->b)); + if(t==3 || other==3)error("subscript has a void operand"); if(is_pointer(t) && is_pointer(other))error("subscript needs one integer operand"); if(!is_pointer(t))t=other; if(!is_pointer(t))error("subscript requires pointer/array"); + type_size(pointer_types[t-16].base); return pointer_types[t-16].base; } case N_UNARY:{ int t=expression_type(n->a); - if(n->op=='&')return pointer_to(t); + if(n->op=='&') { + if(n->a->kind!=N_ID && n->a->kind!=N_INDEX && n->a->kind!=N_STR && + !(n->a->kind==N_UNARY && n->a->op=='*'))error("address-of requires an lvalue"); + if(n->a->kind==N_UNARY && n->a->op=='*')return decay_type(expression_type(n->a->a)); + return object_readonly(n->a)?pointer_to_const(t):pointer_to(t); + } t=decay_type(t); - if(n->op=='*'){if(!is_pointer(t))error("dereference requires pointer");return pointer_types[t-16].base;} - if(n->op==T_INC || n->op==T_DEC)return t; - return 0; + if(t==3)error("void expression has no scalar value"); + if(n->op=='*'){if(!is_pointer(t))error("dereference requires pointer");return pointer_types[t-16].base;} + if((n->op=='+' || n->op=='-' || n->op=='~') && is_pointer(t))error("unary integer operator has a pointer operand"); + if(n->op==T_INC || n->op==T_DEC) {t=modifiable_type(n->a);if(is_pointer(t))type_size(pointer_types[t-16].base);return t;} + return (n->op=='+' || n->op=='-' || n->op=='~') && t==6?6:0; } - case N_ASSIGN:return decay_type(expression_type(n->a)); + case N_ASSIGN:{int type=modifiable_type(n->a);if(n->op=='=')assignment_compatible(type,n->b);else compound_constraints(compound_operator(n->op),type,expression_type(n->b));return type;} case N_BINARY:{ if(n->op==',')return decay_type(expression_type(n->b)); int a=decay_type(expression_type(n->a)),b=decay_type(expression_type(n->b)); + if(a==3 || b==3)error("void expression has no scalar value"); + if((n->op==T_EQ || n->op==T_NE) && (is_pointer(a) || is_pointer(b))) { + if(is_pointer(a) && is_pointer(b)) { + if(is_function_pointer(a)!=is_function_pointer(b))error("function and object pointers cannot be compared"); + if(pointer_types[a-16].base!=3 && pointer_types[b-16].base!=3 && composite_type(a,b)<0) + error("equality has incompatible pointer types"); + } else { + Node *integer=is_pointer(a)?n->b:n->a; + if(!constant_integer_syntax(integer) || constant(integer)!=0)error("pointer equality requires null integer constant"); + } + } + if((n->op=='<' || n->op=='>' || n->op==T_LE || n->op==T_GE) && (is_pointer(a) || is_pointer(b))) { + if(!is_pointer(a) || !is_pointer(b) || is_function_pointer(a) || is_function_pointer(b) || + composite_type(a,b)<0 || pointer_types[a-16].base==3) + error("relational pointer operands require compatible object types"); + } + if((n->op=='*' || n->op=='/' || n->op=='%' || n->op=='&' || n->op=='|' || n->op=='^' || n->op==T_SHL || n->op==T_SHR) && + (is_pointer(a) || is_pointer(b)))error("integer operator has a pointer operand"); if(n->op=='+' || n->op=='-') { - if(is_pointer(a) && is_pointer(b) && (n->op=='+' || a!=b))error("invalid pointer arithmetic"); + if(is_pointer(a) && is_pointer(b) && (n->op=='+' || composite_type(a,b)<0))error("invalid pointer arithmetic"); if(n->op=='-' && !is_pointer(a) && is_pointer(b))error("cannot subtract pointer from integer"); if(is_pointer(a))type_size(pointer_types[a-16].base); if(is_pointer(b))type_size(pointer_types[b-16].base); } if(n->op=='+' && is_pointer(b))return b; if((n->op=='+' || n->op=='-') && is_pointer(a) && !is_pointer(b))return a; + if(n->op==T_SHL || n->op==T_SHR)return a==6?6:0; + if(n->op=='+' || n->op=='-' || n->op=='*' || n->op=='/' || n->op=='%' || n->op=='&' || n->op=='|' || n->op=='^')return a==6 || b==6?6:0; return 0; } case N_CONDITIONAL:{ + if(expression_type(n->a)==3)error("void condition"); int a=decay_type(expression_type(n->b)),b=decay_type(expression_type(n->c)); - if(a==3 || b==3)return 3; - if(is_pointer(a))return a; - if(is_pointer(b))return b; - return 0; + if(a==3 || b==3){if(a!=b)error("conditional mixes void and value");return 3;} + if(is_pointer(a) && is_pointer(b)) { + if(pointer_types[a-16].base==3 || pointer_types[b-16].base==3)return pointer_to(3); + int type=composite_type(a,b);if(type<0)error("conditional has incompatible pointer types");return type; + } + if(is_pointer(a) || is_pointer(b)) { + Node *integer=is_pointer(a)?n->c:n->b; + if(!constant_integer_syntax(integer) || constant(integer)!=0)error("conditional pointer requires null integer constant"); + return is_pointer(a)?a:b; + } + return a==6 || b==6?6:0; } default:error("unsupported sizeof operand");return 0; } } static int type_size(int type) { if(type==3)error("sizeof void expression is invalid"); + if(is_function(type))error("function type has no object size"); if(is_array(type)) { int base=type_size(pointer_types[type-16].base),count=pointer_types[type-16].count; if(count<1)error("incomplete array has no storage size"); @@ -666,9 +1199,26 @@ static int type_size(int type) { } static void binary_typed(int op,int left,int right) { left=decay_type(left);right=decay_type(right); + if(left==3 || right==3)error("void expression has no scalar value"); + if((op=='<' || op=='>' || op==T_LE || op==T_GE) && (is_pointer(left) || is_pointer(right))) { + if(!is_pointer(left) || !is_pointer(right) || composite_type(left,right)<0 || pointer_types[left-16].base==3) + error("relational pointer operands require compatible object types"); + /* Address order is unsigned. Flipping the sign bit maps it onto the + signed comparison helpers without adding another runtime library. */ + addi(0,-32768);addi(1,-32768);binary(op);return; + } + const char *unsigned_helper=NULL; + if((left==6 || right==6) && (op=='/' || op=='%'))unsigned_helper=op=='/'?"__u_div":"__u_mod"; + if(left==6 && op==T_SHR)unsigned_helper="__u_shr"; + if((left==6 || right==6) && (op=='<' || op=='>' || op==T_LE || op==T_GE)) + unsigned_helper=op=='<'?"__u_lt":op=='>'?"__u_gt":op==T_LE?"__u_le":"__u_ge"; + if(unsigned_helper){if(is_pointer(left) || is_pointer(right))error("unsigned integer operator has pointer operand");push(0);push(1);call(named("fn.",unsigned_helper));addi(6,2);return;} + if((op=='*' || op=='/' || op=='%' || op=='&' || op=='|' || op=='^' || op==T_SHL || op==T_SHR) && + (is_pointer(left) || is_pointer(right)))error("integer operator has a pointer operand"); if((op=='+' || op=='-') && (is_pointer(left) || is_pointer(right))) { if(is_pointer(left) && is_pointer(right)) { - if(op!='-' || left!=right)error("invalid pointer arithmetic"); + if(op!='-' || composite_type(left,right)<0)error("invalid pointer arithmetic"); + type_size(pointer_types[right-16].base); int stride=type_size(pointer_types[left-16].base);binary('-'); if(stride!=1){move(1,0);literal(0,stride,NULL);binary('/');}return; } @@ -687,41 +1237,73 @@ static void expr(Node *n) { switch(n->kind) { case N_NUM:literal(0,n->value,NULL);break; case N_STR:literal(0,0,string_label(n));break; - case N_ID: { int global;Variable *v=variable(n->name,&global);address(n);if(v->type!=2)emit(0x6000);break; } + case N_ID: { + int global;Variable *v=variable_lookup(n->name,&global); + if(v){address(n);if(v->type!=2)emit(0x6000);} + else {function(n->name);literal(0,0,named("fn.",n->name));} + break; + } case N_INDEX:address(n);if(!is_array(expression_type(n)))emit(0x6000);break; - case N_CAST:expr(n->a);break; + case N_CAST:expression_type(n);expr(n->a);convert_value(n->type);break; case N_SIZEOF:{ literal(0,type_size(expression_type(n->a)),NULL);break; } case N_UNARY: - if(n->op=='&')address(n->a); + expression_type(n); + if(n->a->kind==N_NUM && (n->op=='-' || n->op=='~' || n->op=='!')) { + int value=n->a->value; + literal(0,n->op=='-'?-value:n->op=='~'?~value:!value,NULL);break; + } + if(n->op=='!' && n->a->kind==N_UNARY && n->a->op=='!') { + expression_type(n);expr(n->a->a);literal(1,0,NULL);compare(T_NE);break; + } + if(n->op=='&') { + if(n->a->kind==N_ID) {int global;if(!variable_lookup(n->a->name,&global))expr(n->a);else address(n->a);} + else address(n->a); + } else if(n->op==T_INC||n->op==T_DEC) {address(n->a);push(0);emit(0x6000);if(n->value)move(4,0); int type=expression_type(n->a);if(is_array(type))error("array is not modifiable"); int stride=is_pointer(type)?type_size(pointer_types[type-16].base):1; - addi(0,n->op==T_INC?stride:-stride);pop(1);emit(0x9040);if(n->value)move(0,4);} - else {expr(n->a);if(n->op=='*'){int t=expression_type(n);if(t==3)error("cannot load void");if(!is_array(t))emit(0x6000);}else if(n->op=='-')negate(0);else if(n->op=='~')emit(0x3100); + addi(0,n->op==T_INC?stride:-stride);convert_value(type);pop(1);emit(0x9040);if(n->value)move(0,4);} + else {if(n->op=='+' || n->op=='-' || n->op=='~' || n->op=='!')expression_type(n);expr(n->a);if(n->op=='*'){int t=expression_type(n);if(t==3)error("cannot load void");if(!is_array(t) && !is_function(t))emit(0x6000);}else if(n->op=='-')negate(0);else if(n->op=='~')emit(0x3100); else if(n->op=='!'){literal(1,0,NULL);compare(T_EQ);}else if(n->op!='+')error("unsupported unary operator");} break; case N_BINARY: + expression_type(n); + if(n->a->kind==N_NUM && n->b->kind==N_NUM && (n->op=='+' || n->op=='-' || n->op=='*')) { + literal(0,constant(n),NULL);break; + } if(n->op==','){expr(n->a);expr(n->b);} - else if(n->op==T_AND||n->op==T_OR) {int shortcut=fresh(),end=fresh();expr(n->a);move(0,0);branch(n->op==T_AND?2:5,shortcut); + else if(n->op==T_AND||n->op==T_OR) {expression_type(n);int shortcut=fresh(),end=fresh();expr(n->a);move(0,0);branch(n->op==T_AND?2:5,shortcut); expr(n->b);literal(1,0,NULL);compare(T_NE);jump(end);mark(shortcut);literal(0,n->op==T_OR,NULL);mark(end);} else {expr(n->a);push(0);expr(n->b);pop(1);binary_typed(n->op,expression_type(n->a),expression_type(n->b));}break; case N_CONDITIONAL:{ + expression_type(n); int other=fresh(),end=fresh();expr(n->a);move(0,0);branch(2,other); expr(n->b);jump(end);mark(other);expr(n->c);mark(end);break; } case N_ASSIGN: { - if(is_array(expression_type(n->a)))error("array is not assignable"); + int left_type=modifiable_type(n->a); + if(n->op=='=')assignment_compatible(left_type,n->b); + if(n->op!='=')compound_constraints(compound_operator(n->op),left_type,expression_type(n->b)); address(n->a);push(0); if(n->op!='='){emit(0x6000);push(0);} expr(n->b); - if(n->op!='=') { pop(1);int op=n->op==T_ADDEQ?'+':n->op==T_SUBEQ?'-':n->op==T_MULEQ?'*':n->op==T_DIVEQ?'/':n->op==T_MODEQ?'%':n->op==T_ANDEQ?'&':n->op==T_OREQ?'|':'^';binary_typed(op,expression_type(n->a),expression_type(n->b)); } - pop(1);emit(0x9040);break; } + if(n->op!='=') { pop(1);binary_typed(compound_operator(n->op),left_type,expression_type(n->b)); } + convert_value(left_type);pop(1);emit(0x9040);break; } case N_CALL: { int count=0;for(Node *a=n->a;a;a=a->next)count++; + if(n->d) { + int pointer=decay_type(expression_type(n->d)); + if(!is_function_pointer(pointer))error("called expression is not a function pointer"); + int ftype=pointer_types[pointer-16].base; + FunctionType *signature=&function_types[pointer_types[ftype-16].count]; + if(!signature->unspecified && count!=signature->count)error("wrong argument count for function pointer"); + expr(n->d);push(0);args_reverse_signature(n->a,signature,0); + move(3,6);addi(3,count);emit(0x6000|(3<<9)|(3<<6));emit(legacy?0xcb00:0xc300);addi(6,count+1);break; + } if(!strcmp(n->name,"bob_address")){if(count!=1||n->a->kind!=N_ID)error("bob_address requires a function name");function(n->a->name);literal(0,0,named("fn.",n->a->name));break;} - if(!strcmp(n->name,"bob_call")){if(count!=1)error("bob_call needs one argument");expr(n->a);move(3,0);emit(legacy?0xcb00:0xc300);break;} + if(!strcmp(n->name,"bob_call")){if(count!=1)error("bob_call needs one argument");assignment_compatible(0,n->a);expr(n->a);move(3,0);emit(legacy?0xcb00:0xc300);break;} int vector=-1,expected=0; if(!strcmp(n->name,"bob_halt"))vector=0; else if(!strcmp(n->name,"bob_putc")){vector=1;expected=1;} @@ -730,15 +1312,21 @@ static void expr(Node *n) { else if(!strcmp(n->name,"bob_getc"))vector=5; else if(!strcmp(n->name,"bob_run")){vector=6;expected=1;} else if(!strcmp(n->name,"bob_snapshot")){vector=7;expected=2;} + else if(!strcmp(n->name,"bob_run_image")){vector=12;expected=1;} + else if(!strcmp(n->name,"bob_run_native")){vector=13;expected=1;} + else if(!strcmp(n->name,"bob_import_image")){vector=14;expected=1;} else if(!strcmp(n->name,"bob_key"))vector=8; else if(!strcmp(n->name,"bob_terminal"))vector=9; else if(!strcmp(n->name,"bob_columns"))vector=10; else if(!strcmp(n->name,"bob_rows"))vector=11; if(vector>=0) {if(count!=expected)error("wrong argument count for %s",n->name); + int first_type=(vector==2 || vector==12)?pointer_to_const(4):vector==3?pointer_to(4):vector==7 || vector==13 || vector==14?pointer_to(0):0; + if(count)assignment_compatible(first_type,n->a); + if(expected==2)assignment_compatible(0,n->a->next); if(expected==2){expr(n->a->next);push(0);expr(n->a);pop(1);}else if(count)expr(n->a); emit(0xf000|vector<<8);break;} Function *f=function(n->name);if(count!=f->nargs)error("wrong argument count for %s",n->name); - args_reverse(n->a);call(named("fn.",n->name));addi(6,count);break; } + args_reverse(n->a,f->node->a);call(named("fn.",n->name));if(count)addi(6,count);break; } default:error("unsupported expression kind %d",n->kind); } } @@ -759,6 +1347,19 @@ static void switch_cases(Node *n,Node **cases,int *count) { } switch_cases(n->next,cases,count); } +static void static_references(Node *n) { + if(!n)return; + if(n->kind==N_SIZEOF) { + n->value=type_size(expression_type(n->a));n->kind=N_NUM;n->a=NULL; + } + if(n->kind==N_ID) { + if(function_index(n->name)>=0)return; + int global;Variable *v=variable(n->name,&global); + if(!global)error("static initializer refers to automatic object %s",n->name); + n->name=v->name; + } + static_references(n->a);static_references(n->b);static_references(n->c);static_references(n->d);static_references(n->next); +} static void stmt(Node *n) { if(!n)return; switch(n->kind) { @@ -767,6 +1368,8 @@ static void stmt(Node *n) { case N_GOTO:jump_name(user_label(n->name));break; case N_CASE:if(!n->value)error("case/default outside switch");mark(n->value);stmt(n->b);break; case N_SWITCH:{ + int type=decay_type(expression_type(n->a)); + if(type==3 || is_pointer(type))error("switch requires integer condition"); Node *cases[256];int count=0,end=fresh(),fallback=end; switch_cases(n->b,cases,&count); expr(n->a);push(0); @@ -786,17 +1389,31 @@ static void stmt(Node *n) { nlocals=saved;scope_base=base;break; } case N_DECL: + if(n->storage) { + int index=n->storage==2?n->value:0; + if(n->storage==1)while(indexname))index++; + if(index==nglobals)error("unregistered extern object"); + int repeated=0; + for(int i=scope_base;iname)) { + if(n->storage!=1 || locals[i].offset!=65536+index)error("conflicting local storage for %s",n->name); + repeated=1; + } + if(!repeated){if(nlocals==MAX_SYMBOLS)error("too many locals");locals[nlocals++]=(Variable){n->name,n->type,n->count,65536+index,NULL,n->op,n->readonly};} + if(n->storage==2)static_references(n->a); + break; + } for(int i=scope_base;iname))error("duplicate local %s",n->name); if(nlocals==MAX_SYMBOLS)error("too many locals"); - locals[nlocals++]=(Variable){n->name,n->type,n->count,n->value,n->a,n->op}; + locals[nlocals++]=(Variable){n->name,n->type,n->count,n->value,n->a,n->op,n->readonly}; if(n->a){ Node v={0};v.kind=N_ID;v.name=n->name; - if(n->type!=2){address(&v);push(0);expr(n->a);pop(1);emit(0x9040);} + if(n->type!=2){assignment_compatible(n->type,n->a);address(&v);push(0);expr(n->a);convert_value(n->type);pop(1);emit(0x9040);} else { - int index=0,total=type_size(array_of(n->op,n->count)); + int index=0,total=type_size(array_of(n->op,n->count)),element=n->op; + while(is_array(element))element=pointer_types[element-16].base; for(Node *value=n->a;value;value=value->next) { if(index==total)error("too many array initializers"); - address(&v);addi(0,index++);push(0);expr(value);pop(1);emit(0x9040); + assignment_compatible(element,value);address(&v);addi(0,index++);push(0);expr(value);convert_value(element);pop(1);emit(0x9040); } if(indexa)expr(n->a);else literal(0,0,NULL);jump(return_label);break; - case N_IF:{int other=fresh(),end=fresh();expr(n->a);move(0,0);branch(2,other);stmt(n->b);jump(end);mark(other);stmt(n->c);mark(end);break;} + case N_RETURN: + if(current_return_type==3 && n->a)error("void function returns an expression"); + if(current_return_type!=3 && !n->a)error("value-returning function needs a return expression"); + if(n->a){assignment_compatible(current_return_type,n->a);expr(n->a);}else literal(0,0,NULL); + convert_value(current_return_type);jump(return_label);break; + case N_IF:{if(expression_type(n->a)==3)error("void condition");int other=fresh(),end=fresh();expr(n->a);move(0,0);branch(2,other);stmt(n->b);jump(end);mark(other);stmt(n->c);mark(end);break;} case N_DO:{ int start=fresh(),step=fresh(),end=fresh(); if(loop_depth==64)error("loops nested too deeply"); if(break_depth==64)error("break contexts nested too deeply"); mark(start);loop_step[loop_depth]=step;loop_end[loop_depth++]=end;break_targets[break_depth++]=end; - stmt(n->b);loop_depth--;break_depth--;mark(step);expr(n->a);move(0,0);branch(5,start);mark(end);break; + stmt(n->b);loop_depth--;break_depth--;mark(step);if(expression_type(n->a)==3)error("void condition");expr(n->a);move(0,0);branch(5,start);mark(end);break; } case N_WHILE:case N_FOR:{int start=fresh(),step=fresh(),end=fresh(); int saved=nlocals,base=scope_base; if(n->kind==N_FOR)scope_base=nlocals; if(n->kind==N_FOR)stmt(n->a); mark(start);Node *condition=n->kind==N_FOR?n->b:n->a; - if(condition){expr(condition);move(0,0);branch(2,end);}if(loop_depth==64)error("loops nested too deeply"); + if(condition){if(expression_type(condition)==3)error("void condition");expr(condition);move(0,0);branch(2,end);}if(loop_depth==64)error("loops nested too deeply"); if(break_depth==64)error("break contexts nested too deeply"); loop_step[loop_depth]=step;loop_end[loop_depth++]=end;break_targets[break_depth++]=end; stmt(n->kind==N_FOR?n->d:n->b);loop_depth--;break_depth--; @@ -833,87 +1454,280 @@ static void stmt(Node *n) { static int frame_slots; static void collect(Node *n) { if(!n)return; - if(n->kind==N_DECL){frame_slots+=n->type==2?type_size(array_of(n->op,n->count)):1;n->value=-frame_slots;} + if(n->kind==N_DECL && !n->storage){frame_slots+=n->type==2?type_size(array_of(n->op,n->count)):1;n->value=-frame_slots;} collect(n->a);collect(n->b);collect(n->c);collect(n->d);collect(n->next); } +/* Return the composite type, or -1 when the declarations conflict. */ +static int composite_type(int a,int b) { + if(a==b)return a; + if(is_enum(a) && b==0)return a; + if(is_enum(b) && a==0)return b; + if(!is_derived(a) || !is_derived(b))return -1; + PointerType x=pointer_types[a-16],y=pointer_types[b-16]; + if(x.kind!=y.kind)return -1; + if(x.kind==3)return -1; + if(x.kind==4) { + int signature=x.count; + if(x.count!=y.count) { + FunctionType *left=&function_types[x.count],*right=&function_types[y.count]; + if(left->unspecified==right->unspecified)return -1; + FunctionType *specified=left->unspecified?right:left; + for(int i=0;icount;i++) + if(specified->parameters[i]!=0 && specified->parameters[i]!=6 && !is_pointer(specified->parameters[i]))return -1; + signature=left->unspecified?y.count:x.count; + } + int result=composite_type(x.base,y.base); + return result<0?-1:function_type(result,signature); + } + int base=composite_type(x.base,y.base); + if(base<0)return -1; + if(x.kind==1)return derived_type(1,base,1,x.qualifiers|y.qualifiers); + if(x.count && y.count && x.count!=y.count)return -1; + return derived_type(2,base,x.count?x.count:y.count,x.qualifiers|y.qualifiers); +} +static int function_composite_type(int a,int b) { + if(is_pointer(a) || is_pointer(b)) { + if(!is_pointer(a) || !is_pointer(b))return -1; + PointerType x=pointer_types[a-16],y=pointer_types[b-16]; + if(x.qualifiers!=y.qualifiers)return -1; + int base=function_composite_type(x.base,y.base); + return base<0?-1:derived_type(1,base,1,x.qualifiers); + } + if(is_array(a) || is_array(b)) { + if(!is_array(a) || !is_array(b))return -1; + PointerType x=pointer_types[a-16],y=pointer_types[b-16]; + if(x.count && y.count && x.count!=y.count)return -1; + int base=function_composite_type(x.base,y.base); + return base<0?-1:derived_type(2,base,x.count?x.count:y.count,x.qualifiers|y.qualifiers); + } + return composite_type(a,b); +} static void compatible_function(Node *a,Node *b) { - if(a->type!=b->type)error("conflicting return type for %s",a->name); + int result=function_composite_type(a->type,b->type); + if(result<0)error("conflicting return type for %s",a->name); + a->type=b->type=result; if((a->kind==N_PROTOTYPE && a->op) || (b->kind==N_PROTOTYPE && b->op))return; Node *x=a->a,*y=b->a; - while(x && y){if(x->type!=y->type)error("conflicting parameter type for %s",a->name);x=x->next;y=y->next;} + while(x && y){result=function_composite_type(x->type,y->type);if(result<0)error("conflicting parameter type for %s",a->name);x->type=y->type=result;x=x->next;y=y->next;} if(x || y)error("conflicting parameter count for %s",a->name); } +static int register_object(Node *n,int defined,int visible) { + int index=0;while(indexname))index++; + if(index==nglobals) { + if(nglobals==MAX_SYMBOLS)error("too many globals"); + globals[nglobals++]=(Variable){n->name,n->type,n->count,0,n->a,n->op,n->readonly}; + global_linkage[index]=n->storage==2?2:1; + } else { + if(globals[index].readonly!=n->readonly)error("conflicting const qualification for %s",n->name); + if(visible && ((n->storage==2 && global_linkage[index]!=2) || + (n->storage==0 && global_linkage[index]==2)))error("conflicting linkage for object %s",n->name); + Variable *g=&globals[index]; + int old=g->type==2?array_of(g->base,g->count):g->type; + int next=n->type==2?array_of(n->op,n->count):n->type; + int merged=composite_type(old,next); + if(merged<0)error("conflicting object type for %s",n->name); + if(g->init && n->a)error("multiple object definitions for %s",n->name); + if(is_array(merged)){g->type=2;g->base=pointer_types[merged-16].base;g->count=pointer_types[merged-16].count;} + else g->type=merged; + if(n->a)g->init=n->a; + } + if(defined)global_defined[index]=1; + if(visible && n->storage==2 && n->type==2 && !n->count)error("internal tentative array requires complete type"); + if(visible)global_visible[index]=1; + return index; +} +static void collect_externs(Node *n) { + if(!n)return; + if(n->kind==N_DECL && n->storage) { + if(n->storage==2) {Node object=*n;object.name=named("static.",label_name(fresh()));n->value=register_object(&object,1,0);} + else register_object(n,0,0); + } + collect_externs(n->a);collect_externs(n->b);collect_externs(n->c);collect_externs(n->d);collect_externs(n->next); +} +static int function_index(const char *name) { + for(int i=0;ikind==N_ID && function_index(n->name)>=0)mark_function(n->name); + if(n->kind==N_CALL && n->name) { + if(!strcmp(n->name,"bob_address") && n->a && n->a->kind==N_ID)mark_function(n->a->name); + else mark_function(n->name); + } + if(n->kind==N_INDEX){mark_function("__mul");mark_function("__div");} + if(n->kind==N_BINARY || n->kind==N_ASSIGN) { + const char *helper_name=NULL; + switch(n->op) { + case '*':case T_MULEQ:helper_name="__mul";break; + case '/':case T_DIVEQ:helper_name="__div";break; + case '%':case T_MODEQ:helper_name="__mod";break; + case '|':case T_OREQ:helper_name="__or";break; + case '^':case T_XOREQ:helper_name="__xor";break; + case T_SHL:case T_SHLEQ:helper_name="__shl";break; + case T_SHR:case T_SHREQ:helper_name="__shr";break; + case '<':helper_name="__cmp_lt";break; + case '>':helper_name="__cmp_gt";break; + case T_LE:helper_name="__cmp_le";break; + case T_GE:helper_name="__cmp_ge";break; + case T_EQ:helper_name="__cmp_eq";break; + case T_NE:helper_name="__cmp_ne";break; + default:break; + } + if(helper_name)mark_function(helper_name); + if(n->op=='/' || n->op==T_DIVEQ || n->op=='%' || n->op==T_MODEQ) + mark_function(n->op=='/' || n->op==T_DIVEQ?"__u_div":"__u_mod"); + if(n->op==T_SHR || n->op==T_SHREQ)mark_function("__u_shr"); + if(n->op=='<' || n->op=='>' || n->op==T_LE || n->op==T_GE) { + mark_function(n->op=='<'?"__u_lt":n->op=='>'?"__u_gt":n->op==T_LE?"__u_le":"__u_ge"); + } + if(n->op=='+' || n->op=='-') {mark_function("__mul");mark_function("__div");} + } + mark_nodes(n->a);mark_nodes(n->b);mark_nodes(n->c);mark_nodes(n->d);mark_nodes(n->next); +} +static void mark_function(const char *name) { + int index=function_index(name); + if(index<0 || functions[index].reachable)return; + functions[index].reachable=1; + mark_nodes(functions[index].node->b); +} static void generate(void) { + char *linkage_names[MAX_SYMBOLS];int linkage_values[MAX_SYMBOLS],linkage_count=0; for(Node *n=top;n;n=n->next) { + if(n->kind==N_FUNCTION || n->kind==N_PROTOTYPE) { + int i=0;while(iname))i++; + if(i==linkage_count) { + if(linkage_count==MAX_SYMBOLS)error("too many function declarations"); + linkage_names[i]=n->name;linkage_values[i]=n->storage==2?2:1;linkage_count++; + } else if(n->storage==2 && linkage_values[i]!=2)error("conflicting linkage for function %s",n->name); + } if(n->kind==N_FUNCTION){if(nfunctions==MAX_SYMBOLS)error("too many functions");int count=0;for(Node *a=n->a;a;a=a->next)count++; for(int i=0;iname))error("duplicate function %s",n->name); - functions[nfunctions++]=(Function){n->name,n,count};} - else if(n->kind==N_DECL){if(nglobals==MAX_SYMBOLS)error("too many globals");for(int i=0;iname))error("duplicate global %s",n->name); - globals[nglobals++]=(Variable){n->name,n->type,n->count,0,n->a,n->op};} + functions[nfunctions++]=(Function){n->name,n,count,0};} + else if(n->kind==N_DECL)register_object(n,!n->value || n->a,1); } + for(int i=0;ib); + for(int i=0;inext)if(n->kind==N_PROTOTYPE || n->kind==N_FUNCTION) { for(Node *other=n->next;other;other=other->next) if((other->kind==N_PROTOTYPE || other->kind==N_FUNCTION) && !strcmp(n->name,other->name))compatible_function(n,other); for(int i=0;iname,globals[i].name))error("object/function name collision %s",n->name); } - if(function("main")->nargs)error("main must take no arguments"); - define("entry");literal(6,0xf000,NULL);literal(5,0,NULL);call("fn.main");emit(0xf000); + if(function("main")->nargs && (!wide_app || function("main")->nargs!=2)) + error("main must take no arguments, or a bob32 app may use main(int argc, char **argv)"); + for(Node *n=top;n;n=n->next)if(n->kind==N_DECL)mark_nodes(n->a); + mark_function("main"); + define("entry");if(!wide_app)literal(6,0xf000,NULL);literal(5,0,NULL); + if(wide_app && function("main")->nargs==2){push(1);push(0);} + call("fn.main");emit(0xf000); for(int i=0;iname;nlocals=0;frame_slots=0;int arg=0; + if(wide && !functions[i].reachable)continue; + Function *f=&functions[i];current_function=f->name;current_return_type=f->node->type;nlocals=0;frame_slots=0;int arg=0; compiling_compare_helper=!strncmp(f->name,"__cmp_",6); for(Node *a=f->node->a;a;a=a->next){ if(!*a->name||a->type==2)error("named scalar/pointer parameters required"); for(int j=0;jname))error("duplicate parameter %s",a->name); - locals[nlocals++]=(Variable){a->name,a->type,1,2+arg++,NULL,a->op}; + locals[nlocals++]=(Variable){a->name,a->type,1,2+arg++,NULL,a->op,a->readonly}; } collect(f->node->b);if(frame_slots>4096)error("frame too large");return_label=fresh();define(named("fn.",f->name)); scope_base=0;function_body=1; - push(7);push(5);move(5,6);addi(6,-frame_slots);stmt(f->node->b);literal(0,0,NULL);mark(return_label);move(6,5);pop(5);pop(7);emit(0xe000); + int needs_frame=frame_slots || f->nargs; + push(7);if(needs_frame){push(5);move(5,6);}if(frame_slots)addi(6,-frame_slots); + stmt(f->node->b);literal(0,0,NULL);mark(return_label); + if(needs_frame){move(6,5);pop(5);}pop(7);emit(0xe000); } nlocals=0; - for(int i=0;iname));Node *init=g->init; + for(int i=0;iname));Node *init=g->init; int total=g->type==2?type_size(array_of(g->base,g->count)):g->count; int element=g->type==2?g->base:g->type; while(is_array(element))element=pointer_types[element-16].base; for(int j=0;jnext; }if(init)error("too many initializers for %s",g->name);} for(int i=0;i0x9000)error("kernel exceeds 0x9000 (code + data is %d words)",ncode); - for(int i=0;i0xa000)error("kernel exceeds 0xA000 (code + data is %d words)",ncode); + if(wide && (uint64_t)origin+(uint32_t)ncode>(uint64_t)UINT32_MAX+1) + error("wide image exceeds the 32-bit address space"); + for(int i=0;i4000000)error("input too large"); + if(fseek(f,0,SEEK_SET))error("input seek failure"); char *s=allocate((size_t)length+1); - if(fread(s,1,(size_t)length,f)!=(size_t)length)error("read failure"); - fclose(f);return s; + if(fread(s,1,(size_t)length,f)!=(size_t)length || ferror(f))error("read failure"); + if(fclose(f))error("input close failure"); + if(memchr(s,0,(size_t)length))error("zero byte in source"); + return s; } static void word(FILE *f,int value) { fputc(value&255,f);fputc((value>>8)&255,f); } +static void dword(FILE *f,uint32_t value) { word(f,(int)value);word(f,(int)(value>>16)); } +static void finish_output(FILE *file) { + int failed=ferror(file); + if(fclose(file))failed=1; + if(failed)error("output write failure"); +} +static int same_path(const char *a,const char *b) { +#ifdef _WIN32 + char absolute_a[4096],absolute_b[4096]; + if(!_fullpath(absolute_a,a,sizeof(absolute_a)) || !_fullpath(absolute_b,b,sizeof(absolute_b))) + error("cannot resolve output path"); + return !_stricmp(absolute_a,absolute_b); +#else + return !strcmp(a,b); +#endif +} int main(int argc,char **argv) { - if(argc<4||argc>5){fprintf(stderr,"Usage: bobcc input.i output.basm output.b16 [--legacy]\n");return 1;} - if(argc==5){if(strcmp(argv[4],"--legacy"))error("unknown option");legacy=1;} + if(argc<4||argc>5){fprintf(stderr,"Usage: bobcc input.i output.basm output.b16 [--legacy|--wide|--wide-kernel|--wide-app]\n");return 1;} + if(argc==5){if(!strcmp(argv[4],"--legacy"))legacy=1;else if(!strcmp(argv[4],"--wide"))wide=1;else if(!strcmp(argv[4],"--wide-kernel")){wide=1;origin=0x10000;}else if(!strcmp(argv[4],"--wide-app")){wide=1;wide_app=1;origin=0x20000;}else error("unknown option");} + if(wide&&legacy)error("--wide cannot be combined with --legacy"); lex(read_file(argv[1]));parse(); /* Parse helper bodies in a second token buffer, preserving the AST. */ - memset(tokens,0,sizeof(tokens));ntokens=at=0;lex(read_file("tools/arithmetic.c"));parse();generate(); - FILE *basm=fopen(argv[2],"wb");if(!basm){perror(argv[2]);return 1;} - fprintf(basm,"; bob16 C kernel, generated by tools/bobcc.c\n.fill 4601\n.fill b600\n.fill 0300\n"); - for(int i=3;i=sizeof(map_path))error("output path too long"); - strcpy(map_path,argv[3]);char *extension=strrchr(map_path,'.'); + strcpy(map_path,argv[3]);char *base=map_path; + for(char *p=map_path;*p;p++)if(*p=='/' || *p=='\\')base=p+1; + char *extension=strrchr(base,'.'); if(extension)strcpy(extension,".map");else strcat(map_path,".map"); - FILE *map=fopen(map_path,"w");if(map){for(int i=0;i #include #include +#include +#include #ifdef _WIN32 #include #define EXE ".exe" #define BUILD_DIR "build\\" #define BOB_COMMAND "bob.exe" +#define BOB32_COMMAND "bob32.exe" #else -#include #define EXE "" #define BUILD_DIR "./build/" #define BOB_COMMAND "./bob" +#define BOB32_COMMAND "./bob32" #endif static void run(const char *command) { if(system(command)!=0){fprintf(stderr,"Build failed: %s\n",command);exit(1);} } int main(int argc,char **argv) { - if(argc>2||(argc==2&&strcmp(argv[1],"--run")&&strcmp(argv[1],"--test"))) { - fprintf(stderr,"Usage: build [--run | --test] (from repository root)\n");return 1; + if(argc>2||(argc==2&&strcmp(argv[1],"--run")&&strcmp(argv[1],"--run32")&&strcmp(argv[1],"--test"))) { + fprintf(stderr,"Usage: build [--run | --run32 | --test] (from repository root)\n");return 1; } #ifdef _WIN32 - _mkdir("build"); - FILE *gcc=fopen("C:/msys64/ucrt64/bin/gcc.exe","rb"); - if(gcc){fclose(gcc);const char *path=getenv("PATH");size_t size=(path?strlen(path):0)+64; - char *value=malloc(size);if(!value)return 1;snprintf(value,size,"C:/msys64/ucrt64/bin;%s",path?path:"");_putenv_s("PATH",value);free(value);} + int directory_result=_mkdir("build"); #else - mkdir("build",0777); + int directory_result=mkdir("build",0777); #endif + if(directory_result && errno!=EEXIST){perror("build");return 1;} + struct stat directory; + if(stat("build",&directory)) {perror("build");return 1;} +#ifdef _WIN32 + int is_directory=(directory.st_mode&_S_IFMT)==_S_IFDIR; +#else + int is_directory=S_ISDIR(directory.st_mode); +#endif + if(!is_directory){ + fprintf(stderr,"build must be a directory\n");return 1; + } run("gcc -std=gnu11 -O2 -Wall -Wextra -Werror main.c -o bob" EXE); + run("gcc -std=gnu11 -O2 -Wall -Wextra -Werror main.c -o bob32" EXE); run("gcc -std=c11 -O2 -Wall -Wextra -Werror tools/bobcc.c -o build/bobcc" EXE); run("gcc -E -P -nostdinc -undef -DBOBC_LEGACY=0 -I kernel kernel/kernel.c -o build/kernel.i"); run(BUILD_DIR "bobcc" EXE " build/kernel.i kernel.basm build/kernel.b16"); + run("gcc -E -P -nostdinc -undef -DBOBC_LEGACY=0 -DBOBC_WIDE=1 -I kernel kernel/kernel.c -o build/kernel32.i"); + run(BUILD_DIR "bobcc" EXE " build/kernel32.i build/kernel32.basm build/kernel32.b32 --wide-kernel"); if(argc==2&&!strcmp(argv[1],"--test")) { + run("gcc -std=c11 -O2 -Wall -Wextra -Werror tests/test_cpu.c -o build/test_cpu" EXE); + run(BUILD_DIR "test_cpu" EXE); run("gcc -std=c11 -O2 -Wall -Wextra -Werror tests/test_os.c -o build/test_os" EXE); run(BUILD_DIR "test_os" EXE); #ifdef _WIN32 run("gcc -std=c11 -O2 -Wall -Wextra -Werror tests/test_console.c -o build/test_console.exe"); run("build\\test_console.exe"); #endif - } else if(argc==2) run(BOB_COMMAND " --boot build/kernel.b16"); + } else if(argc==2&&!strcmp(argv[1],"--run32")) run(BOB32_COMMAND " --boot build/kernel32.b32"); + else if(argc==2) run(BOB_COMMAND " --boot build/kernel.b16"); return 0; } diff --git a/tools/unsigned.c b/tools/unsigned.c new file mode 100644 index 0000000..52e689a --- /dev/null +++ b/tools/unsigned.c @@ -0,0 +1,26 @@ +/* Native 16-bit unsigned operations, expressed in the signed C foundation. */ +int __u_lt(int a, int b) { + if (a < 0) { if (b >= 0) return 0; } + else if (b < 0) return 1; + return a < b; +} +int __u_gt(int a, int b) { return __u_lt(b, a); } +int __u_le(int a, int b) { return !__u_lt(b, a); } +int __u_ge(int a, int b) { return !__u_lt(a, b); } +int __u_div(int a, int b) { + int q = 0, r = 0, i = 0, carry, bit; + if (b == 0) return 0; + while (i < 16) { + carry = r < 0; bit = a < 0; + r = r + r + bit; a = a + a; q = q + q; + if (carry || !__u_lt(r, b)) { r = r - b; q++; } + i++; + } + return q; +} +int __u_mod(int a, int b) { if (b == 0) return 0; return a - __mul(__u_div(a, b), b); } +int __u_shr(int a, int b) { + if (b < 0 || b > 15) return 0; + while (b > 0) { a = __shr(a, 1) & 32767; b--; } + return a; +}