simplicio-prompt 0.1.0

package/benchmarks/prompt_vs_normal.py

@@ -0,0 +1,431 @@
+"""Benchmark normal instruction flow vs the Yool runtime prompt flow.
+
+This does not call a hosted LLM. It measures the operational behavior that the
+prompt requires from an executor:
+
+- normal instruction: flat planning + sequential execution;
+- yool prompt: lazy batch_spawn + lane worker fan-out + tuple receipts.
+"""
+
+from __future__ import annotations
+
+import argparse
+import math
+import hashlib
+import json
+import statistics
+import sys
+import time
+import tracemalloc
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any, Callable
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+
+from kernel.yool_tuple_kernel import (  # noqa: E402
+    LaneWorkerPool,
+    RuntimePolicy,
+    TupleSpace,
+    YoolTuple,
+    build_default_space,
+)
+
+YOOL_PROMPT = """Use o repo canonico https://github.com/wesleysimplicio/simplicio-prompt.
+Leia antes de editar: YOOL_TUPLE_HAMT.md, kernel/yool_tuple_kernel.py,
+guardrails/cpu_throttle.py, guardrails/disk_gc.py, examples/python/receipts.py
+e scripts/build_hamt.py.
+
+Ao receber "Implement X": decomponha em grafo Hilbert-indexed, crie tuple raiz,
+use batch_spawn(depth, branching, compression_threshold) para 1.000.000+
+subagents sem enumerar, execute work ativo com spawn_agent, roteie por out/in/rd,
+route_packet e scan_index, aplique hookwall, compress_token e prune_idle, e use
+LaneWorkerPool respeitando YOOL_TUPLE_* env vars.
+
+Execute:
+python kernel/yool_tuple_kernel.py
+
+Responda SEMPRE exatamente neste formato (sem variações):
+[Tuple Space Snapshot]
+[Active Agents/Subagents]
+[Total Agents/Subagents]
+[Próximo Yool a executar]
+[Resultado parcial]"""
+
+NORMAL_INSTRUCTION = (
+    "Implement X quickly. Use agents if useful. Report the result when finished."
+)
+NORMAL_REPEATED_CONTEXT = (
+    NORMAL_INSTRUCTION
+    + "\nSubagent {index}: carry the orchestration rules, task goal, route, status, "
+    "and result summary in chat context."
+)
+YOOL_TUPLE_ENVELOPE = (
+    '{"yool":"prompt_worker","lane":"benchmark","args":{"index":0},'
+    '"receipts":[],"route":"tuple-space"}'
+)
+YOOL_BATCH_ENVELOPE = (
+    "batch_spawn(depth=4, branching=32, compression_threshold=1024, "
+    "virtual_agents=1048576)"
+)
+
+
+@dataclass
+class BenchmarkResult:
+    profile: str
+    phase: str
+    tasks: int
+    wall_ms: float
+    peak_kb: float
+    active_agents: int
+    compressed_agents: int
+    virtual_agents: int
+    total_agents: int
+    receipts: int
+    notes: str = ""
+
+    @property
+    def throughput_tasks_s(self) -> float:
+        if self.wall_ms <= 0:
+            return 0.0
+        return self.tasks / (self.wall_ms / 1000)
+
+    def to_dict(self) -> dict[str, Any]:
+        data = asdict(self)
+        data["throughput_tasks_s"] = self.throughput_tasks_s
+        return data
+
+
+@dataclass
+class TokenModelResult:
+    scenario: str
+    normal_tokens: int
+    yool_tokens: int
+    savings_tokens: int
+    savings_pct: float
+    notes: str
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+def measure(fn: Callable[[], BenchmarkResult]) -> BenchmarkResult:
+    tracemalloc.start()
+    try:
+        result = fn()
+        _current, peak = tracemalloc.get_traced_memory()
+        result.peak_kb = peak / 1024
+        return result
+    finally:
+        tracemalloc.stop()
+
+
+def simulated_yool_work(index: int, sleep_ms: float) -> str:
+    if sleep_ms > 0:
+        time.sleep(sleep_ms / 1000)
+    payload = f"task:{index}".encode("utf-8")
+    return hashlib.blake2b(payload, digest_size=8).hexdigest()
+
+
+def estimate_tokens(text: str) -> int:
+    """Deterministic rough estimate: about four UTF-8 chars per token."""
+    return max(1, math.ceil(len(text.encode("utf-8")) / 4))
+
+
+def normal_flat_scale(total_agents: int) -> BenchmarkResult:
+    def run() -> BenchmarkResult:
+        t0 = time.perf_counter()
+        agents = [
+            {"id": index, "yool": "normal_worker", "lane": "flat"}
+            for index in range(total_agents)
+        ]
+        wall_ms = (time.perf_counter() - t0) * 1000
+        return BenchmarkResult(
+            profile="normal instruction",
+            phase="flat materialization",
+            tasks=total_agents,
+            wall_ms=wall_ms,
+            peak_kb=0.0,
+            active_agents=len(agents),
+            compressed_agents=0,
+            virtual_agents=0,
+            total_agents=len(agents),
+            receipts=0,
+            notes="flat Python list of subagents",
+        )
+
+    return measure(run)
+
+
+def yool_lazy_scale(
+    total_agents: int, branching: int, threshold: int
+) -> BenchmarkResult:
+    depth = 1
+    virtual = branching
+    while virtual < total_agents:
+        depth += 1
+        virtual *= branching
+
+    def run() -> BenchmarkResult:
+        space, root = build_default_space()
+        t0 = time.perf_counter()
+        receipt = space.batch_spawn(
+            root,
+            "prompt_worker",
+            depth=depth,
+            branching=branching,
+            compression_threshold=threshold,
+        )
+        wall_ms = (time.perf_counter() - t0) * 1000
+        snapshot = space.snapshot()
+        return BenchmarkResult(
+            profile="yool prompt",
+            phase="lazy batch_spawn",
+            tasks=receipt.virtual_agents,
+            wall_ms=wall_ms,
+            peak_kb=0.0,
+            active_agents=snapshot["active_agents"],
+            compressed_agents=snapshot["compressed_agents"],
+            virtual_agents=snapshot["virtual_agents"],
+            total_agents=snapshot["total_agents"],
+            receipts=1,
+            notes=f"depth={depth}, branching={branching}",
+        )
+
+    return measure(run)
+
+
+def normal_sequential_execution(tasks: int, sleep_ms: float) -> BenchmarkResult:
+    def run() -> BenchmarkResult:
+        receipts = []
+        t0 = time.perf_counter()
+        for index in range(tasks):
+            receipts.append(simulated_yool_work(index, sleep_ms))
+        wall_ms = (time.perf_counter() - t0) * 1000
+        return BenchmarkResult(
+            profile="normal instruction",
+            phase="sequential execution",
+            tasks=tasks,
+            wall_ms=wall_ms,
+            peak_kb=0.0,
+            active_agents=tasks,
+            compressed_agents=0,
+            virtual_agents=0,
+            total_agents=tasks,
+            receipts=len(receipts),
+            notes="single worker, no lane fan-out",
+        )
+
+    return measure(run)
+
+
+def yool_lane_execution(
+    tasks: int, sleep_ms: float, concurrency: int, max_concurrency: int
+) -> BenchmarkResult:
+    def run() -> BenchmarkResult:
+        t0 = time.perf_counter()
+        policy = RuntimePolicy(
+            lane_concurrency=concurrency,
+            max_lane_concurrency=max_concurrency,
+            cpu_quota_pct=95,
+            queue_maxsize=8192,
+            compression_threshold=1024,
+        )
+        space = TupleSpace(policy=policy)
+        root = YoolTuple("kernel_root", (0,), "root", "runtime", "benchmark")
+        space.out_tuple(root)
+        for index in range(tasks):
+            space.spawn_agent(
+                root,
+                "prompt_worker",
+                {"index": index, "lane": "benchmark"},
+            )
+
+        def executor(tup: YoolTuple) -> str:
+            result = simulated_yool_work(int(tup.data["index"]), sleep_ms)
+            tup.receipts.append(f"ok:{result}")
+            return result
+
+        pool = LaneWorkerPool(space, policy=policy)
+        receipts = [
+            item for item in pool.run_lane("benchmark", executor) if item is not None
+        ]
+        wall_ms = (time.perf_counter() - t0) * 1000
+        snapshot = space.snapshot()
+        return BenchmarkResult(
+            profile="yool prompt",
+            phase="lane fan-out execution",
+            tasks=tasks,
+            wall_ms=wall_ms,
+            peak_kb=0.0,
+            active_agents=snapshot["active_agents"],
+            compressed_agents=snapshot["compressed_agents"],
+            virtual_agents=snapshot["virtual_agents"],
+            total_agents=snapshot["total_agents"],
+            receipts=len(receipts),
+            notes=f"lane_concurrency={concurrency}, max_lane_concurrency={max_concurrency}",
+        )
+
+    return measure(run)
+
+
+def summarise(results: list[BenchmarkResult]) -> dict[str, Any]:
+    by_phase: dict[tuple[str, str], BenchmarkResult] = {}
+    for result in results:
+        by_phase[(result.profile, result.phase)] = result
+
+    def compare(normal_phase: str, yool_phase: str) -> dict[str, Any] | None:
+        normal = by_phase.get(("normal instruction", normal_phase))
+        yool = by_phase.get(("yool prompt", yool_phase))
+        if normal is None or yool is None:
+            return None
+        return {
+            "speedup_x": normal.wall_ms / yool.wall_ms if yool.wall_ms else None,
+            "peak_memory_reduction_x": normal.peak_kb / yool.peak_kb
+            if yool.peak_kb
+            else None,
+            "normal_phase": normal_phase,
+            "yool_phase": yool_phase,
+            "normal_wall_ms": normal.wall_ms,
+            "yool_wall_ms": yool.wall_ms,
+            "normal_peak_kb": normal.peak_kb,
+            "yool_peak_kb": yool.peak_kb,
+            "normal_tasks": normal.tasks,
+            "yool_tasks": yool.tasks,
+        }
+
+    comparisons: dict[str, Any] = {}
+    scale = compare("flat materialization", "lazy batch_spawn")
+    if scale is not None:
+        comparisons["scale_representation"] = scale
+    execution = compare("sequential execution", "lane fan-out execution")
+    if execution is not None:
+        comparisons["active_execution"] = execution
+
+    return {
+        "results": [item.to_dict() for item in results],
+        "comparisons": comparisons,
+        "token_model": [item.to_dict() for item in token_model()],
+        "token_assumptions": {
+            "method": "rough local estimate using ceil(utf8_bytes / 4)",
+            "normal_instruction_tokens": estimate_tokens(NORMAL_INSTRUCTION),
+            "yool_prompt_tokens": estimate_tokens(YOOL_PROMPT),
+            "normal_repeated_context_tokens": estimate_tokens(
+                NORMAL_REPEATED_CONTEXT.format(index=0)
+            ),
+            "yool_tuple_envelope_tokens": estimate_tokens(YOOL_TUPLE_ENVELOPE),
+        },
+        "wall_ms_median": statistics.median(item.wall_ms for item in results),
+    }
+
+
+def token_model() -> list[TokenModelResult]:
+    prompt_tokens = estimate_tokens(YOOL_PROMPT)
+    normal_instruction_tokens = estimate_tokens(NORMAL_INSTRUCTION)
+    normal_repeated_tokens = estimate_tokens(NORMAL_REPEATED_CONTEXT.format(index=0))
+    tuple_tokens = estimate_tokens(YOOL_TUPLE_ENVELOPE)
+    batch_tokens = estimate_tokens(YOOL_BATCH_ENVELOPE)
+
+    scale_agents = 1_048_576
+    normal_scale = normal_instruction_tokens + normal_repeated_tokens * scale_agents
+    yool_scale = prompt_tokens + batch_tokens
+
+    active_tasks = 256
+    normal_active = normal_repeated_tokens * active_tasks
+    yool_active = prompt_tokens + tuple_tokens * active_tasks
+
+    active_large = 512
+    normal_active_large = normal_repeated_tokens * active_large
+    yool_active_large = prompt_tokens + tuple_tokens * active_large
+
+    one_off_normal = normal_instruction_tokens
+    one_off_yool = prompt_tokens
+
+    return [
+        _token_result(
+            "one_off_prompt_bootstrap",
+            one_off_normal,
+            one_off_yool,
+            "One-off call: normal instruction is cheaper, but it lacks execution protocol.",
+        ),
+        _token_result(
+            "scale_1m_subagents",
+            normal_scale,
+            yool_scale,
+            "Normal path enumerates/repeats subagent context; Yool path sends one batch_spawn envelope.",
+        ),
+        _token_result(
+            "active_256_tasks",
+            normal_active,
+            yool_active,
+            "Yool prompt is paid once; active work uses compact tuple envelopes.",
+        ),
+        _token_result(
+            "active_512_tasks",
+            normal_active_large,
+            yool_active_large,
+            "Savings grow as repeated chat-context orchestration is replaced by tuple envelopes.",
+        ),
+    ]
+
+
+def _token_result(
+    scenario: str, normal_tokens: int, yool_tokens: int, notes: str
+) -> TokenModelResult:
+    savings = normal_tokens - yool_tokens
+    savings_pct = (savings / normal_tokens * 100) if normal_tokens else 0.0
+    return TokenModelResult(
+        scenario=scenario,
+        normal_tokens=normal_tokens,
+        yool_tokens=yool_tokens,
+        savings_tokens=savings,
+        savings_pct=savings_pct,
+        notes=notes,
+    )
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--tasks", type=int, default=256)
+    parser.add_argument("--scale-agents", type=int, default=131_072)
+    parser.add_argument("--sleep-ms", type=float, default=2.0)
+    parser.add_argument("--lane-concurrency", type=int, default=32)
+    parser.add_argument("--max-lane-concurrency", type=int, default=64)
+    parser.add_argument("--compression-threshold", type=int, default=1024)
+    parser.add_argument("--json", action="store_true")
+    args = parser.parse_args()
+
+    results = [
+        normal_flat_scale(args.scale_agents),
+        yool_lazy_scale(
+            args.scale_agents, branching=32, threshold=args.compression_threshold
+        ),
+        normal_sequential_execution(args.tasks, args.sleep_ms),
+        yool_lane_execution(
+            args.tasks,
+            args.sleep_ms,
+            concurrency=args.lane_concurrency,
+            max_concurrency=args.max_lane_concurrency,
+        ),
+    ]
+    payload = summarise(results)
+
+    if args.json:
+        print(json.dumps(payload, indent=2, ensure_ascii=False))
+    else:
+        print("Prompt benchmark")
+        for item in payload["results"]:
+            print(
+                f"- {item['profile']} / {item['phase']}: "
+                f"{item['wall_ms']:.2f} ms, "
+                f"{item['throughput_tasks_s']:.1f} tasks/s, "
+                f"peak={item['peak_kb']:.1f} KiB, "
+                f"total_agents={item['total_agents']}"
+            )
+        print(json.dumps(payload["comparisons"], indent=2, ensure_ascii=False))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/benchmarks/prompt_vs_normal_benchmark.pdf

