From b31455f81d8b7cecd66f577a0ce545dfe66d705b Mon Sep 17 00:00:00 2001
From: Kartik Agaram <vc@akkartik.com>
Date: Sun, 18 Nov 2018 00:17:29 -0800
Subject: [PATCH] 4747 - subx: 'read' primitive

---
 subx/010---vm.cc      |   2 +-
 subx/056write.subx    |  37 +++--
 subx/058read.subx     | 362 ++++++++++++++++++++++++++++++++++++++++++
 subx/apps/crenshaw2-1 | Bin 3378 -> 4171 bytes
 subx/apps/factorial   | Bin 3395 -> 4188 bytes
 5 files changed, 385 insertions(+), 16 deletions(-)
 create mode 100644 subx/058read.subx

diff --git a/subx/010---vm.cc b/subx/010---vm.cc
index 8a19d818..a71d431f 100644
--- a/subx/010---vm.cc
+++ b/subx/010---vm.cc
@@ -112,7 +112,7 @@ SF = ZF = OF = false;
 //:: simulated RAM
 
 :(before "End Types")
-const uint32_t INITIAL_SEGMENT_SIZE = 0x1000 - 1;
+const uint32_t INITIAL_SEGMENT_SIZE = 0x1000000 - 1;
 // Subtract one just so we can start the first segment at address 1 without
 // overflowing the first segment. Other segments will learn to adjust.
 
diff --git a/subx/056write.subx b/subx/056write.subx
index e750c12d..015f9f69 100644
--- a/subx/056write.subx
+++ b/subx/056write.subx
@@ -15,20 +15,6 @@
 #   write: int  # index at which writes go
 #   data: (array byte)  # prefixed by length as usual
 
-== data
-
-# In-memory stream for tests to write() to.
-# Also illustrates the layout of streams.
-_test-stream:
-  # current write index
-  00 00 00 00
-  # current read index
-  00 00 00 00
-  # length (= 8)
-  08 00 00 00
-  # data
-  00 00 00 00 00 00 00 00  # 8 bytes
-
 == code
 
 # instruction                     effective address                                                   operand     displacement    immediate
@@ -97,7 +83,7 @@ $write:end:
   5d/pop-to-EBP
   c3/return
 
-clear-stream:  # f : (address stream)
+clear-stream:  # f : (address stream) -> <void>
   # prolog
   55/push-EBP
   89/copy                         3/mod/direct    5/rm32/EBP    .           .             .           4/r32/ESP   .               .                 # copy ESP to EBP
@@ -151,6 +137,15 @@ test-write-single:
   e8/call  write/disp32
     # discard args
   81          0/subop/add         3/mod/direct    4/rm32/ESP    .           .             .           .           .               8/imm32           # add to ESP
+  # check-ints-equal(EAX, 2)
+    # push args
+  68/push  "F - test-read-single: return EAX"/imm32
+  68/push  2/imm32
+  50/push-EAX
+    # call
+  e8/call  check-ints-equal/disp32
+    # discard args
+  81          0/subop/add         3/mod/direct    4/rm32/ESP    .           .             .           .           .               0xc/imm32         # add to ESP
   # check-ints-equal(*_test-stream.data, 41/A 62/b 00 00, msg)
     # push args
   68/push  "F - test-write-single"/imm32
@@ -202,3 +197,15 @@ test-write-appends:
   81          0/subop/add         3/mod/direct    4/rm32/ESP    .           .             .           .           .               0xc/imm32         # add to ESP
   # end
   c3/return
+
+== data
+
+_test-stream:
+  # current write index
+  00 00 00 00
+  # current read index
+  00 00 00 00
+  # length (= 8)
+  08 00 00 00
+  # data
+  00 00 00 00 00 00 00 00  # 8 bytes
diff --git a/subx/058read.subx b/subx/058read.subx
new file mode 100644
index 00000000..a43a8718
--- /dev/null
+++ b/subx/058read.subx
@@ -0,0 +1,362 @@
+# read: analogously to write, support reading from in-memory streams in
+# addition to file descriptors.
+#
+# We can pass it either a file descriptor or an address to a stream. If a
+# file descriptor is passed in, we _read from it using the right syscall. If a
+# stream is passed in (a fake file descriptor), we read from it instead. This
+# lets us initialize input for tests.
+#
+# A little counter-intuitively, the output of 'read' ends up in.. a stream. So
+# tests end up doing a redundant copy. Why? Well, consider the alternatives:
+#
+#   a) Reading into a string, and returning a pointer to the end of the read
+#   region, or a count of bytes written. Now this count or end pointer must be
+#   managed separately by the caller, which can be error-prone.
+#
+#   b) Having 'read' return a buffer that it allocates. But there's no way to
+#   know in advance how large to make the buffer. If you read less than the
+#   size of the buffer you again end up needing to manage initialized vs
+#   uninitialized memory.
+#
+#   c) Creating more helpful variants like 'read-byte' or 'read-until' which
+#   also can take a file descriptor or stream, just like 'write'. But such
+#   primitives don't exist in the Linux kernel, so we'd be implementing them
+#   somehow, either with more internal buffering or by making multiple
+#   syscalls.
+#
+# Reading into a stream avoids these problems. The buffer is externally
+# provided and the caller has control over where it's allocated, its lifetime,
+# and so on. The buffer's read and write pointers are internal to it so it's
+# easier to keep in a consistent state. And it can now be passed directly to
+# helpers like 'read-byte' or 'read-until' that only need to support streams,
+# never file descriptors.
+#
+# Like with 'write', we assume our data segment will never begin at an address
+# shorter than 0x08000000, so any smaller arguments are assumed to be real
+# file descriptors.
+#
+# As a reminder, a stream looks like this:
+#   write: int  # index at which to write to next
+#   read: int  # index at which to read next
+#   data: (array byte)  # prefixed by length as usual
+
+== code
+
+# instruction                     effective address                                                   operand     displacement    immediate
+# op          subop               mod             rm32          base        index         scale       r32
+# 1-3 bytes   3 bits              2 bits          3 bits        3 bits      3 bits        2 bits      2 bits      0/1/2/4 bytes   0/1/2/4 bytes
+
+# main:  (manual test if this is the last file loaded)
+  e8/call  run-tests/disp32  # 'run-tests' is a function created automatically by SubX. It calls all functions that start with 'test-'.
+  # syscall(exit, Num-test-failures)
+  8b/copy                         0/mod/indirect  5/rm32/.disp32            .             .           1/r32/EBX   Num-test-failures/disp32          # copy *Num-test-failures to EBX
+  b8/copy-to-EAX  1/imm32
+  cd/syscall  0x80/imm8
+
+read:  # f : fd or (address stream), s : (address stream) -> num-bytes-read/EAX
+  # prolog
+  55/push-EBP
+  89/copy                         3/mod/direct    5/rm32/EBP    .           .             .           4/r32/ESP   .               .                 # copy ESP to EBP
+  ## if (f < 0x08000000) return _read(f, s)  # f can't be a user-mode address, so treat it as a kernel file descriptor
+  81          7/subop/compare     1/mod/*+disp8   4/rm32/sib    5/base/EBP  4/index/none  .           .           8/disp8         0x08000000/imm32  # compare *(EBP+8)
+  7d/jump-if-greater-or-equal  $read:fake/disp8
+    # push args
+  ff          6/subop/push        1/mod/*+disp8   4/rm32/sib    5/base/EBP  4/index/none  .           .           0xc/disp8       .                 # push *(EBP+12)
+  ff          6/subop/push        1/mod/*+disp8   4/rm32/sib    5/base/EBP  4/index/none  .           .           8/disp8         .                 # push *(EBP+8)
+    # call
+  e8/call  _read/disp32
+    # discard args
+  81          0/subop/add         3/mod/direct    4/rm32/ESP    .           .             .           .           .               8/imm32           # add to ESP
+  # return
+  eb/jump  $read:end/disp8
+$read:fake:
+  ## otherwise, treat 'f' as a stream to scan from
+  # save registers
+  56/push-ESI
+  57/push-EDI
+  # ESI = f
+  8b/copy                         1/mod/*+disp8   4/rm32/sib    5/base/EBP  4/index/none              6/r32/ESI   8/disp8         .                 # copy *(EBP+8) to ESI
+  # EDI = s
+  8b/copy                         1/mod/*+disp8   4/rm32/sib    5/base/EBP  4/index/none              7/r32/EDI   0xc/disp8       .                 # copy *(EBP+12) to ESI
+  # EAX = _append-4(out = &s->data[s->write], outend = &s->data[s->length],
+  #                 in  = &f->data[f->read],  inend =  &f->data[f->write])
+    # push &f->data[f->write]
+  8b/copy                         0/mod/indirect  6/rm32/ESI    .           .             .           0/r32/EAX   .               .                 # copy *ESI to EAX
+  8d/copy-address                 1/mod/*+disp8   4/rm32/sib    6/base/ESI  0/index/EAX   .           0/r32/EAX   0xc/disp8       .                 # copy ESI+EAX+12 to EAX
+  50/push-EAX
+    # push &f->data[f->read]
+  8b/copy                         1/mod/*+disp8   6/rm32/ESI    .           .             .           0/r32/EAX   4/disp8         .                 # copy *(ESI+4) to EAX
+  8d/copy-address                 1/mod/*+disp8   4/rm32/sib    6/base/ESI  0/index/EAX   .           0/r32/EAX   0xc/disp8       .                 # copy ESI+EAX+12 to EAX
+  50/push-EAX
+    # push &s.data[s.length]
+  8b/copy                         1/mod/*+disp8   7/rm32/EDI    .           .             .           0/r32/EAX   8/disp8         .                 # copy *(EDI+8) to EAX
+  8d/copy-address                 1/mod/*+disp8   4/rm32/sib    7/base/EDI  0/index/EAX   .           0/r32/EAX   0xc/disp8       .                 # copy EDI+EAX+12 to EAX
+  50/push-EAX
+    # push &s.data[s.write]
+  8b/copy                         0/mod/indirect  7/rm32/EDI    .           .             .           0/r32/EAX   .               .                 # copy *EDI to EAX
+  8d/copy-address                 1/mod/*+disp8   4/rm32/sib    7/base/EDI  0/index/EAX   .           0/r32/EAX   0xc/disp8       .                 # copy EDI+EAX+12 to EAX
+  50/push-EAX
+    # call
+  e8/call  _append-4/disp32
+    # discard args
+  81          0/subop/add         3/mod/direct    4/rm32/ESP    .           .             .           .           .               0x10/imm32        # add to ESP
+  # s.write += EAX
+  01/add                          0/mod/indirect  7/rm32/EDI    .           .             .           0/r32/EAX   .               .                 # add EAX to *EDI
+  # f.read += EAX
+  01/add                          1/mod/*+disp8   6/rm32/ESI    .           .             .           0/r32/EAX   4/disp8         .                 # add EAX to *(ESI+4)
+  # restore registers
+  5f/pop-to-EDI
+  5e/pop-to-ESI
+$read:end:
+  # epilog
+  89/copy                         3/mod/direct    4/rm32/ESP    .           .             .           5/r32/EBP   .               .                 # copy EBP to ESP
+  5d/pop-to-EBP
+  c3/return
+
+## helpers
+
+# idea: we could create a clear-if-empty method that clears only if f.read == f.write
+# Unclear how I'd use it, though. Callers seem to need the check anyway.
+# Maybe a better helper would be 'empty-stream?'
+
+_read:  # fd : int, s : (address stream) -> num-bytes-read/EAX
+  # prolog
+  55/push-EBP
+  89/copy                         3/mod/direct    5/rm32/EBP    .           .             .           4/r32/ESP   .               .                 # copy ESP to EBP
+  # save registers
+  51/push-ECX
+  52/push-EDX
+  53/push-EBX
+  56/push-ESI
+  # ESI = s
+  8b/copy                         1/mod/*+disp8   4/rm32/sib    5/base/EBP  4/index/none  .           6/r32/ESI   0xc/disp8       .                 # copy *(EBP+12) to ESI
+  # EAX = s.write
+  8b/copy                         0/mod/indirect  6/rm32/ESI    .           .             .           0/r32/EAX   .               .                 # copy *ESI to EAX
+  # EDX = s.length
+  8b/copy                         1/mod/*+disp8   6/rm32/ESI    .           .             .           2/r32/EDX   8/disp8         .                 # copy *(ESI+8) to EDX
+  # syscall(read, fd, &s.data[s.write], s.length - s.write)
+    # fd : EBX
+  8b/copy                         1/mod/*+disp8   4/rm32/sib    5/base/EBP  4/index/none  .           3/r32/EBX   8/disp8         .                 # copy *(EBP+8) to EBX
+    # data : ECX = &s.data[s.write]
+  8d/copy-address                 1/mod/*+disp8   4/rm32/sib    6/base/ESI  0/index/EAX   .           1/r32/ECX   0xc/disp8       .                 # copy ESI+EAX+12 to ECX
+    # size : EDX = s.length - s.write
+  29/subtract                     3/mod/direct    2/rm32/EDX    .           .             .           0/r32/EAX   .               .                 # subtract EAX from EDX
+    # syscall
+  b8/copy-to-EAX  3/imm32/read
+  cd/syscall  0x80/imm8
+  # add the result EAX to s.write
+  01/add                          0/mod/indirect  6/rm32/ESI    .           .             .           0/r32/EAX   .               .                 # add EAX to *ESI
+  # restore registers
+  5e/pop-to-ESI
+  5b/pop-to-EBX
+  5a/pop-to-EDX
+  59/pop-to-ECX
+  # epilog
+  89/copy                         3/mod/direct    4/rm32/ESP    .           .             .           5/r32/EBP   .               .                 # copy EBP to ESP
+  5d/pop-to-EBP
+  c3/return
+
+  # Two options:
+  #   1 (what we have above):
+  #     ECX = s
+  #     EAX = s.write
+  #     EDX = s.length
+  #     # syscall
+  #     ECX = lea ECX+EAX+12
+  #     EDX = sub EDX EAX
+  #
+  #   2:
+  #     ECX = s
+  #     EDX = s.length
+  #     ECX = &s.data
+  #     # syscall
+  #     ECX = add ECX, s.write
+  #     EDX = sub EDX, s.write
+  #
+  # Not much to choose between the two? Option 2 performs a duplicate load to
+  # use one less register, but doesn't increase the amount of spilling (ECX
+  # and EDX must be used, and EAX must be clobbered anyway).
+
+## tests
+
+test-read-single:
+  # clear-stream(_test-stream)
+    # push args
+  68/push  _test-stream/imm32
+    # call
+  e8/call  clear-stream/disp32
+    # discard args
+  81          0/subop/add         3/mod/direct    4/rm32/ESP    .           .             .           .           .               4/imm32           # add to ESP
+  # clear-stream(_test-stream-buffer)
+    # push args
+  68/push  _test-stream-buffer/imm32
+    # call
+  e8/call  clear-stream/disp32
+    # discard args
+  81          0/subop/add         3/mod/direct    4/rm32/ESP    .           .             .           .           .               4/imm32           # add to ESP
+  # write(_test-stream, "Ab")
+    # push args
+  68/push  "Ab"/imm32
+  68/push  _test-stream/imm32
+    # call
+  e8/call  write/disp32
+    # discard args
+  81          0/subop/add         3/mod/direct    4/rm32/ESP    .           .             .           .           .               8/imm32           # add to ESP
+  # read(_test-stream, _test-stream-buffer)
+    # push args
+  68/push  _test-stream-buffer/imm32
+  68/push  _test-stream/imm32
+    # call
+  e8/call  read/disp32
+    # discard args
+  81          0/subop/add         3/mod/direct    4/rm32/ESP    .           .             .           .           .               8/imm32           # add to ESP
+  # check-ints-equal(EAX, 2)
+    # push args
+  68/push  "F - test-read-single: return EAX"/imm32
+  68/push  2/imm32
+  50/push-EAX
+    # call
+  e8/call  check-ints-equal/disp32
+    # discard args
+  81          0/subop/add         3/mod/direct    4/rm32/ESP    .           .             .           .           .               0xc/imm32         # add to ESP
+  # check-ints-equal(*_test-stream-buffer.data, 41/A 62/b 00 00, msg)
+    # push args
+  68/push  "F - test-read-single"/imm32
+  68/push  0x006241/imm32/Ab
+    # push *_test-stream-buffer.data
+  b8/copy-to-EAX  _test-stream-buffer/imm32
+  ff          6/subop/push        1/mod/*+disp8   0/rm32/EAX    .           .             .           .           0xc/disp8       .                 # push *(EAX+12)
+    # call
+  e8/call  check-ints-equal/disp32
+    # discard args
+  81          0/subop/add         3/mod/direct    4/rm32/ESP    .           .             .           .           .               0xc/imm32         # add to ESP
+  # end
+  c3/return
+
+test-read-is-stateful:
+  ## make two consecutive reads, check that their results are appended
+  # clear-stream(_test-stream)
+    # push args
+  68/push  _test-stream/imm32
+    # call
+  e8/call  clear-stream/disp32
+    # discard args
+  81          0/subop/add         3/mod/direct    4/rm32/ESP    .           .             .           .           .               4/imm32           # add to ESP
+  # clear-stream(_test-stream-buffer)
+    # push args
+  68/push  _test-stream-buffer/imm32
+    # call
+  e8/call  clear-stream/disp32
+    # discard args
+  81          0/subop/add         3/mod/direct    4/rm32/ESP    .           .             .           .           .               4/imm32           # add to ESP
+  # write(_test-stream, "C")
+    # push args
+  68/push  "C"/imm32
+  68/push  _test-stream/imm32
+    # call
+  e8/call  write/disp32
+    # discard args
+  81          0/subop/add         3/mod/direct    4/rm32/ESP    .           .             .           .           .               8/imm32           # add to ESP
+  # read(_test-stream, _test-stream-buffer)
+    # push args
+  68/push  _test-stream-buffer/imm32
+  68/push  _test-stream/imm32
+    # call
+  e8/call  read/disp32
+    # discard args
+  81          0/subop/add         3/mod/direct    4/rm32/ESP    .           .             .           .           .               8/imm32           # add to ESP
+  # write(_test-stream, "D")
+    # push args
+  68/push  "D"/imm32
+  68/push  _test-stream/imm32
+    # call
+  e8/call  write/disp32
+    # discard args
+  81          0/subop/add         3/mod/direct    4/rm32/ESP    .           .             .           .           .               8/imm32           # add to ESP
+  # read(_test-stream, _test-stream-buffer)
+    # push args
+  68/push  _test-stream-buffer/imm32
+  68/push  _test-stream/imm32
+    # call
+  e8/call  read/disp32
+    # discard args
+  81          0/subop/add         3/mod/direct    4/rm32/ESP    .           .             .           .           .               8/imm32           # add to ESP
+  # check-ints-equal(*_test-stream-buffer.data, 43/C 44/D 00 00, msg)
+    # push args
+  68/push  "F - test-read-is-stateful"/imm32
+  68/push  0x00004443/imm32/C-D
+    # push *_test-stream-buffer.data
+  b8/copy-to-EAX  _test-stream-buffer/imm32
+  ff          6/subop/push        1/mod/*+disp8   0/rm32/EAX    .           .             .           .           0xc/disp8       .                 # push *(EAX+12)
+    # call
+  e8/call  check-ints-equal/disp32
+    # discard args
+  81          0/subop/add         3/mod/direct    4/rm32/ESP    .           .             .           .           .               0xc/imm32         # add to ESP
+  # end
+  c3/return
+
+test-read-returns-0-on-end-of-file:
+  ## read after hitting end-of-file, check that result is 0
+  # clear-stream(_test-stream)
+    # push args
+  68/push  _test-stream/imm32
+    # call
+  e8/call  clear-stream/disp32
+    # discard args
+  81          0/subop/add         3/mod/direct    4/rm32/ESP    .           .             .           .           .               4/imm32           # add to ESP
+  # clear-stream(_test-stream-buffer)
+    # push args
+  68/push  _test-stream-buffer/imm32
+    # call
+  e8/call  clear-stream/disp32
+    # discard args
+  81          0/subop/add         3/mod/direct    4/rm32/ESP    .           .             .           .           .               4/imm32           # add to ESP
+  # write(_test-stream, "Ab")
+    # push args
+  68/push  "Ab"/imm32
+  68/push  _test-stream/imm32
+    # call
+  e8/call  write/disp32
+    # discard args
+  81          0/subop/add         3/mod/direct    4/rm32/ESP    .           .             .           .           .               8/imm32           # add to ESP
+  ## first read gets to end-of-file
+  # read(_test-stream, _test-stream-buffer)
+    # push args
+  68/push  _test-stream-buffer/imm32
+  68/push  _test-stream/imm32
+    # call
+  e8/call  read/disp32
+    # discard args
+  81          0/subop/add         3/mod/direct    4/rm32/ESP    .           .             .           .           .               8/imm32           # add to ESP
+  ## second read
+  # read(_test-stream, _test-stream-buffer)
+    # push args
+  68/push  _test-stream-buffer/imm32
+  68/push  _test-stream/imm32
+    # call
+  e8/call  read/disp32
+    # discard args
+  81          0/subop/add         3/mod/direct    4/rm32/ESP    .           .             .           .           .               8/imm32           # add to ESP
+  # check-ints-equal(EAX, 0)
+    # push args
+  68/push  "F - test-read-returns-0-on-end-of-file"/imm32
+  68/push  0/imm32
+  50/push-EAX
+    # call
+  e8/call  check-ints-equal/disp32
+    # discard args
+  81          0/subop/add         3/mod/direct    4/rm32/ESP    .           .             .           .           .               0xc/imm32         # add to ESP
+  # end
+  c3/return
+
+== data
+
+_test-stream-buffer:
+  # current write index
+  00 00 00 00
+  # current read index
+  00 00 00 00
+  # length (= 8)
+  08 00 00 00
+  # data
+  00 00 00 00 00 00 00 00  # 8 bytes
diff --git a/subx/apps/crenshaw2-1 b/subx/apps/crenshaw2-1
index 18a107adf70c90723e37af56cc0d21d8fe76dac7..a34a0eef409907db83c7288f02011591f63baaef 100755
GIT binary patch
literal 4171
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
VFB0>0=vv2im3mB4oFa;3*?(oK+_eAz

delta 1316
zcmZ8hT}TvB7`^W9=*;X)Erk@7Vc3dAD*YG{{UEzRA=N4wq=n=|O!}~fLedZGA{m<%
z+Knh8d+fn}Xd_tgA<*qfq?dxgdWzr*k-bDk=JcJr&D^zxIrq-_&OP`0zI$h<E3<1x
z;?b<m7#@w$FTz*}4b_HxOd3rq#F#aDc5R^F7#*rg4HD({MJ*90VLDF>8NEg%wbiGb
zo1UyfaY>Ie6h||x*TpWHWWJo55|d?&4OjG$HizKMKx^i6qIozTwSK(65$8?8lgsW?
z&<S8=Pe?rCFM}H+lc0!U4i<@CJ{PR2`BX|)_EM|#r6_XNFP9@_x%Dl+BUD{-owtXM
zq)@S#a9uZ@r@EOl2VY4Zmn7CY^B@~L8OtH!_E_Q~buXQ_C^%J6_bUtC^ek2?3)?3b
z7qOZ2U12toG!`#1u2RNgoaRf)ad2M34q|U)o6&X~Jf+0~NrUILj?}*YirIoqC3#R~
zvJGTor^#}NpqN$U<rO2<Ma4Av7Mik1_~bWLOsjbq#h7u^H-05EEp$m5SE?>0eUB%~
zqZcF<hTQmk>4iX_!Mn>2rAENtCJ<Sb#a)m%{e*Zxm&2<d4|*EfA*Fo-62=K}u1M>G
zE)A2mO=)d<|L1$4pj}4`r<{85J0Y%9;=N&hRNu3qg<6@3g(fiO+DJY#&@ONHX>!2r
z=8yHBSP~9hIHY0a(5tp<plZA_#(iyv(q_ZF!zfREMXVb>+g0ql^7%*!cs@0jr!7<3
zdXOZdc04cAcKX^`btY$&_DVrpXvaNY{7i`-T70=#Uia3I4XW4&WmH?VX~gC&W<#LX
z<{5MIYW!!&PhG5+8hj_NM*W*M_cver>AGV47r`7r`%Mr7+yPu&Ab1LR2Uq~i{vilZ
e4q_7^0XPpB1H9&4;YvOhKEX$<V=r_&7W@krXR%ZO

diff --git a/subx/apps/factorial b/subx/apps/factorial
index c59587653daa809e993b6ad20a886d0e9aee66a0..07be8565da921a24260a303391384b8928b5d9f9 100755
GIT binary patch
literal 4188
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

delta 1259
zcmZ8hO-NKx7`@KCac1tD7ea{{r6X!YkehH(s41iU5XmgWg%xT+yhV%2iln5ODJK{w
zLcI_a1PT3MKV-ETuqYad770PvCWD}ayC`T^S^E0UefsXuz&r2F`OZD}eBb+-j}|tJ
zw)edWF@__+=vT&A37wk4>fm(dL4z?Ir7QL9LVBoPsm^b)uaLkwRUeWLEl<yo4QqzM
zX-l@zpIl%hJa((E`YOrnLE__bXAr^&T^Hmly3TDH35(tSfi(}H@e%JN40%_)_ScoY
z2Sp6C;VDmwMSpGR3kAtpw5Z;wE*Tdc#^#dC;<(Y7L|8fPI8J(o;xc;?s}<R;NQAQ)
zC$jAbV|i4ZL`0rb$yFd%J*X`zp;i`awMCUjE-zy<<y*_!NE&M|GOpFe@;+T7G~;=+
zGMln7YH9f~45ZBl;$blwi1{*MF&F4fcKz2(Gd5M^UY#W7Hp5vS6*N;pUMtge)kV!5
z@+<<{qTeHb=w^=b189b~bI<sNO6pEY#fa)Dr96*^+G7|bHHK{C!LvTPVMD=v$qCT6
z3FH$UViF|g5|=mV30Q4l4)i><m$ddXNchI(i6U*8NpuB)?9tjPkgjistKCQo3wA5`
zJrFl&ai=NzLQOR`O)?uZrg6^qkbE|EF#GLrLH3h_dRU)_60sB<Qn*Js?J%sjYouLQ
z+j!<_d$qP;ibS|P>7bT|&vsoajd-y?QGivS9iWvqsI{#iNkrp#T%<keX+P>)az<-2
zuGSsLJx}~di>D$Y%F7!TyxK)w`>u_)6>VB$iKD#H*J6q5eCzrQb*0{CS*0|1O&t0j
zh<U!N+xq1=G6T5to8T*e{UK-pi~%nEC71-f1N;PhSRz;g)KMC_A20y826!n_W>id>
VhPY|26K~BXF%ju{T4}}n{{WCFp)LRb