@@ -0,0 +1,124 @@
+%PDF-1.4
+%���� ReportLab Generated PDF document (opensource)
+1 0 obj
+<<
+/F1 2 0 R /F2 3 0 R /F3 4 0 R /F4 6 0 R
+>>
+endobj
+2 0 obj
+<<
+/BaseFont /Helvetica /Encoding /WinAnsiEncoding /Name /F1 /Subtype /Type1 /Type /Font
+>>
+endobj
+3 0 obj
+<<
+/BaseFont /Helvetica-Bold /Encoding /WinAnsiEncoding /Name /F2 /Subtype /Type1 /Type /Font
+>>
+endobj
+4 0 obj
+<<
+/BaseFont /Times-Roman /Encoding /WinAnsiEncoding /Name /F3 /Subtype /Type1 /Type /Font
+>>
+endobj
+5 0 obj
+<<
+/Contents 12 0 R /MediaBox [ 0 0 595.2756 841.8898 ] /Parent 11 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+6 0 obj
+<<
+/BaseFont /Courier /Encoding /WinAnsiEncoding /Name /F4 /Subtype /Type1 /Type /Font
+>>
+endobj
+7 0 obj
+<<
+/Contents 13 0 R /MediaBox [ 0 0 595.2756 841.8898 ] /Parent 11 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+8 0 obj
+<<
+/Contents 14 0 R /MediaBox [ 0 0 595.2756 841.8898 ] /Parent 11 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+9 0 obj
+<<
+/PageMode /UseNone /Pages 11 0 R /Type /Catalog
+>>
+endobj
+10 0 obj
+<<
+/Author (wesleysimplicio/simplicio-prompt) /CreationDate (D:20260521154938-03'00') /Creator (\(unspecified\)) /Keywords () /ModDate (D:20260521154938-03'00') /Producer (ReportLab PDF Library - \(opensource\)) 
+  /Subject (\(unspecified\)) /Title (Yool Prompt Benchmark) /Trapped /False
+>>
+endobj
+11 0 obj
+<<
+/Count 3 /Kids [ 5 0 R 7 0 R 8 0 R ] /Type /Pages
+>>
+endobj
+12 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 2430
+>>
+stream
+Gb"/(>E@OI&q8_F_+2!(1;&gn>6CZigU'Zg"3&+@_1<eOf?27!,KZFN^V3(WUh!\5bK2eYd:0F$o.i\Y%/J/g0gu4oB_+/c,P5f'SpX0CAS?(9W5&Hd?D-J>X*7We2cCPEBqurK[D7_,%<=-rRc3i2$8g,&'ZAUrO<JA/6H5NV&RhC[FlSB+Rf0-41A%k'esdT6=6ShA>fR`Y5-O6lS()/7ULuJ\<pR9.q[+q3U;baJH=$jBmoT9%g7r&h4mm0H.^q@Zh2WD;M;+^_"3k0*9i7a0;1<nMhV0Nd+00LsajMFdSqKnkRqCR&^>-_?YI6Gp`jL5P(h)]uaD49DXrl:CQ^CZ<h):$9OD_pL?]-7U``Y3HrkTr93k`#dol^d.r-3NH8s,<qZ)CsQqlTPOCpC:EM.c,jPZHupY%h182`?N%PsoDHl>;qj-q:[([q2#$Zkr!aY6u'-aL9iX*mdk&8Wc/)=o?<1oHp`)ec2[Er'!V07HpqB<Cr_63U#=1p)8Z!Mol)XjL94&,0oRo7<rOhQYp_#EIJ?aF&^l3VOP/cUK(1H]oTK.,qGJ?5t@Fu@1Q(oCK,3C3aGs3]8b!F)5gVk_n+.Q2u\3![>h5(BpU4u?p?qrD3ItiV[4csM],UuQRpOB(I'qGmaGb-T2g92(+#O`*sq[>(c-JAUuGJa_V,!56$$+T(XH1?62u:FquFKMYQ"D`kZdJoqT65%a-Q*X@(>rEKm2oP2CO%(4++aN_:n,88C(U\XBf^&kkEbchnRldcTAlfNMTPlm;MWiGBbFs9I<oSOul'NQKar-,5Td)@Q5Qo+TgVY703n5O`V\8aoQ/;Le8.273E]e'?1bS9^_>R`l'8/2mp$Vk3H&0<CS^&?ooA#,-2siiB0IhgfnY1+4U;#NY5<#VPQV`.Z5]n6UU$!K#Pg+7thmu\59II(8f_/LBULUE)-%:_D4^[UP4D;X9m8`/C3B>,4#qN@1[f08A!#'8X!3mXBrrt?1h<.Tb03-Q$b8:%"^_QKS*4+3J</c%Hh<6G3:e:bXJ;D(`5M?HW_'FqU$O^Z'&?!hN*HqDa.u)JEXD/jWY9Cg+hY>EFJW?9o_%^YXFj#ZEo[`/#?r=4.:4n2rQlRetO,1c-fWNY@GV!7S/,Hb`La>/pchldXi+/9F>_aF)0qkNuHZF^`%)B\d&#eH5&kQ#u0@Y)">!r&.t[8HQf536I>3ge4IJe7C7&$>f1jV6D/^6-/aQ7#"HFjBg^G6"Mlp&laVo^]EW9%bkA]rRn'm+9`b[NKC==i`P<thC06W:M%trC:@^?aq&DgB(4]nR-/h"<QSs"<DdD]Al$_DV+1>(QSZ^dAVal7"kU)4'PbhB._Y0W*aNC#dG/E/kSP]h4(p-:j'FaC4bZr&$$dR.\l*FeAM)a25mW&:&&RRb2;G[E!#r@oOSM2N!^iMr82CV<)*+m7BS33?S-iV;Yb*Md@e8F==PYGK(HpDX]m'P5UJffMJIFp]U:)N/*`*<Y2a_Xrt+&`Ch5JZaB/$.J5Nt'Q)!YCa]5BmoN/ci%td'<#A1pf%1\euXhI^7R"\p:t,_eK0RH3;Ob"46<B^ct$`W6uW8<]`Q(CVB+9$B;8&K==8/=#V*;@@/Ro]$LnA`bp#X*se_^n3"o"!M;A+=?kbOI/`<g1V?oR</@OK%,o2mSq53c_i8;]M"VY%B6XTNL!S-_`b4fjptWNfcG\mZ:'gY3T.c5N*:Api'HQ<$%/.LpTmu)@):1--'L0N!5ka<BRX.nsW%!Zl?iPCkTi0TNFeG_.2/q6uC`9\VZ5!H*;D-`FhJ1$,q/D(3$?%s-L\8iU#TEP_M8IMDR@pOT>pqPY8d1h*RRu3d<%Dq/I2JDMquITu>bbrERrD]I?ruE7m_9n_Y8+P^#e6-$([]e"OGcR2OtYGMER>nN%Mq97kn76#.',Ghh=SZP?*'[V$#dQcQqBT2!P^+XHJ2G3Z+XF[[Nk^3K@LU[m6q=sA`%>*l-hURiKT@uatYO3>nX"ak_[M3RgUk5(bK9PW%CM')5D`=.pZ.BA'Uu.g+:OOs'"lEbsCj+c!b?4J:F+J\PkXmOhlF>d6Yui83E6A9R&dHR497@h;/ZkWiKJk9Qu+>p-i$Hm:qk/HT-23Fu"qZPUl0=\[(br1Kh!gRmWM.qo;i[2e,rabEDh>&PMg"7kE=(F=^SA2DP_7p5Q9hKbN!)UD`cb*f9$]k?AS4CNLg?hCaeS)\VNWVarX@36W+I7n!o[=Hj6S&*0"h'JVJK\<fVq'&lhf6pQrM.3_HXOs7d(W@=Rj4uGcNg].0c&MWA&'G1Ho*NLn:_'PX.b$;o13arH:K$VD/%W?.Y:m*N)Qm9gcRmX.j2T7![m-!t#nES,0Yq$)q*b"!Mq_k&OLnfLN,%'ON7_XNN!s&0W\/3^6`k=&gN-euX)#&3k/af=5566;d^ru~>endstream
+endobj
+13 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 3042
+>>
+stream
+Gau0DCN%re(B'h3EA9_0Ztmj25Otp.dS:&32Uf1g*D?fmOdK5a8Q8,-M>,Wj+_<h'fQ!e;U5q_'^#XS]T$'cb9`20fs)Cg+Ako[V(0NQ?YK:eoQf_q&3^<IaA?@.@gMgFSE[_9!_`$<NHC-Ub^iom=N$rcgbJhfK[_.-jS"g%2[S:XM)G]>r1rVu(l1u-Z/>WMYh[DiJj92pS4fr706Qi+?[4*ppD61E/'uR_em:8u4T<9HCmW_&W/1k2Vr%FMRg(Li!hZt4Vl#e8pq/0'aF:?dpls;M(*:&0YRB1\A7jSQQf6@0FQ">9Jgo'/IGL*S3?DSA`(>%dk-ZR2--"k=j=_6hVr;5g$#hnbeTcLWadLtgeTAL_.N^rh)]I)`WO>FJ`5Ta_uhLG1Hk2s2,%msfm]]E=630d\I0hb)G)aZ^DIIu!3kd9;He,;d$m=\db)E$?#XJ^R"Ig3j&Ln>FX&HQYOf('MaG7-B_^pacGFeU4n.MW;7!4d\eW*jg3(Uq&M09Y.1@RWV]Z;,IA")o(C/hLu%-qeogo>BeMk'#8B%^_[NGA":0dH"BAP/M<7&e62LBp$8mQnf8[N;2*R8WABp'_=/n4T7*c2\#"dV8d0/?G870^>pfX8g.q!.rgn&JDF4oAPh\43R0XK9uV0[e5GU//eXaQ/FjFr'$%E@3X"u9e^IV721MPr<:LTe<3/h`5tmh>M:$pUSamC4ArUUCM<fVs\g]F1]X[!i.(M2.L=<U@`s30g?lVnYN(aAB%*SA"L^^nj(^k>*".V.Xr%TOq-eU$Z7nWQ$2Ockda\p@S>W.N<2%s65]O4_hp+VooB[cMWq1";P#6JXo'=imkS3RbbT_+!N:THH5p'FH+ACi'1O2P<[:f%ZDM:7BF_Bus#:Bq"KW*K`)=buD07>mkYPn:@?=Eu#S]tP4%Le9=7>NUKMoV,87Z4;Os,\rj?@J_^$.sS)^Y0.I'11+/Z68ho<)k=VE:A1,o0X3r_&ik`;m58_#52bf$idhseE4OSNa+e<rFkAG#Ec&KofUfjVRCk]DDQd\U'@5O!XPVK6g7S-F1YW;LPA$S-n)kg0)ns#Ik-H]nCZdu%cZ259'/qZ%6b[c](5*4ph@#eddlHK9-gWmKkIgTX)iA+fHsf\A\T&MO-8pY(Ol/c@cU+;nd1!b#$/Zh#i2`>dh=1W^2K(q<`98N^[)m$#6L0]K"rsp,+8W.hI15_-'soF:Q_!PSjJ-Fu;:e!T+5QkOgQ342L2XWrhV4-mDInrK[3]q)KW%XS:".1LKj:%eWJR/Eq%[D](54j+?"J]\*M\[=psu""?0[J?GMea7c[[NS$c_.#VMcA7FnN:-IW>1(j$N:<ZS?-SBXDLLf')P(S^7W_f,nuj=ZPm/m,)s_A4E8lmL4:"_C6`#e1YRe*<?AA4NB,X`F#4q3f]&T[g-9Bd"6CPkTd@u$\ht."29i&jrt^UfNj./mc*Mdr-7a])Cj?*h$Z=VG@1QN)+:7ZnADSA4,0kuf>+M-cDPMsrC8lQ+sUpYR@fS)IW<O>d8T"jT:$@s5D[7$LI1^P;\Bq]kBO-c:5RuV+.<i7FY0TkN0Nsm>F&if^?PUGPk^]=_bl!@C52HO^$GP?3o?J9e>6ILjem]+EP&+I>"tul'`D:1RQ-UE/+e:0Ps:LH(/tA(ds=SCH:$FU[(#T4?1F:>P#GO_bc3-]PGi$e"-4DW%RRB8Z,le@Y&=nSM.X&fq^%'q?<"CUbmI%:WDE.!SY@m@A8-XM12]0n0WmkX_/=@U`;8VZT&!?U1%Z%U^^^%i9R@?GHS5Zn<?k1Upe&?cMj!\mYW31gjKRBNjU9TkD>o9;Fp=oUP%>%RI9NgL-s*Oa.&OR4+]'/8;&McHkrN<3AZ;c_n^1Kbh'?^jX1*)52/6p]]iR>YBt9r-RE+U/$IXGqU7NHK(1UAF($_b@@k1O@CER3$hIqUe/Bo)`/<qF.Ns@%sYl^4`?F$TeRhZ*m#1/eq9.!VZ$.MuQ0'2g@NJ=G6A94n4+0GLU@9$36"*m4OcbE0;>JhCDd7C7HPh9h>9-J3A!VU]5,aGk2rb_O-_K,=n+c<iDg">V3;2rEqS>nNerh2^;#YB?3YpR:nDahMb-M/glE\?*0A6c)f&i.fa?`2S`T^#YQG9V$5Z%V/I5NC#2p4J!em!5p`-Rt9>_V)V8Wg%%G-1H>@3!c#t>DC6[I]PG`UuM5FC[3\?po,Qpf@=A-``,5B'\:2[YTs\SJ3:%NQj!%>O:,1O_sGkE8i-]ZUpgSi^mZ*J:t`CZ`4],gYtZfjNQ):<55u`?8n:)Th;biJNrXHk@0R3SXLdB>p,:QsFk5%!1U=$,\*qN*GoOmZni=YJToSfX)!VRS;4UluH>&DO,-4s*eZ#5Jqk<JWG:td;5(3]Ah(37)X1t6;)Re\DUe#Y.8E?8S.ZUN)?n9\N<=BUX\Qt+UckahQU$+fkl4?B&$X2,(.8OQ^)_b<6A`1eXm^^R:8u?m%V/[tsrGU.#;55@^``!)G-jV-7O5dS4K`:c=l"i*SEdi2Cq"==#\WHsuJ5X4ifa>N"BXBAF&YiT*L@oG1.[e7eZ`'4h9Qe@?&<5fdI4T8F4j4ubbi<_EY/%TeXJaBb26=t_2OJ3!>:`o`6X]DZ-"`jmpBo:Fjb$`94jVQ+IlW($MTeJnAAiQ#WS"VO?dfFHoe\6c4WH(`#JNAn0_9c=\(#-(@Wf=gaHG?qQcBCcl_QWJXGE43F@Tl@gu`W+ZK1R&.<[$<9&JjWIgp2ebn)9ca3eaE?En7N^(7T0!:EMKKNal;`XAmL;AV3GXX+GlNq=kke<5s)'aFI8<W8<9UdE+ZL%Z.t$7(/Y7s*T*^1dC17F4cF(MT%`QFT'U,IjE-r(#5Y\KWH#PoPl7&i%DM.n)jJa""WbT@;B!P@;9ck>-YEF+qrm&Q]*)(T/A$5G'Fpe4aEkAI.B-"[]oqecK]jMCNF5fqm^5Q]CNSH22Kfoq-;rkmN.Nrthb)`p0b&q:@2S^XbuF?$,<LMp+W7Z6psD.r=T8Uq(/!SZVM,WioVp6q@7^TPR!r~>endstream
+endobj
+14 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 420
+>>
+stream
+Gau0=]5GJ>']&?qB;A'Q[c><OMH%0kJ?i0Tj9>^?]UFLSr-ban>4nSh/<qgA]!(_0!2h-_Z`&D"L=nmY87Yp1`>#U(DR87]&=6"#==hlGL";\aXu,fKRMcis8:qf)@q3;PSf4c9^'e&%f79];@ZlQ,M:+M[>K^-Fk]T7O0_%4?SB31AL]fboq(u4$?t(BF85_m8X?u3U,uIYrrja%"3)'L\.44e)f:U4%DAomj/"USQE.dN8F!P?T%fRnJI2;H=n1+P$d:WhYhM_p^:Lg\RD:`T!Kt@CS8>cF+2<DOI`Abp=E,F$pLOE+]dFH4MZJDdXOeeutns;PDS$'%CCX3:(6f6Cgb0fBf]*@"3H_N"Sh&!MAU#!8*kTLTgPk*5M\MgN;EWlaA]$:d<^S$"Nnoh>c`,FO`i!lI)\i9~>endstream
+endobj
+xref
+0 15
+0000000000 65535 f 
+0000000061 00000 n 
+0000000122 00000 n 
+0000000229 00000 n 
+0000000341 00000 n 
+0000000450 00000 n 
+0000000655 00000 n 
+0000000760 00000 n 
+0000000965 00000 n 
+0000001170 00000 n 
+0000001239 00000 n 
+0000001547 00000 n 
+0000001619 00000 n 
+0000004141 00000 n 
+0000007275 00000 n 
+trailer
+<<
+/ID 
+[<8ca17f21cc76142cb58a8925493355bc><8ca17f21cc76142cb58a8925493355bc>]
+% ReportLab generated PDF document -- digest (opensource)
+
+/Info 10 0 R
+/Root 9 0 R
+/Size 15
+>>
+startxref
+7786
+%%EOF