diff --git a/docs/superpowers/specs/2026-10-16-rust-migration-lot45-outils-image-design.md b/docs/superpowers/specs/2026-10-16-rust-migration-lot45-outils-image-design.md new file mode 100644 index 0000000..0aff8aa --- /dev/null +++ b/docs/superpowers/specs/2026-10-16-rust-migration-lot45-outils-image-design.md @@ -0,0 +1,116 @@ +# Lot 45 — Outils d'image de l'agent dans la façade + +## Contexte + +Deux outils de l'agent montrent une image au modèle : + +- `see_image` charge un fichier image du disque dans la vision du + modèle ; +- `web_screenshot` photographie une page rendue par Playwright, la range + dans le dossier de la discussion et donne à l'agent la ligne markdown + qui la montre à l'utilisateur. + +La façade tient la conversation par défaut, mais ces deux outils passaient +encore par le Go (`/internal/v1/tool/exec`), qui renvoyait l'image à +relayer dans `vision_img`. + +## Le lot + +`src/imagetools.rs` porte trois fichiers Go : + +- `chat_vision_tool.go` (`see_image`) ; +- `chat_screenshot.go` (`web_screenshot`) ; +- `prepareImageForModel` (`web_upload_orient.go`). + +Ce qui est porté : + +- **la préparation de l'image**, la même que pour les pièces jointes : + - orientation EXIF d'une JPEG redressée dans les pixels ; + - grand côté ramené sous 1568 px (mêmes pixels que le Go) ; + - PNG réencodée en PNG, le reste en JPEG qualité 88 ; + - rien à faire, ou image que la bibliothèque standard du Go ne décode + pas (WebP, BMP, PNG cassée) : les octets d'origine ; +- **la sonde du moteur** (`engineSeesImages`) : + - preset externe : sa case « vision » ; + - sinon `GET /props` du moteur local, authentifié par la clé de + complétion, gardé 10 s ; + - appelée en dernier, après toutes les vérifications du fichier ; +- **`see_image`**, mêmes textes : + - vision coupée, poste distant, chemin manquant ; + - format non reconnu, fichier introuvable, dossier ; + - trop lourde (12 Mo au plus) ; + - moteur aveugle, fichier vide ; + - chemin relatif au dossier de travail de l'agent, ou absolu ; +- **`web_screenshot`**, mêmes textes : + - Playwright absent, url manquante ou invalide ; + - internet coupé : seule une adresse locale passe (`localhost`, + `127.0.0.1`, `::1`, `0.0.0.0`, `*.localhost`, casse comprise comme + le Go) ; + - mêmes arguments de Playwright (viewport, page entière, attente, + 90 s au plus) ; + - erreur résumée par ses trois dernières lignes non vides ; + - aucune image ou image vide refusée ; + - capture rangée dans `captures/` du dossier de la discussion, nommée + par l'hôte et l'heure locale ; + - ménage : 20 captures et 40 Mo au plus, la nouvelle reste ; + - relayée au modèle (« Voici la capture demandée. ») seulement si la + vision est active et que le moteur voit les images. + +`ChatShared.vision` porte la sonde du processus ; `GoTurnHost::exec_tool` +exécute les deux outils : + +- `see_image` prend le dossier de travail et le poste visé du contexte + des outils (lot 7) ; contexte indisponible : le Go prend le relais ; +- `web_screenshot` range ses captures dans le dossier de la discussion + principale, sous le dossier de travail de l'agent, et les montre par + `ToolOutcome.image`. + +Rien ne change côté Go : ces outils n'ont pas d'état partagé, et le Go +garde les siens pour ses sous-agents et ses tâches IA. + +## Écarts connus + +- Encodeurs PNG et JPEG : mêmes pixels, octets différents. + +## Parité + +`internal/loki/parity_image_tools_test.go` (Linux) tire du Go un journal +(`tests/parity_images/images.json`) avec ses fichiers (en base64), un faux +moteur (`/props` authentifié, vision réglée par étape, sondes comptées) et +un faux Playwright (script qui note ses arguments et produit l'image, rien, +un fichier vide ou une erreur). + +Chaque étape porte : + +- le résultat, avec le texte relayé au modèle ; +- l'image relayée : + - identique à un fichier : son nom ; + - réencodée : son type et ses dimensions ; + - en PNG : cinq pixels ; +- la capture montrée, les arguments de Playwright, le nombre de sondes ; +- le dossier des captures. + +Le journal couvre : + +- `see_image` : + - vision coupée ; + - chemin vide, pas une image, introuvable, dossier, trop lourde ; + - moteur aveugle, fichier vide ; + - onze images : PNG, JPEG, GIF, WebP, BMP, PNG cassée, JPEG tournée, + grandes images réduites en largeur et en hauteur, sous-dossier, + chemin absolu ; +- `web_screenshot` : + - url manquante ou invalide, internet coupé ; + - capture locale sans vision, capture vue par le modèle ; + - page entière réduite ; + - vision mais moteur aveugle ; + - Playwright en échec, image vide, aucune image ; + - ménage des captures. + +`tests/imagetools.rs` le rejoue contre le port. D'autres tests +complètent : + +- `tests/lot6.rs` (`outils_image_par_la_facade`) : un tour de la façade + appelle les deux outils sans passer par le Go ; +- tests unitaires : types d'image, noms de capture, adresses locales, + dernières lignes, préparation, ménage, refus avant Playwright. diff --git a/internal/loki/parity_image_tools_test.go b/internal/loki/parity_image_tools_test.go new file mode 100644 index 0000000..b71d48d --- /dev/null +++ b/internal/loki/parity_image_tools_test.go @@ -0,0 +1,344 @@ +//go:build linux + +package loki + +import ( + "bytes" + "crypto/sha256" + "encoding/base64" + "encoding/hex" + "encoding/json" + "fmt" + "image" + "image/color" + "image/jpeg" + "image/png" + "net/http" + "net/http/httptest" + "os" + "path/filepath" + "regexp" + "sort" + "strings" + "sync" + "testing" + "time" +) + +// parity_image_tools_test.go — journal de référence des outils d'image de +// l'agent (lot 45 de la migration Rust) : see_image et web_screenshot, avec la +// préparation des images (orientation EXIF, grand côté sous 1568 px) et la +// sonde « le moteur voit-il les images » (faux /props). +// +// Une image laissée telle quelle est comparée à l'octet (empreinte) ; une +// image réencodée, par ses dimensions et son type (l'encodeur diffère), et +// une PNG réduite par quelques pixels (même réduction des deux côtés). +// web_screenshot passe par un faux Playwright qui range ses arguments et +// écrit l'image demandée par le scénario. Rangé dans +// rust/loki-rs/tests/parity_images/images.json ; tests/imagetools.rs le +// rejoue contre le port. +// +// LOKI_PARITY_UPDATE=1 go test ./internal/loki -run TestPariteOutilsImage + +const parityImagesFile = "../../rust/loki-rs/tests/parity_images/images.json" + +// parityFakePlaywright : écrit le fichier « image » de son dossier à la +// place de la capture (dernier argument), ou échoue selon « mode ». +const parityFakePlaywright = `#!/bin/sh +d=$(dirname "$0") +printf '%s\n' "$@" > "$d/args" +for a in "$@"; do out="$a"; done +mode=$(cat "$d/mode" 2>/dev/null) +case "$mode" in + echec) echo "Launching chromium" ; echo "" ; echo "page.goto: net::ERR_NAME_NOT_RESOLVED at https://x" >&2 ; echo "Call log:" >&2 ; echo " - navigating" >&2 ; exit 1 ;; + vide) : > "$out" ;; + rien) ;; + *) cat "$d/image" > "$out" ;; +esac +` + +type parityImageStep struct { + Name string `json:"name"` + Vision bool `json:"vision,omitempty"` + Sees bool `json:"sees,omitempty"` // le faux /props annonce la vision + Mode string `json:"mode,omitempty"` // faux Playwright + Image string `json:"image,omitempty"` // fichier rendu par le faux Playwright + Internet bool `json:"internet,omitempty"` + Tool string `json:"tool"` + Args map[string]any `json:"args"` + Label string `json:"label"` + Result string `json:"result"` + Part map[string]any `json:"part,omitempty"` // image relayée + Shown string `json:"shown,omitempty"` // web_screenshot : la capture montrée dans le fil + PWArgs []string `json:"pw_args,omitempty"` + Probes int `json:"probes"` + Captures []string `json:"captures,omitempty"` +} + +var parityImgStampRe = regexp.MustCompile(`[0-9]{8}-[0-9]{6}`) + +// parityImageFiles : les images du dossier de travail. +func parityImageFiles() map[string][]byte { + grad := func(w, h int) *image.NRGBA { + img := image.NewNRGBA(image.Rect(0, 0, w, h)) + for y := 0; y < h; y++ { + for x := 0; x < w; x++ { + img.SetNRGBA(x, y, color.NRGBA{R: uint8(x * 255 / w), G: uint8(y * 255 / h), B: uint8((x + y) % 256), A: 255}) + } + } + return img + } + enc := func(img image.Image, kind string) []byte { + var b bytes.Buffer + if kind == "png" { + _ = png.Encode(&b, img) + } else { + _ = jpeg.Encode(&b, img, &jpeg.Options{Quality: 90}) + } + return b.Bytes() + } + // JPEG avec un tag EXIF Orientation=6 (photo de téléphone tenue debout). + withExif := func(j []byte, orient byte) []byte { + tiff := []byte{'M', 'M', 0, 0x2A, 0, 0, 0, 8, 0, 1, 0x01, 0x12, 0, 3, 0, 0, 0, 1, 0, orient, 0, 0, 0, 0, 0, 0} + payload := append([]byte("Exif\x00\x00"), tiff...) + seg := []byte{0xFF, 0xE1, byte((len(payload) + 2) >> 8), byte(len(payload) + 2)} + seg = append(seg, payload...) + return append(append(append([]byte{}, j[:2]...), seg...), j[2:]...) + } + return map[string][]byte{ + "petite.png": enc(grad(10, 8), "png"), + "grande.png": enc(grad(2000, 1000), "png"), + "haute.png": enc(grad(300, 1700), "png"), + "photo.jpg": enc(grad(40, 20), "jpeg"), + "tournee.jpg": withExif(enc(grad(40, 20), "jpeg"), 6), + "grande.jpeg": enc(grad(1800, 900), "jpeg"), + "anim.gif": []byte("GIF89a\x01\x00\x01\x00\x80\x00\x00\x00\x00\x00\xff\xff\xff!\xf9\x04\x01\x00\x00\x00\x00,\x00\x00\x00\x00\x01\x00\x01\x00\x00\x02\x02D\x01\x00;"), + "image.webp": []byte("RIFF\x10\x00\x00\x00WEBPVP8 faux"), + "image.BMP": []byte("BM pas vraiment une image"), + "cassee.png": []byte("\x89PNG\r\n\x1a\nabîmé"), + "texte.txt": []byte("pas une image"), + "vide.png": {}, + "capture.jpg": enc(grad(1280, 800), "jpeg"), + "pleine.jpg": enc(grad(1280, 3000), "jpeg"), + "capture.png": enc(grad(64, 40), "png"), + "sous/tres.png": enc(grad(3, 3), "png"), + } +} + +// parityPartFacts : ce qu'on compare d'une image relayée. +func parityPartFacts(t *testing.T, part map[string]any, raw map[string][]byte) map[string]any { + u, _ := part["image_url"].(map[string]any)["url"].(string) + i := strings.Index(u, ";base64,") + mime := strings.TrimPrefix(u[:i], "data:") + b, err := base64.StdEncoding.DecodeString(u[i+8:]) + if err != nil { + t.Fatal(err) + } + out := map[string]any{"mime": mime} + for name, r := range raw { + if bytes.Equal(r, b) { + out["same_as"] = name // laissée telle quelle : à l'octet + return out + } + } + img, _, err := image.Decode(bytes.NewReader(b)) + if err != nil { + h := sha256.Sum256(b) + out["sha"] = hex.EncodeToString(h[:8]) + return out + } + bd := img.Bounds() + out["w"], out["h"] = bd.Dx(), bd.Dy() + if mime == "image/png" { + px := map[string]string{} + for _, p := range [][2]int{{0, 0}, {1, 1}, {100, 50}, {bd.Dx() - 1, bd.Dy() - 1}, {bd.Dx() / 2, bd.Dy() / 3}} { + c := color.NRGBAModel.Convert(img.At(p[0], p[1])).(color.NRGBA) + px[fmt.Sprintf("%d,%d", p[0], p[1])] = fmt.Sprintf("%d,%d,%d,%d", c.R, c.G, c.B, c.A) + } + out["px"] = px + } + return out +} + +func TestPariteOutilsImage(t *testing.T) { + testHome(t) + root := t.TempDir() + files := filepath.Join(root, "fichiers") + raw := parityImageFiles() + for name, b := range raw { + p := filepath.Join(files, name) + _ = os.MkdirAll(filepath.Dir(p), 0o755) + if err := os.WriteFile(p, b, 0o644); err != nil { + t.Fatal(err) + } + } + _ = os.MkdirAll(filepath.Join(files, "dossier.png"), 0o755) + lourd, _ := os.Create(filepath.Join(files, "lourd.png")) + _ = lourd.Truncate(13 << 20) + lourd.Close() + setTaskWorkspace(files) + t.Cleanup(func() { setTaskWorkspace("") }) + + // Faux moteur : /props, authentifié. + var mu sync.Mutex + sees, probes := false, 0 + eng := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + mu.Lock() + defer mu.Unlock() + if r.URL.Path != "/props" || r.Header.Get("Authorization") != "Bearer cle-moteur" { + w.WriteHeader(401) + return + } + probes++ + _ = json.NewEncoder(w).Encode(map[string]any{"modalities": map[string]any{"vision": sees}}) + })) + defer eng.Close() + _ = SetConfigKey("PORT", strings.TrimPrefix(eng.URL, "http://127.0.0.1:")) + _ = putStr(bkState, "api_key", "cle-moteur") + + // Faux Playwright, seul « playwright » du PATH. + pwDir := t.TempDir() + if err := os.WriteFile(filepath.Join(pwDir, "playwright"), []byte(parityFakePlaywright), 0o755); err != nil { + t.Fatal(err) + } + t.Setenv("PATH", pwDir+string(os.PathListSeparator)+os.Getenv("PATH")) + conv := convEnsureActive() + capDir, _ := captureDirFor(conv) + + var steps []parityImageStep + run := func(st parityImageStep) { + if st.Vision { + _ = SetConfigKey("MMPROJ", "vision.gguf") + } else { + _ = SetConfigKey("MMPROJ", "") + } + mu.Lock() + sees, probes = st.Sees, 0 + mu.Unlock() + visionProbeMu.Lock() + visionProbeAt = time.Time{} + visionProbeMu.Unlock() + _ = os.WriteFile(filepath.Join(pwDir, "mode"), []byte(st.Mode), 0o644) + if st.Image != "" { + _ = os.WriteFile(filepath.Join(pwDir, "image"), raw[st.Image], 0o644) + } + _ = os.Remove(filepath.Join(pwDir, "args")) + args := map[string]any{} + b, _ := json.Marshal(st.Args) + _ = json.Unmarshal([]byte(strings.ReplaceAll(string(b), "{{FICHIERS}}", files)), &args) + label := toolCallLabel(st.Tool, args) + st.Label = strings.ReplaceAll(label, files, "{{FICHIERS}}") + res := execTool(t.Context(), st.Tool, args, label, Caps{Agent: true, Internet: st.Internet}) + image, _, relay := toolStepExtras(st.Tool, label, res) + st.Result = strings.ReplaceAll(parityImgStampRe.ReplaceAllString(res.Result, "{{T}}"), files, "{{FICHIERS}}") + st.Shown = parityImgStampRe.ReplaceAllString(image, "{{T}}") + var part map[string]any + if relay != nil { + parts, _ := json.Marshal(relay.Content) + var ps []map[string]any + _ = json.Unmarshal(parts, &ps) + for _, p := range ps { + if p["type"] == "image_url" { + part = p + } + if p["type"] == "text" { + st.Result += "\n[relais] " + strings.ReplaceAll(fmt.Sprint(p["text"]), files, "{{FICHIERS}}") + } + } + } + if part != nil { + st.Part = parityPartFacts(t, part, raw) + } + if b, err := os.ReadFile(filepath.Join(pwDir, "args")); err == nil { + for _, l := range strings.Split(strings.TrimRight(string(b), "\n"), "\n") { + st.PWArgs = append(st.PWArgs, parityImgStampRe.ReplaceAllString(strings.ReplaceAll(l, capDir, "{{CAPTURES}}"), "{{T}}")) + } + } + mu.Lock() + st.Probes = probes + mu.Unlock() + if st.Tool == "web_screenshot" { + entries, _ := os.ReadDir(capDir) + st.Captures = []string{} + for _, e := range entries { + st.Captures = append(st.Captures, parityImgStampRe.ReplaceAllString(e.Name(), "{{T}}")) + } + sort.Strings(st.Captures) + } + if st.Args == nil { + st.Args = map[string]any{} + } + steps = append(steps, st) + } + a := func(kv ...any) map[string]any { + m := map[string]any{} + for i := 0; i+1 < len(kv); i += 2 { + m[kv[i].(string)] = kv[i+1] + } + return m + } + + // see_image. + run(parityImageStep{Name: "sans vision", Tool: "see_image", Args: a("file", "petite.png")}) + run(parityImageStep{Name: "chemin manquant", Vision: true, Tool: "see_image", Args: a("file", " ")}) + run(parityImageStep{Name: "pas une image", Vision: true, Tool: "see_image", Args: a("file", "texte.txt")}) + run(parityImageStep{Name: "introuvable", Vision: true, Tool: "see_image", Args: a("file", "absente.png")}) + run(parityImageStep{Name: "dossier", Vision: true, Tool: "see_image", Args: a("file", "dossier.png")}) + run(parityImageStep{Name: "trop lourde", Vision: true, Tool: "see_image", Args: a("file", "lourd.png")}) + run(parityImageStep{Name: "le moteur ne voit pas", Vision: true, Tool: "see_image", Args: a("file", "petite.png")}) + run(parityImageStep{Name: "vide", Vision: true, Sees: true, Tool: "see_image", Args: a("file", "vide.png")}) + for _, f := range []string{"petite.png", "grande.png", "haute.png", "photo.jpg", "tournee.jpg", "grande.jpeg", "anim.gif", "image.webp", "image.BMP", "cassee.png", "sous/tres.png"} { + run(parityImageStep{Name: "voir " + f, Vision: true, Sees: true, Tool: "see_image", Args: a("file", f)}) + } + run(parityImageStep{Name: "chemin absolu", Vision: true, Sees: true, Tool: "see_image", Args: a("file", "{{FICHIERS}}/petite.png")}) + + // web_screenshot. + run(parityImageStep{Name: "capture sans url", Tool: "web_screenshot", Args: a()}) + run(parityImageStep{Name: "url invalide", Tool: "web_screenshot", Args: a("url", "ftp://x")}) + run(parityImageStep{Name: "internet coupé", Tool: "web_screenshot", Args: a("url", "https://exemple.test/")}) + run(parityImageStep{Name: "capture locale sans vision", Image: "capture.jpg", Tool: "web_screenshot", Args: a("url", "http://localhost:3000/app?x=1")}) + run(parityImageStep{Name: "capture vue par le modèle", Vision: true, Sees: true, Internet: true, Image: "capture.jpg", + Tool: "web_screenshot", Args: a("url", "https://www.exemple.test/page#ancre", "width", 1600.0)}) + run(parityImageStep{Name: "page entière réduite", Vision: true, Sees: true, Internet: true, Image: "pleine.jpg", + Tool: "web_screenshot", Args: a("url", "https://pleine.test/", "full_page", true, "width", 100.0)}) + run(parityImageStep{Name: "vision mais moteur aveugle", Vision: true, Internet: true, Image: "capture.png", + Tool: "web_screenshot", Args: a("url", "https://aveugle.test/")}) + run(parityImageStep{Name: "Playwright en échec", Internet: true, Mode: "echec", Tool: "web_screenshot", Args: a("url", "https://x.test/")}) + run(parityImageStep{Name: "image vide", Internet: true, Mode: "vide", Tool: "web_screenshot", Args: a("url", "https://vide.test/")}) + run(parityImageStep{Name: "aucune image", Internet: true, Mode: "rien", Tool: "web_screenshot", Args: a("url", "https://rien.test/")}) + // Ménage : 22 vieilles captures, plus la nouvelle → 20. + old := time.Now().Add(-time.Hour) + for i := 0; i < 22; i++ { + p := filepath.Join(capDir, fmt.Sprintf("vieille-%02d.jpg", i)) + _ = os.WriteFile(p, []byte("x"), 0o644) + mt := old.Add(time.Duration(i) * time.Second) + _ = os.Chtimes(p, mt, mt) + } + run(parityImageStep{Name: "ménage des captures", Internet: true, Image: "capture.png", Tool: "web_screenshot", Args: a("url", "http://127.0.0.1:8080/")}) + + var buf bytes.Buffer + enc := json.NewEncoder(&buf) + enc.SetEscapeHTML(false) + enc.SetIndent("", " ") + if err := enc.Encode(map[string]any{"files": raw, "steps": steps}); err != nil { + t.Fatal(err) + } + got := buf.Bytes() + if os.Getenv("LOKI_PARITY_UPDATE") == "1" { + if err := os.MkdirAll(filepath.Dir(parityImagesFile), 0o755); err != nil { + t.Fatal(err) + } + if err := os.WriteFile(parityImagesFile, got, 0o644); err != nil { + t.Fatal(err) + } + return + } + want, err := os.ReadFile(parityImagesFile) + if err != nil { + t.Fatalf("journal de référence absent (%v) : LOKI_PARITY_UPDATE=1 pour le créer", err) + } + if !bytes.Equal(got, want) { + t.Errorf("les outils d'image ne produisent plus le journal rangé dans %s.\n"+ + "LOKI_PARITY_UPDATE=1 pour le régénérer si le changement est voulu.", parityImagesFile) + } +} diff --git a/rust/loki-rs/src/chat/generate.rs b/rust/loki-rs/src/chat/generate.rs index 5a84078..4ef9a23 100644 --- a/rust/loki-rs/src/chat/generate.rs +++ b/rust/loki-rs/src/chat/generate.rs @@ -1325,6 +1325,7 @@ impl ChatShared { web: Default::default(), jobs: crate::tools::jobs::global(), browser: crate::browser::global(), + vision: Default::default(), go_version: Default::default(), } } diff --git a/rust/loki-rs/src/chat/host.rs b/rust/loki-rs/src/chat/host.rs index dd1c1f1..5ff33ef 100644 --- a/rust/loki-rs/src/chat/host.rs +++ b/rust/loki-rs/src/chat/host.rs @@ -358,6 +358,8 @@ pub struct ChatShared { pub jobs: Arc, /// Le navigateur piloté (lot 44). pub browser: Arc, + /// La sonde « le moteur voit-il les images » (lot 45). + pub vision: Arc, /// La version du Go, annoncée aux serveurs MCP à une reconnexion ; lue /// une fois. pub go_version: tokio::sync::OnceCell, @@ -716,6 +718,74 @@ impl TurnHost for GoTurnHost { ..Default::default() }; } + // Outils d'image (lot 45) : see_image dans le dossier de la + // discussion, web_screenshot par Playwright ; l'image relayée au + // modèle s'il la voit. + if name == "see_image" || name == "web_screenshot" { + let cfg = self.shared.store.config().await; + let vision = crate::system::vision_enabled(&cfg); + if name == "see_image" { + let st = crate::tools::GoToolState { + store: self.shared.store.clone(), + caps: self.caps.clone(), + }; + match crate::tools::ToolState::context(&st).await { + Ok(ctx) => { + let sees = self.shared.vision.sees(&self.shared.store, &cfg); + let (result, img) = crate::imagetools::see_image( + label, + &ctx.cwd, + &ctx.target, + vision, + sees, + ) + .await; + return ToolOutcome { + result, + relay: img.map(|i| see_image_message(label, i)), + ..Default::default() + }; + } + Err(e) => { + eprintln!("[outils] contexte indisponible, see_image par le Go : {e}") + } + } + } else { + let home = self.shared.images.home(); + let ws = tokio::task::spawn_blocking(move || { + let env = std::env::var(crate::paths::WORKSPACE_ENV).ok(); + crate::paths::agent_workspace(&home, env.as_deref()) + }) + .await + .unwrap_or_default(); + let conv_dir = crate::convfiles::conv_dir(&ws, &self.compact.main_conv); + let internet = self.caps.get("Internet").and_then(Value::as_bool) == Some(true); + let pw = crate::paths::look_path("playwright").unwrap_or_default(); + let shot = crate::imagetools::web_screenshot( + args, + &pw, + Path::new(&conv_dir), + internet, + &crate::imagetools::local_stamp(), + ) + .await; + let relay = if !shot.rel.is_empty() + && vision + && self.shared.vision.sees(&self.shared.store, &cfg).await + { + crate::imagetools::screenshot_message(&shot.abs) + .and_then(|m| serde_json::from_value::(m).ok()) + } else { + None + }; + return ToolOutcome { + result: shot.result, + image: shot.rel, + relay, + ..Default::default() + }; + } + } // Navigateur piloté (lot 44) : la session est ici ; aperçu de la page // après une action qui la change (jamais après une erreur), capture // relayée au modèle. diff --git a/rust/loki-rs/src/convfiles.rs b/rust/loki-rs/src/convfiles.rs index 1cd8608..f7b492c 100644 --- a/rust/loki-rs/src/convfiles.rs +++ b/rust/loki-rs/src/convfiles.rs @@ -145,6 +145,17 @@ fn safe_conv_id(id: &str) -> String { id.to_string() } +/// `convDirFor` : le dossier d'une discussion sous la racine de travail (la +/// racine elle-même pour un identifiant douteux). +pub fn conv_dir(root: &str, id: &str) -> String { + let id = safe_conv_id(id); + if id.is_empty() { + root.to_string() + } else { + go_join(&[root, CONV_FILES_ROOT, &id]) + } +} + /// `exifOrientation` : le tag Orientation (1..8) d'un JPEG, 0 sinon. pub fn exif_orientation(b: &[u8]) -> i32 { if b.len() < 4 || b[0] != 0xFF || b[1] != 0xD8 { diff --git a/rust/loki-rs/src/imagetools.rs b/rust/loki-rs/src/imagetools.rs new file mode 100644 index 0000000..837e5ed --- /dev/null +++ b/rust/loki-rs/src/imagetools.rs @@ -0,0 +1,456 @@ +//! Outils d'image de l'agent (lot 45) — port de `chat_vision_tool.go` +//! (`see_image`), de `chat_screenshot.go` (`web_screenshot`, Playwright) et +//! de `prepareImageForModel` (`web_upload_orient.go`). +//! +//! `see_image` charge une image du disque dans la vision du modèle ; +//! `web_screenshot` photographie une page rendue par Playwright, la range +//! dans le dossier de la discussion et la montre au modèle s'il voit les +//! images. Les deux passent par la même préparation que les pièces jointes : +//! orientation EXIF redressée, grand côté ramené sous 1568 px (mêmes pixels +//! que le Go ; l'encodeur, lui, diffère). + +use std::path::{Path, PathBuf}; +use std::time::{Duration, Instant, SystemTime}; + +use base64::Engine as _; +use serde_json::{Map, Value, json}; + +use crate::convfiles::{Rgba, apply_orientation, exif_orientation, scale_down_to_max}; +use crate::store::{BK_STATE, Store}; + +/// `maxImageDim`. +pub const MAX_IMAGE_DIM: usize = 1568; +/// `imageJPEGQuality`. +const JPEG_QUALITY: u8 = 88; +/// `maxVisionBytes`. +pub const MAX_VISION_BYTES: i64 = 12 << 20; +/// `screenshotTimeout`. +const SCREENSHOT_TIMEOUT: Duration = Duration::from_secs(90); +/// `maxCaptureFiles`, `maxCaptureBytes`. +const MAX_CAPTURE_FILES: usize = 20; +const MAX_CAPTURE_BYTES: u64 = 40 << 20; + +/// `imageMimes` : les images qu'on sait montrer au modèle. +pub fn image_mime(name: &str) -> &'static str { + let ext = Path::new(name) + .extension() + .map(|e| format!(".{}", e.to_string_lossy().to_lowercase())) + .unwrap_or_default(); + match ext.as_str() { + ".png" => "image/png", + ".jpg" | ".jpeg" => "image/jpeg", + ".gif" => "image/gif", + ".webp" => "image/webp", + ".bmp" => "image/bmp", + _ => "", + } +} + +/// `prepareImageForModel` : orientation cuite dans les pixels, grand côté +/// sous [`MAX_IMAGE_DIM`] ; rien à faire ou image indécodable : les octets +/// d'origine. +pub fn prepare_image_for_model(raw: &[u8], mime: &str) -> (Vec, String) { + let orient = if mime == "image/jpeg" { + exif_orientation(raw) + } else { + 0 + }; + let need_orient = (2..=8).contains(&orient); + // Les formats que décode la bibliothèque standard du Go. + let fmt = match image::guess_format(raw) { + Ok(f @ (image::ImageFormat::Png | image::ImageFormat::Jpeg | image::ImageFormat::Gif)) => f, + _ => return (raw.to_vec(), mime.to_string()), + }; + let Ok(src) = image::load_from_memory_with_format(raw, fmt) else { + return (raw.to_vec(), mime.to_string()); + }; + let (w, h) = (src.width() as usize, src.height() as usize); + let need_resize = w > MAX_IMAGE_DIM || h > MAX_IMAGE_DIM; + if !need_orient && !need_resize { + return (raw.to_vec(), mime.to_string()); + } + let mut img = Rgba { + w, + h, + pix: src.to_rgba8().into_raw(), + }; + if need_orient { + img = apply_orientation(&img, orient); + } + if img.w > MAX_IMAGE_DIM || img.h > MAX_IMAGE_DIM { + img = scale_down_to_max(&img, MAX_IMAGE_DIM); + } + let Some(buf) = image::RgbaImage::from_raw(img.w as u32, img.h as u32, img.pix) else { + return (raw.to_vec(), mime.to_string()); + }; + let mut out = std::io::Cursor::new(Vec::new()); + if mime == "image/png" { + if buf.write_to(&mut out, image::ImageFormat::Png).is_err() { + return (raw.to_vec(), mime.to_string()); + } + return (out.into_inner(), "image/png".into()); + } + let enc = image::codecs::jpeg::JpegEncoder::new_with_quality(&mut out, JPEG_QUALITY); + let rgb = image::DynamicImage::ImageRgba8(buf).to_rgb8(); + if rgb.write_with_encoder(enc).is_err() { + return (raw.to_vec(), mime.to_string()); + } + (out.into_inner(), "image/jpeg".into()) +} + +/// `imageURLPart`. +pub fn image_url_part(b: &[u8], mime: &str) -> Value { + json!({ + "type": "image_url", + "image_url": { "url": format!("data:{mime};base64,{}", base64::engine::general_purpose::STANDARD.encode(b)) }, + }) +} + +/// `engineSeesImages` : le moteur en service accepte-t-il des images ? +/// Sonde `/props` (authentifiée), gardée 10 s ; preset externe : sa case. +#[derive(Default)] +pub struct VisionProbe { + last: tokio::sync::Mutex>, +} + +impl VisionProbe { + pub async fn sees(&self, store: &Store, cfg: &crate::serve::Cfg) -> bool { + if crate::serve::is_external(cfg) { + return crate::system::vision_enabled(cfg); + } + let mut last = self.last.lock().await; + if let Some((at, seen)) = *last + && at.elapsed() < Duration::from_secs(10) + { + return seen; + } + *last = Some((Instant::now(), false)); + crate::chat::engine::install_crypto(); + let client = reqwest::Client::builder() + .timeout(Duration::from_secs(2)) + .build() + .unwrap_or_default(); + let url = format!("http://localhost:{}/props", crate::engstatus::llm_port(cfg)); + let mut rq = client.get(url); + let key = store.get_str(BK_STATE, "api_key").await; + if !key.is_empty() { + rq = rq.header("Authorization", format!("Bearer {key}")); + } + let Ok(resp) = rq.send().await else { + return false; + }; + if resp.status().as_u16() != 200 { + return false; + } + let v: Value = match resp.bytes().await { + Ok(b) => serde_json::from_slice(&b).unwrap_or_default(), + Err(_) => return false, + }; + let seen = v["modalities"]["vision"].as_bool().unwrap_or(false); + *last = Some((Instant::now(), seen)); + seen + } + + /// Oublie la dernière sonde (tests). + pub async fn reset(&self) { + *self.last.lock().await = None; + } +} + +/// `toolSeeImage` : (accusé, partie image). `cwd` et `target` : le contexte +/// des outils ; `sees` : la sonde du moteur, appelée en dernier. +pub async fn see_image( + path: &str, + cwd: &Path, + target: &str, + vision: bool, + sees: impl std::future::Future, +) -> (String, Option) { + let err = |m: String| (m, None); + if !vision { + return err("[erreur] la vision n'est pas active sur ce preset (aucun projecteur MMPROJ configuré) — impossible de voir une image".into()); + } + if !target.is_empty() { + return err("[erreur] voir une image n'est pas possible sur un poste distant (le fichier est sur l'autre machine)".into()); + } + if path.is_empty() { + return err("[erreur] chemin de fichier manquant".into()); + } + let abs = crate::tools::policy::resolve_agent_path(cwd, path); + let mime = image_mime(&abs.to_string_lossy()); + if mime.is_empty() { + return err(format!( + "[erreur] format non reconnu comme image (attendu : png, jpg, gif, webp, bmp) : {path}" + )); + } + let st = match std::fs::metadata(&abs) { + Ok(m) => m, + Err(_) => return err(format!("[erreur] fichier introuvable : {path}")), + }; + if st.is_dir() { + return err(format!("[erreur] c'est un dossier, pas une image : {path}")); + } + if st.len() as i64 > MAX_VISION_BYTES { + return err(format!( + "[erreur] image trop lourde ({}, max {}) : {path}", + crate::downloads::human_bytes(st.len() as i64), + crate::downloads::human_bytes(MAX_VISION_BYTES) + )); + } + if !sees.await { + return err(format!( + "[erreur] le moteur en service ne traite pas les images (projecteur non chargé ?) — impossible de voir {path}" + )); + } + let b = match std::fs::read(&abs) { + Ok(b) => b, + Err(e) => { + return err(format!( + "[erreur] lecture impossible : {}", + crate::paths::os_err("open", &abs.to_string_lossy(), &e) + )); + } + }; + if b.is_empty() { + return err(format!("[erreur] fichier vide : {path}")); + } + let (b, mime) = prepare_image_for_model(&b, mime); + let base = abs + .file_name() + .map(|n| n.to_string_lossy().into_owned()) + .unwrap_or_default(); + ( + format!("[ok] image chargée : {base}"), + Some(image_url_part(&b, &mime)), + ) +} + +// --- web_screenshot ------------------------------------------------------------- + +/// Le résultat de `web_screenshot` : le texte, et la capture rangée +/// (chemin relatif à la discussion, et absolu). +#[derive(Debug, Default, Clone, PartialEq)] +pub struct Shot { + pub result: String, + pub rel: String, + pub abs: PathBuf, +} + +/// `safeSlug`. +pub fn safe_slug(s: &str) -> String { + let re = regex::Regex::new(r"[^a-zA-Z0-9._-]+").expect("regex"); + let s = re.replace_all(s, "-"); + let s = s.trim_matches(['-', '.']); + let s: String = s.chars().take(40).collect(); + if s.is_empty() { "page".into() } else { s } +} + +/// `isLocalURL`. Le nom d'hôte tel qu'écrit (`url.Hostname()` du Go +/// garde la casse : `LOCALHOST` n'est pas local). +pub fn is_local_url(raw: &str) -> bool { + if url::Url::parse(raw).is_err() { + return false; + } + let host = go_hostname(raw); + matches!(host, "localhost" | "127.0.0.1" | "::1" | "0.0.0.0") || host.ends_with(".localhost") +} + +/// `url.Hostname()` : l'hôte de l'autorité, sans identifiants ni port, +/// sans crochets pour une IPv6. +fn go_hostname(raw: &str) -> &str { + let Some(i) = raw.find("://") else { + return ""; + }; + let rest = &raw[i + 3..]; + let auth = &rest[..rest.find(['/', '?', '#']).unwrap_or(rest.len())]; + let hp = auth.rfind('@').map_or(auth, |j| &auth[j + 1..]); + if let Some(v6) = hp.strip_prefix('[') { + return v6.find(']').map_or(v6, |j| &v6[..j]); + } + match hp.rfind(':') { + Some(c) if hp[c + 1..].bytes().all(|b| b.is_ascii_digit()) => &hp[..c], + _ => hp, + } +} + +/// `lastLines` : les n dernières lignes non vides, jointes par « · ». +pub fn last_lines(s: &str, n: usize) -> String { + let keep: Vec<&str> = s.split('\n').filter(|l| !l.trim().is_empty()).collect(); + keep[keep.len().saturating_sub(n)..].join(" · ") +} + +/// `pruneCaptures` : les plus anciennes captures partent tant que le +/// dossier dépasse 20 fichiers ou 40 Mo ; celle qui vient d'être prise reste. +pub fn prune_captures(dir: &Path, keep: &Path) { + let Ok(rd) = std::fs::read_dir(dir) else { + return; + }; + let mut shots: Vec<(PathBuf, SystemTime, u64)> = Vec::new(); + let mut total = 0u64; + for e in rd.flatten() { + let Ok(m) = e.metadata() else { continue }; + if m.is_dir() { + continue; + } + let p = e.path(); + total += m.len(); + if p == keep { + continue; + } + shots.push((p, m.modified().unwrap_or(SystemTime::UNIX_EPOCH), m.len())); + } + shots.sort_by_key(|s| s.1); + // Tous les fichiers comptent, celle qui reste comprise. + let mut nb = shots.len() + usize::from(!keep.as_os_str().is_empty()); + for (p, _, size) in shots { + if nb <= MAX_CAPTURE_FILES && total <= MAX_CAPTURE_BYTES { + break; + } + if std::fs::remove_file(&p).is_ok() { + total -= size; + nb -= 1; + } + } +} + +/// `toolWebScreenshot`. `playwright` : le binaire (vide : absent) ; +/// `conv_dir` : le dossier de la discussion ; `internet` : l'accès est-il +/// ouvert ; `stamp` : l'heure du nom de fichier. +pub async fn web_screenshot( + args: &Map, + playwright: &str, + conv_dir: &Path, + internet: bool, + stamp: &str, +) -> Shot { + let fail = |m: &str| Shot { + result: m.to_string(), + ..Default::default() + }; + if playwright.is_empty() { + return fail( + "[erreur] Playwright n'est pas installé dans cette image (bâtie avec PLAYWRIGHT=0).", + ); + } + let url = args + .get("url") + .and_then(Value::as_str) + .unwrap_or("") + .trim() + .to_string(); + if url.is_empty() { + return fail("[erreur] url manquante"); + } + if !url.starts_with("http://") && !url.starts_with("https://") { + return fail("[erreur] url invalide : elle doit commencer par http:// ou https://"); + } + if !internet && !is_local_url(&url) { + return fail( + "[refusé] L'accès internet est coupé : la capture ne marche que sur une adresse locale (localhost / 127.0.0.1), par exemple ton serveur de dev. Active l'accès internet pour le web.", + ); + } + let mut width = 1280i64; + if let Some(v) = args.get("width").and_then(Value::as_f64) + && (320.0..=3840.0).contains(&v) + { + width = v as i64; + } + let full_page = args.get("full_page").and_then(Value::as_bool) == Some(true); + let dir = conv_dir.join("captures"); + if let Err(e) = crate::paths::go_mkdir_all(&dir) { + return fail(&format!("[erreur] création du dossier de captures : {e}")); + } + let mut host = url.as_str(); + if let Some(i) = host.find("://") { + host = &host[i + 3..]; + } + if let Some(i) = host.find(['/', '?', '#']) { + host = &host[..i]; + } + let host = host.to_string(); + let name = format!("{}-{stamp}.jpg", safe_slug(&host)); + let out = dir.join(&name); + let mut cmd_args: Vec = [ + "screenshot", + "--browser", + "chromium", + "--viewport-size", + &format!("{width},800"), + "--wait-for-timeout", + "3500", + ] + .map(String::from) + .to_vec(); + if full_page { + cmd_args.push("--full-page".into()); + } + cmd_args.push(url.clone()); + cmd_args.push(out.to_string_lossy().into_owned()); + let run = tokio::process::Command::new(playwright) + .args(&cmd_args) + .current_dir(&dir) + .stdin(std::process::Stdio::null()) + .kill_on_drop(true) + .output(); + match tokio::time::timeout(SCREENSHOT_TIMEOUT, run).await { + Err(_) => return fail("[erreur] la page n'a pas fini de charger en 90 s"), + // Lancement impossible : le Go ne rend que la fin de la sortie, vide. + Ok(Err(_)) => return fail("[erreur] capture impossible : "), + Ok(Ok(o)) if !o.status.success() => { + let mut combined = o.stdout.clone(); + combined.extend_from_slice(&o.stderr); + return fail(&format!( + "[erreur] capture impossible : {}", + last_lines(&crate::system::go_lossy(&combined), 3).trim() + )); + } + Ok(Ok(_)) => {} + } + let size = match std::fs::metadata(&out) { + Ok(m) if m.len() > 0 => m.len(), + _ => return fail("[erreur] Playwright n'a produit aucune image"), + }; + prune_captures(&dir, &out); + let rel = format!("captures/{name}"); + Shot { + result: format!( + "Capture enregistrée ({rel}, {} Ko).\nPour la montrer à l'utilisateur, recopie TELLE QUELLE cette ligne markdown dans ta réponse :\n![capture de {host}](/api/chat/image?path={rel})", + size / 1024 + ), + rel, + abs: out, + } +} + +/// `screenshotImageMessage` : le message qui porte la capture au modèle. +pub fn screenshot_message(abs: &Path) -> Option { + let mime = image_mime(&abs.to_string_lossy()); + if mime.is_empty() { + return None; + } + let b = std::fs::read(abs).ok().filter(|b| !b.is_empty())?; + let (b, mime) = prepare_image_for_model(&b, mime); + Some(json!({ + "role": "user", + "content": [ + { "type": "text", "text": "Voici la capture demandée." }, + image_url_part(&b, &mime), + ], + })) +} + +/// `time.Now().Format("20060102-150405")`, heure locale. +pub fn local_stamp() -> String { + let sec = SystemTime::now() + .duration_since(SystemTime::UNIX_EPOCH) + .map(|d| d.as_secs() as i64) + .unwrap_or_default(); + let c = crate::tz::Location::local().civil(sec); + format!( + "{:04}{:02}{:02}-{:02}{:02}{:02}", + c.year, c.month, c.day, c.hour, c.minute, c.second + ) +} + +#[cfg(test)] +mod tests; diff --git a/rust/loki-rs/src/imagetools/tests.rs b/rust/loki-rs/src/imagetools/tests.rs new file mode 100644 index 0000000..a8812a5 --- /dev/null +++ b/rust/loki-rs/src/imagetools/tests.rs @@ -0,0 +1,150 @@ +//! Tests unitaires des outils d'image (lot 45) ; la parité avec le Go est +//! dans `tests/imagetools.rs`. + +use super::*; + +#[test] +fn types_d_image() { + assert_eq!(image_mime("a.PNG"), "image/png"); + assert_eq!(image_mime("/x/b.jpeg"), "image/jpeg"); + assert_eq!(image_mime("c.Jpg"), "image/jpeg"); + assert_eq!(image_mime("d.gif"), "image/gif"); + assert_eq!(image_mime("e.webp"), "image/webp"); + assert_eq!(image_mime("f.bmp"), "image/bmp"); + assert_eq!(image_mime("g.svg"), ""); + assert_eq!(image_mime("png"), ""); + assert_eq!(image_mime(""), ""); +} + +#[test] +fn noms_de_capture() { + assert_eq!(safe_slug("localhost:3000"), "localhost-3000"); + assert_eq!(safe_slug("www.exemple.test"), "www.exemple.test"); + assert_eq!(safe_slug("..--a b--.."), "a-b"); + assert_eq!(safe_slug("été"), "t"); + assert_eq!(safe_slug("::"), "page"); + assert_eq!(safe_slug(""), "page"); + assert_eq!(safe_slug(&"x".repeat(60)).len(), 40); +} + +#[test] +fn adresses_locales() { + for u in [ + "http://localhost:3000/app", + "http://127.0.0.1/", + "http://[::1]:8080/", + "http://0.0.0.0:5173", + "https://app.localhost/", + "http://moi:secret@localhost/", + ] { + assert!(is_local_url(u), "{u}"); + } + for u in [ + "https://exemple.test/", + "http://localhost.exemple.test/", + "http://LOCALHOST/", + "http://127.0.0.2/", + "pas une url", + "http://localhost:abc/", + ] { + assert!(!is_local_url(u), "{u}"); + } +} + +#[test] +fn dernieres_lignes() { + assert_eq!(last_lines("a\n\nb\n \nc\nd\n", 3), "b · c · d"); + assert_eq!(last_lines("seule", 6), "seule"); + assert_eq!(last_lines("", 6), ""); + assert_eq!(last_lines("\n \n", 6), ""); +} + +#[test] +fn image_preparee() { + // Petite PNG : rien à faire, les octets d'origine. + let mut png = Vec::new(); + image::RgbaImage::from_pixel(10, 5, image::Rgba([1, 2, 3, 255])) + .write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png) + .unwrap(); + assert_eq!( + prepare_image_for_model(&png, "image/png"), + (png.clone(), "image/png".into()) + ); + // Indécodable : telle quelle. + assert_eq!( + prepare_image_for_model(b"pas une image", "image/png"), + (b"pas une image".to_vec(), "image/png".into()) + ); + // Trop grande : réduite sous 1568 px, en PNG. + let mut big = Vec::new(); + image::RgbaImage::from_pixel(3136, 100, image::Rgba([9, 9, 9, 255])) + .write_to(&mut std::io::Cursor::new(&mut big), image::ImageFormat::Png) + .unwrap(); + let (b, mime) = prepare_image_for_model(&big, "image/png"); + assert_eq!(mime, "image/png"); + let img = image::load_from_memory(&b).unwrap(); + assert_eq!((img.width(), img.height()), (1568, 50)); + let part = image_url_part(b"ab", "image/gif"); + assert_eq!(part["image_url"]["url"], "data:image/gif;base64,YWI="); +} + +#[test] +fn menage_des_captures() { + let d = tempfile::tempdir().unwrap(); + let base = SystemTime::now() - Duration::from_secs(1000); + for i in 0..25u64 { + let p = d.path().join(format!("c{i:02}.jpg")); + std::fs::write(&p, "x").unwrap(); + std::fs::File::options() + .write(true) + .open(&p) + .unwrap() + .set_modified(base + Duration::from_secs(i)) + .unwrap(); + } + // La plus ancienne est celle qu'on vient de prendre : elle reste. + let keep = d.path().join("c00.jpg"); + prune_captures(d.path(), &keep); + let mut left: Vec = std::fs::read_dir(d.path()) + .unwrap() + .flatten() + .map(|e| e.file_name().to_string_lossy().into_owned()) + .collect(); + left.sort(); + assert_eq!(left.len(), 20); + assert_eq!(left[0], "c00.jpg"); + assert_eq!(left[1], "c06.jpg"); +} + +#[tokio::test] +async fn capture_refusee_avant_playwright() { + let d = tempfile::tempdir().unwrap(); + let args = |v: Value| serde_json::from_value::>(v).unwrap(); + let s = web_screenshot(&args(json!({"url": "http://x/"})), "", d.path(), true, "t").await; + assert!( + s.result.contains("Playwright n'est pas installé"), + "{}", + s.result + ); + let s = web_screenshot(&args(json!({"url": 3})), "/bin/false", d.path(), true, "t").await; + assert_eq!(s.result, "[erreur] url manquante"); + assert!(s.rel.is_empty()); + assert!(!d.path().join("captures").exists()); +} + +#[tokio::test] +async fn voir_sans_poste_distant() { + let d = tempfile::tempdir().unwrap(); + let (r, img) = see_image("a.png", d.path(), "nœud", true, async { true }).await; + assert!(r.contains("poste distant"), "{r}"); + assert!(img.is_none()); + let (r, _) = see_image("", d.path(), "", true, async { true }).await; + assert_eq!(r, "[erreur] chemin de fichier manquant"); +} + +#[test] +fn horodatage_local() { + let s = local_stamp(); + assert_eq!(s.len(), 15); + assert_eq!(&s[8..9], "-"); +} diff --git a/rust/loki-rs/src/lib.rs b/rust/loki-rs/src/lib.rs index 9f55911..a1ee2a7 100644 --- a/rust/loki-rs/src/lib.rs +++ b/rust/loki-rs/src/lib.rs @@ -29,6 +29,7 @@ pub mod engstatus; pub mod gguf; pub mod gojson; pub mod hf; +pub mod imagetools; pub mod mcp; pub mod memory; pub mod models; diff --git a/rust/loki-rs/tests/imagetools.rs b/rust/loki-rs/tests/imagetools.rs new file mode 100644 index 0000000..6a52453 --- /dev/null +++ b/rust/loki-rs/tests/imagetools.rs @@ -0,0 +1,286 @@ +//! Lot 45 : outils d'image de l'agent (`see_image`, `web_screenshot`) +//! tenus par la façade, rejoués sur le journal du Go +//! (`internal/loki/parity_image_tools_test.go` → +//! `tests/parity_images/images.json`) : mêmes fichiers, même faux moteur +//! (`/props`), même faux Playwright. Une image laissée telle quelle se +//! compare à l'octet ; une image réencodée par ses dimensions et son type, +//! et une PNG réduite par ses pixels. +#![cfg(target_os = "linux")] + +mod common; + +use std::convert::Infallible; +use std::sync::{Arc, Mutex}; + +use base64::Engine as _; +use bytes::Bytes; +use common::fakego; +use http_body_util::Full; +use hyper::service::service_fn; +use hyper::{Request, Response}; +use hyper_util::rt::TokioIo; +use loki_rs::imagetools::{self, VisionProbe}; +use loki_rs::store::Store; +use regex::Regex; +use serde_json::{Map, Value, json}; +use tokio::net::TcpListener; + +const FAKE_PLAYWRIGHT: &str = r#"#!/bin/sh +d=$(dirname "$0") +printf '%s\n' "$@" > "$d/args" +for a in "$@"; do out="$a"; done +mode=$(cat "$d/mode" 2>/dev/null) +case "$mode" in + echec) echo "Launching chromium" ; echo "" ; echo "page.goto: net::ERR_NAME_NOT_RESOLVED at https://x" >&2 ; echo "Call log:" >&2 ; echo " - navigating" >&2 ; exit 1 ;; + vide) : > "$out" ;; + rien) ;; + *) cat "$d/image" > "$out" ;; +esac +"#; + +/// Le faux moteur : `/props` authentifié, la vision réglée par le test. +async fn fake_engine(sees: Arc>) -> u16 { + let l = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let port = l.local_addr().unwrap().port(); + tokio::spawn(async move { + while let Ok((st, _)) = l.accept().await { + let sees = sees.clone(); + tokio::spawn(async move { + let svc = service_fn(move |req: Request| { + let sees = sees.clone(); + async move { + let ok = req.uri().path() == "/props" + && req + .headers() + .get("authorization") + .and_then(|h| h.to_str().ok()) + == Some("Bearer cle-moteur"); + let mut r = Response::new(Full::new(Bytes::new())); + if ok { + let mut s = sees.lock().unwrap(); + s.1 += 1; + r = Response::new(Full::new(Bytes::from( + json!({ "modalities": { "vision": s.0 } }).to_string(), + ))); + } else { + *r.status_mut() = hyper::StatusCode::UNAUTHORIZED; + } + Ok::<_, Infallible>(r) + } + }); + let _ = hyper::server::conn::http1::Builder::new() + .serve_connection(TokioIo::new(st), svc) + .await; + }); + } + }); + port +} + +/// `parityPartFacts`. +fn part_facts(part: &Value, raw: &Map) -> Value { + let u = part["image_url"]["url"].as_str().unwrap(); + let i = u.find(";base64,").unwrap(); + let mime = u[..i].trim_start_matches("data:"); + let b = base64::engine::general_purpose::STANDARD + .decode(&u[i + 8..]) + .unwrap(); + let mut out = Map::new(); + out.insert("mime".into(), json!(mime)); + for (name, r) in raw { + let rb = base64::engine::general_purpose::STANDARD + .decode(r.as_str().unwrap_or("")) + .unwrap(); + if rb == b { + out.insert("same_as".into(), json!(name)); + return Value::Object(out); + } + } + let Ok(img) = image::load_from_memory(&b) else { + panic!("image relayée illisible"); + }; + let img = img.to_rgba8(); + let (w, h) = img.dimensions(); + out.insert("w".into(), json!(w)); + out.insert("h".into(), json!(h)); + if mime == "image/png" { + let mut px = Map::new(); + for (x, y) in [(0, 0), (1, 1), (100, 50), (w - 1, h - 1), (w / 2, h / 3)] { + let p = img.get_pixel(x, y).0; + px.insert( + format!("{x},{y}"), + json!(format!("{},{},{},{}", p[0], p[1], p[2], p[3])), + ); + } + out.insert("px".into(), Value::Object(px)); + } + Value::Object(out) +} + +#[tokio::test(flavor = "multi_thread", worker_threads = 2)] +async fn outils_image_comme_le_go() { + let fx: Value = + serde_json::from_str(include_str!("parity_images/images.json")).expect("journal"); + let tmp = tempfile::tempdir().unwrap(); + let files = tmp.path().join("fichiers"); + let raw = fx["files"].as_object().unwrap(); + for (name, b) in raw { + let p = files.join(name); + std::fs::create_dir_all(p.parent().unwrap()).unwrap(); + std::fs::write( + &p, + base64::engine::general_purpose::STANDARD + .decode(b.as_str().unwrap_or("")) + .unwrap(), + ) + .unwrap(); + } + std::fs::create_dir_all(files.join("dossier.png")).unwrap(); + std::fs::File::create(files.join("lourd.png")) + .unwrap() + .set_len(13 << 20) + .unwrap(); + let files_s = files.to_string_lossy().into_owned(); + + let sees = Arc::new(Mutex::new((false, 0u32))); + let port = fake_engine(sees.clone()).await; + let (_, go, _stop) = fakego::start(tmp.path().join("home")).await; + let backend = go.backend.lock().unwrap().unwrap(); + let store = Store::new(backend, fakego::JETON.into()); + go.set("state", "api_key", "cle-moteur"); + let mut cfg = std::collections::HashMap::new(); + cfg.insert("PORT".to_string(), port.to_string()); + let probe = VisionProbe::default(); + + let pw_dir = tmp.path().join("pw"); + std::fs::create_dir_all(&pw_dir).unwrap(); + let pw = pw_dir.join("playwright"); + std::fs::write(&pw, FAKE_PLAYWRIGHT).unwrap(); + use std::os::unix::fs::PermissionsExt as _; + std::fs::set_permissions(&pw, std::fs::Permissions::from_mode(0o755)).unwrap(); + let conv_dir = tmp.path().join("conv"); + let cap_dir = conv_dir.join("captures"); + let stamp_re = Regex::new(r"[0-9]{8}-[0-9]{6}").unwrap(); + + for (n, st) in fx["steps"].as_array().unwrap().iter().enumerate() { + let name = st["name"].as_str().unwrap(); + *sees.lock().unwrap() = (st["sees"] == true, 0); + probe.reset().await; + std::fs::write(pw_dir.join("mode"), st["mode"].as_str().unwrap_or("")).unwrap(); + if let Some(img) = st["image"].as_str() { + let b = base64::engine::general_purpose::STANDARD + .decode(raw[img].as_str().unwrap()) + .unwrap(); + std::fs::write(pw_dir.join("image"), b).unwrap(); + } + let _ = std::fs::remove_file(pw_dir.join("args")); + if name == "ménage des captures" { + let old = std::time::SystemTime::now() - std::time::Duration::from_secs(3600); + for i in 0..22 { + let p = cap_dir.join(format!("vieille-{i:02}.jpg")); + std::fs::write(&p, "x").unwrap(); + let f = std::fs::File::options().write(true).open(&p).unwrap(); + f.set_modified(old + std::time::Duration::from_secs(i)) + .unwrap(); + } + } + let args: Map = + serde_json::from_str(&st["args"].to_string().replace("{{FICHIERS}}", &files_s)) + .unwrap(); + let label = st["label"] + .as_str() + .unwrap() + .replace("{{FICHIERS}}", &files_s); + let vision = st["vision"] == true; + let (mut result, part, shown) = match st["tool"].as_str().unwrap() { + "see_image" => { + let (r, img) = + imagetools::see_image(&label, &files, "", vision, probe.sees(&store, &cfg)) + .await; + let relay = img.map(|i| loki_rs::chat::host::see_image_message(&label, i)); + (r, relay, String::new()) + } + _ => { + let stamp = format!("20260101-1200{:02}", n % 60); + let shot = imagetools::web_screenshot( + &args, + &pw.to_string_lossy(), + &conv_dir, + st["internet"] == true, + &stamp, + ) + .await; + let relay = if !shot.rel.is_empty() && vision && probe.sees(&store, &cfg).await { + imagetools::screenshot_message(&shot.abs) + .and_then(|m| serde_json::from_value(m).ok()) + } else { + None + }; + (shot.result, relay, shot.rel) + } + }; + let mut facts = None; + if let Some(m) = &relay_parts(&part) { + for p in m { + if p["type"] == "image_url" { + facts = Some(part_facts(p, raw)); + } + if p["type"] == "text" { + result += &format!("\n[relais] {}", p["text"].as_str().unwrap()); + } + } + } + let mask = |s: &str| { + stamp_re + .replace_all(&s.replace(&files_s, "{{FICHIERS}}"), "{{T}}") + .into_owned() + }; + assert_eq!(mask(&result), st["result"].as_str().unwrap(), "{name}"); + assert_eq!(facts, st.get("part").cloned(), "{name} : image relayée"); + assert_eq!( + mask(&shown), + st["shown"].as_str().unwrap_or(""), + "{name} : capture montrée" + ); + assert_eq!( + sees.lock().unwrap().1 as u64, + st["probes"].as_u64().unwrap(), + "{name} : sondes du moteur" + ); + let pw_args: Vec = std::fs::read_to_string(pw_dir.join("args")) + .map(|b| { + b.trim_end_matches('\n') + .split('\n') + .map(|l| { + mask(&l.replace(&cap_dir.to_string_lossy().into_owned(), "{{CAPTURES}}")) + }) + .collect() + }) + .unwrap_or_default(); + assert_eq!( + json!(pw_args), + st.get("pw_args").cloned().unwrap_or(json!([])), + "{name} : Playwright" + ); + if st["tool"] == "web_screenshot" { + let mut caps: Vec = std::fs::read_dir(&cap_dir) + .into_iter() + .flatten() + .flatten() + .map(|e| mask(&e.file_name().to_string_lossy())) + .collect(); + caps.sort(); + assert_eq!( + json!(caps), + st.get("captures").cloned().unwrap_or(json!([])), + "{name} : dossier des captures" + ); + } + } +} + +/// Les parties d'un message relayé. +fn relay_parts(m: &Option) -> Option> { + let m = m.as_ref()?; + m.content.as_ref()?.as_array().cloned() +} diff --git a/rust/loki-rs/tests/lot6.rs b/rust/loki-rs/tests/lot6.rs index 0028010..9be8e31 100644 --- a/rust/loki-rs/tests/lot6.rs +++ b/rust/loki-rs/tests/lot6.rs @@ -674,6 +674,7 @@ async fn tour_complet_par_le_go() { web: Default::default(), jobs: Default::default(), browser: Default::default(), + vision: Default::default(), go_version: Default::default(), }); let cfg = std::collections::HashMap::new(); @@ -2842,6 +2843,46 @@ async fn job_arriere_plan_par_la_facade() { assert_eq!(jobs.running(), 0); } +/// Lot 45 : `see_image` et `web_screenshot` sont exécutés par la façade +/// (rien par le Go) : sans projecteur, l'image n'est pas lue ; une capture +/// sans url est refusée avant Playwright. +#[tokio::test] +async fn outils_image_par_la_facade() { + let calls = sse(&[ + serde_json::json!({"choices":[{"delta":{"tool_calls":[ + {"index":0,"id":"v1","type":"function","function":{"name":"see_image","arguments":"{\"path\":\"photo.png\"}"}}, + {"index":1,"id":"v2","type":"function","function":{"name":"web_screenshot","arguments":"{}"}} + ]}}]}), + serde_json::json!({"choices":[{"delta":{},"finish_reason":"tool_calls"}]}), + ]); + let (url, seen) = fake_engine(vec![calls, answer("vu")]).await; + let ws = tempfile::tempdir().unwrap(); + std::fs::write(ws.path().join("photo.png"), b"x").unwrap(); + let (svc, go, _stop, _t) = service_with(Some(&url), |_| {}).await; + *go.tool_ctx.lock().unwrap() = Some(serde_json::json!({ + "cwd": ws.path(), "memory_dir": ws.path().join("mem"), "target": "" + })); + svc.send(serde_json::json!({"message": "regarde", "cid": "v"})) + .await + .unwrap(); + until_done(&svc, 1).await; + assert!(go.tool_log.lock().unwrap().is_empty(), "{:?}", go.tool_log); + let seen = seen.lock().unwrap().clone(); + let tools: Vec = seen[1].1["messages"] + .as_array() + .unwrap() + .iter() + .filter(|m| m["role"] == "tool") + .map(|m| m["content"].as_str().unwrap().to_string()) + .collect(); + assert_eq!(tools.len(), 2, "{tools:?}"); + assert!(tools[0].contains("la vision n'est pas active"), "{tools:?}"); + assert!( + tools[1] == "[erreur] url manquante" || tools[1].contains("Playwright n'est pas installé"), + "{tools:?}" + ); +} + /// Lot 44 : le navigateur piloté est celui de la façade. Un tour qui ouvre /// une page l'exécute chez elle (rien par le Go), l'aperçu est servi par /// /api/chat/cushot, et le Go passe par /internal/facade/v1/browser. diff --git a/rust/loki-rs/tests/parity_images/images.json b/rust/loki-rs/tests/parity_images/images.json new file mode 100644 index 0000000..5c424cb --- /dev/null +++ b/rust/loki-rs/tests/parity_images/images.json @@ -0,0 +1,614 @@ +{ + "files": { + "anim.gif": "R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAICRAEAOw==", + "capture.jpg": "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", + "capture.png": "iVBORw0KGgoAAAANSUhEUgAAAEAAAAAoCAIAAADBrGu+AAAAZ0lEQVR4nOzS0QmAMBBEwQsG7b9ji9iPJTpwBdywb8/MNWsffPeaOfg+AHj6T/x8geMBEmoDLAAQAiQEEAIk1AZYACAESAggBEioDbAAQAiQEEAIkFAbYAGAECAhgBAgoe69AQAA//86MgyTWSqBGAAAAABJRU5ErkJggg==", + "cassee.png": "iVBORw0KGgphYsOubcOp", + "grande.jpeg": "/9j/2wCEAAMCAgMCAgMDAwMEAwMEBQgFBQQEBQoHBwYIDAoMDAsKCwsNDhIQDQ4RDgsLEBYQERMUFRUVDA8XGBYUGBIUFRQBAwQEBQQFCQUFCRQNCw0UFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFP/AABEIA4QHCAMBIgACEQEDEQH/xAGiAAABBQEBAQEBAQAAAAAAAAAAAQIDBAUGBwgJCgsQAAIBAwMCBAMFBQQEAAABfQECAwAEEQUSITFBBhNRYQcicRQygZGhCCNCscEVUtHwJDNicoIJChYXGBkaJSYnKCkqNDU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6g4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2drh4uPk5ebn6Onq8fLz9PX29/j5+gEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoLEQACAQIEBAMEBwUEBAABAncAAQIDEQQFITEGEkFRB2FxEyIygQgUQpGhscEJIzNS8BVictEKFiQ04SXxFxgZGiYnKCkqNTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqCg4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2dri4+Tl5ufo6ery8/T19vf4+fr/2gAMAwEAAhEDEQA/APysVakC09Vp4WvTp0zPmGBeakVeacF5qRV5716lOmLmGKtPC8U9Vp6pxXqU6YXGBKkVacEqRV5r1KdMXMMVakC05VqQJXq06YcwwLzT1WnhKkVa9SnTDmGKvFPC8U9V4p4XivUp0xcwwLTwvNPC1IF5r1adMOYYq08LT1WnhK9SnTFzDQtPVaeEp6rXqU6YXGKvFPC8U9V4p4XjvXq06YuYaFp4XmnhaeF5r1KdMOYYq1IFpyrUgSvUp0w5hgSpFWnBakVa9SnTFzDAvFPC8U8LxTwvFerTphzDQtYHiDX/ACC1rav+96PIP4PYe/8AL69HeIdf8jda2rHzejyD+H2Hv/L69OXC81/OfiJ4i/V+fJMkn7+1Sovs94xf8380vs7L3ruPs4PC3tUqLTohgXmnqtPC809Vr+XqdM93mGhakC04JUgSvVp0w5hirTwvFPVaeF4r1KdMXMNC08LzTwvSnhee9epTphzDFXmnqtPVeaeq16tOmK40LTwlPCU8LXqU6Ycw1Vp4XinqtPC8V6lKmHMMC1IF5pwWpAvPevVp0xcwxV5p6rT1XmnqlepTphzDAtSBKcEqQLXqU6YrjFWpFWnKtSKtepTphzDAtPC808LUirzXq06YuYYq09V4p6rT1XivUp0w5hgWnhaeE4p4WvUp0w5hqrT1WnqtPC16tKmLmGhawPEGv+QWtbVv3vR5B/B7D3/l9ej/ABBr/kbrW1b970eRf4fYe/8AL69OWC1/OfiL4i/V+fJMkn7+1Sovs94xf8380vs7L3ruPtYPC3tUqLTohqrT1WnqvNPVa/l6nTPd5hgXinhaeF4p4TpXqU6YuYaF5p6rTwvNPVa9WnTDmGKtSBacq1IFr1KdMXMMC1Iq05UqRVr1KdMLjAvFPC08LxT9tepTpi5hgXmnqtPC809Vr1adMOYaq1IFpwWnhK9SnTFzDQtPVaeF5p6rXqU6YcwwLxUgXkU4LxUgXkV6tOmHMMC809Vp4XmnqtepTpi5hqrTwtOVKkCV6lOmHMNVaeq08LzT1WvUp0xcwwLxUgXkU4LxUgXkV6tOmHMMC809Vp4XmnqlepTpi5hgWsHxBr/2fda2rfvekkg/h9h7/wAvr0d4g1/yN1rat+96PIP4fYe/8vr05cLxX85+IviL9X58kySfv7VKi+z3jF/zfzS+zsveu4+1g8Le1SotOiGBakC04JUipX8vU6Z7vMMC08LT1Wnha9WnTDmGheaeq08LzT1WvUp0xcwxV4p4XinqvHenhOK9SnTDmGhaeFp4Snhea9WnTFzDFWpAtPVaeFr1KdMOYaF5p6rTwvNPVa9WnTFzDFXinheKeq8U8JxXqU6YcwwLUgWnBakC816lKmLmGKtSBacq1IEr1KdMOYYq1Iq04JUirXqU6YcwwLxTwvFPC8U8LxXq06YuYYFp4XmnhakC816lOmHMMVaeFp6rTwlerTpi5hoWnqtPCU9Vr1KdMOYYF4rB8Qa/5Aa1tX/e9HkH8PsPf+X16P8AEGv+QGtbVv3vR5B/D7D3/l9enLBeK/nPxF8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2cHhb2qVF6IYFqQLzTgvSpAvPev5ep0z3eYYq09Vp6rzT1WvVp0w5hgWpFWnBKkCV6lOmLmGKtSBeKcqVIF4r1KdMOYYFp4XmnhelPC8969WnTFzDFXmpFWnKvNSKtepTphzDAtSBacEqQJXq06YuYYq08LT1WnqtenTphzDQtPVeaeFp6rzXq06YcwxVp6rxT1X609V4r1KdMXMNC08LTwlPC16lOmHMNVaeq09Vp6rXq0qYuYYFqRV5pwWpFXmvUp0wuMVaeq8U9V+tPVeK9SnTFzDAtSBacE4qQLXqU6YcwxVrA8Qa/wCRutbVv3vR5R/D7D3/AJfXo/xBr/kbrW1b970kkH8PsPf+X16cuq1/OniL4i/V+fJMkn7+1Sovs94xf8380vs7L3ruPtYPC3tUqr0QwLUgWnKtSBa/l6nTPd5hirTwvFPVKeq8V6lOmLmGBeKk208LxT9lepSphzDAvNPVaeF5p6rXq06YuYaq08LT1Wnha9SnTDmGqtPVaeqU9V4r1KdMXMMC8VIF5pwXipAvNerTphzDAvNPVaeF5p6rXqU6YXGKtSBacq1IFr1adMXMMC1IFpypUirXqU6YcwwLTwvIp4Xinhea9SlTFzDAvNSKtOC81Iq16lOmHMMVakC04LTwlepTpiuNC08LTwvNPVa9WnTDmGhaeF5p4Wnhea9SnTFzDFXmsDX9f8jfa2r/AL3o8g/h9h7/AMvr0f4g1/yC1rat+96PIP4fYe/8vr05dVr+dPEXxF+r8+SZJP39qlRfZ7xi/wCb+aX2dl713H2sHhb2qVPkhirxTwvFPVeO9PC8V/L1Ome7zDQtPC08JT1SvUp0w5hirUgWnKtSBa9SnTFcYF5qRVpwXmpFWvVp0w5hirxTwvFPVeO9PC8V6lOmLmGBakC04JUgXmvUp0w5hgWnhaeq08LXq06YuYaq09Vp6rT1WvUp0wuMC8VIF4FPC8U8LxXqU6YuYYFp4WnhKeF5r1KVMOYYq1IFp6rTwterTphzDVWnqtPC09Vr1KdMXMMC8U8LxTwvFPC8V6lOmHMNC809Vp4Xmnhea9WnTFzDFWpAtOVakCV6lOmFxirWB4g1/wAjda2rfvejyj+D2Hv/AC+vR/iDX/I3Wtq373o8g/h9h7/y+vTl1Wv5z8RfEX6vz5Jkk/f2qVF9nvGL/m/ml9nZe9dx9nB4W9qlT5IYq0u2pVSl2/Wv5cjT0Pd5j45VakCU5VqQLX9DU6Z/lJzDAnPSpFTnpTglSKvNepTphzDFT2p6px0p6r9Keq8V6tOmLmGBOlSBKcFqRVr1KdMOYYq1IEpyrTwlepTphzDQnNPVKeEp6rXqU6YuYaqcdKeE46U9Vp4XjtXq06YcwwLTwvNPC9KeF5r1KdMXMNVKeE4p6rTwlepTphzDQlPVKeEp6rXqU6YuYYqe1PCcdKeq08Lx2r1adMOYaFp4TmnhelPC816lOmLmGKlSBOKcqVIFr1KdMOYYEqRVpwWpFWvVp0w5hgXisDxBr/kBrW1b970eQH7vsPf+X16P8Qa/5G61tW/e9JJB/B7D3/l9enLBeK/nPxE8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2cHhb2qVNuiGhaeE56U8LTwvNfy9Spnu8wwLzT1Snheaeq16tOmHMNCcU8JTwlPCV6lOmLmGqlPC8U9Vp4XivUp0w5hoWnhOelPC08JzXq06YuYYqc9KeqU9V5p6rXqU6YcwwJxUgSnBeKkC16lOmLmGKtSBeKcq1IF4r1KdMOYYE6VIE56U4LUgTmvVp0w5hipz0p6pT1XntT1WvUp0xcwwJxUgWnBeKkC16lOmHMMVaeqU9Vp4XivVp0xcw0J0p4TmnhKeF5r1KdMOYaqe1PVOOlPVaeq8dq9SnTFzDAnHSnhaeF4p4WvVp0w5hqpWB4g1/wAjda2rfvejyA/c9h7/AMvr0f4g1/yN1rat+96PIv8AD7D3/l9enLKtfzn4ieIv1fnyTJJ+/tUqJ/D3jF/zfzS+zsveu4+1g8Le1Sp8kNCU8JTlXipAlfy9Tpnu8w0JzT1SnqlPVa9SnTFzDAnHSnhOnFPC8U8L0r1adMOYaF5p6rTwvNPVa9SnTFzDFSpAlOC8VIEr1KdMOYYE5qRUpwWnqterTpi5hoXin7PanheKftr1KVMOYYF5p6pTwvNPVa9SnTFzDVSnhKeqU8JXqU6Ycw1Up6rTwtPVa9WnTFzDAvFSBORxTgvFSBa9SnTDmGBOelPVKeF5p6rXqU6YcwwJxUgSnKvFSBa9SnTFzDVSnqtOVakVa9WnTDmGBOKkCcjinBeKeE6V6lOmLmGhOelYGv6/5Ba1tW/e9HkB+77D3/l9ej/EGv8AkFrW1b970eQfw+w9/wCX16csq81/OfiL4i/V+fJMkn7+1Sovs94xf8380vs7L3ruPtYPC3tUqfJDFT2qRU4pyrT1Xiv5ep0z3eYaEqRUpwSnha9WnTFzDVWnhaeq08LXqU6Ycw0JzT1T2p4SnqlepTphzDFTjpTwnHSnqtPC8dq9WnTFzDQnSnhOaeFp4XmvUp0w5hirUgSnKtSBa9WnTFzDQnNPVKcEqRUr1KdMOYYqcdKeE46U9Vp4XjtXqU6YuYYE6VIF5pwWpAvNepTphzDFWpAlOVaeEr1adMOYaE5qRUpwSnqtepTpi5hoTinhOOlPC8U8LxXqU6YcwwLTwvNP208LzXq06YuYaqU8JxT1WnhK9SnTDmGhKwPEGv8AkbrW1b970eQH7vsPf+X16P8AEGv/AGfda2rfvejyD+H2Hv8Ay+vTlglfzn4i+Iv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7ODwt7VKnyQ1Up4TinqlPC8V/L1Ome7zDAtSBOelOC1IF57V6tOmHMMVOelPVaeq809Vr1KdMXMMCVIE5pwSpAlepTphzDFSpAnFOVaeF4r1adMXMNC08Jz0p4Wnhea9SnTDmGKnPSnqlPVeakVa9SnTDmGBOKeEp4SnhK9WnTFzDVSnqtPVaeq8V6lKmHMNC09U56U8JT1TmvUp0xcwxU9qeqcdKeq09V47V6lOmHMNCcU8JTwvFPC16tOmLmGKtSBKcq1Iq8V6lOmHMMCdKkCc04JUipzXqU6YuYYqe1PVOOlPVaeq8dq9SnTDmGBOOlYPiDX/s+61tW/e9HkB+77D3/l9ejvEGv+QGtbVv3vR5B/D7D3/l9enLhelfzp4i+Iv1fnyTJJ+/tUqL7PeMX/ADfzS+zsveu4+zg8Le1Sp8kMCc1IqU4LzT1Wv5ep0z3uYaq08LT1XinhK9SnTFzDVSnqlPVKeqV6lOmHMMCcVJs9qcF4qTbXq06YuYYE5p6rTwvNPVa9SnTDmGhKeEpyrxUgSvUp0xcw0JzT1SnqlPVa9WnTDmGBOKkCcjinBeKkC8ivUp0w5hgTnpT1Wnheaeq16lOmLmGKlSBKcF4qQJXq06YcwwJzUipTgtPVa9SnTFzDQvFPCcjinheKeF5FepSphzDAnPSnqlPC81Iq16tOmLmGKlPCU9V4p4SvUp0w5hqpT1Wnhaeq16lOmLmGhawPEGv/AGfda2rfvejyg/d9h7/y+vR3iDX/ACN1rat+96PKP4fYe/8AL69OXC1/OniL4i/V+fJMkn7+1Sovs94xf8380vs7L3ruPtYPC3tUqfJDQvNPVPanheaeqV/L1Ome7zDFTjpTwnHSnqvFPC8V6lOmHMNCU8JzTglSBK9SlTFzDFSpAtOVakC16tOmHMMCc1Iqe1OC809Ur1KdMXMNVOOlPCcdKeq8U8Lx2r1KdMOYYEqQJzTglPC816tOmLmGqtPC09Vp4WvUp0w5hoTmnqlPCU9Ur1KdMXMMCcVIE46U4LxUgXivUp0w5hgSnhOaeFp4XmvVpUxcwxVqQJTlWpAtepTphzDQnNPVKcEqRUr1KdMXMMCcU8Jx0p4XinheK9WnTDmGhOelPC808LzTwvNepTphzDFSsDxBr/kbrW1b970kkB+77D3/AJfXo/X9f8jda2rfvejyD+H2Hv8Ay+vTl1Wv5z8RfEX6vz5Jkk/f2qVF9nvGL/m/ml9nZe9dx9nB4W9qlT5IYFqQJzTgtSBK/l6nTPd5hipS7PapVSl2/SvSjT0DmPjpVp6pT1Snqlf0NTpn+UnMMCVIqc04J0qQJzXq06YuYYqU9U4p6pT1TivUp0w5hgSpAtOCcVIEr1KdMXMMVKkCU5Up6pXq06Ycw0LUipzTglSKlepTphzDFWnhOKeqU8JxXqU6YuYYE6U8JzTwnSpAnNepTpi5hipTwlPVKeqV6lOmHMNC08LTwtPVOa9WnTDmGKtSBOKcqVIE4r1KdMXMMCU8JzTwnSnhOa9SnTDmGKlSKtOVKkVK9WnTFzDAtYPiDX/I3Wtq373o8o/g9h7/AMvr0d4g1/yN1rat+96SSD+H2Hv/AC+vTlwlfzn4i+Iv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7WDwt7VKnyQxUqQLTlSpFSv5ep0z3eYYFp4TkU8JxTwnIr1KVMOYYE5qRUpwTmnqlerTpi5hoSnhaeqU8LXqU6Ycw0LTwtPVOaeqV6lOmLmGhKeE5p4SnhOa9WnTDmGKnNPVKeqc09Ur1KdMXMNVOKeFp6pxTwlepTphzDVWnqlOVOakVK9WlTFzDAlSBOacEqQJzXqU6YcwxU5p6pT1TmnqlepTpi5hipxUgWnKnFSBK9WnTDmGBKeqU9U5p6pXqU6Ycw0JUgSnBKkCV6lOmLmGKtPVeKeqU9U4r1adMOYYE4rA8Qa/5G61tW/e9HkH8PsPf+X16P8Qa95Aa1tW/e9JJAfu+w9/5fXpy4Tiv5z8RPEX6vz5Jkk/f2qVF9nvGL/m/ml9nZe9dx9nB4W9qlT5IYEp4WnhKeE5r+XqVM93mGKlSBKeqU8JXqU6Ycw0JT1SnhKeqV6lOmLmGBeKeF4p4TinhOK9WnTDmGhOaeE5p4TmnhOa9SnTFzDFSpAlOVKkCV6tOmHMMC1Iq04JUipXqU6YcwwLxTwlPCcU/ZXqU6YuYYE5qQJzTgnNPCc16tOmHMNVKeFp6pTwlepTpi5hoWnqtPC09Ur1KdMOYYE4qQJTwnFPCdK9SnTFzDAnNPVOaeE5p6pzXqU6YcwxUqQLTlSpAlerTphzDQtPVKcEqRUr1KdMXMMCcVg+INf8jda2rfvejyL/D7D39+316O8Qa/5G61tW/e9HkX+H2Hv/L69OXVK/nPxF8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2cHhb2qVPkhgSpFTmnBKkVOa/l6nTPe5hipT1TinqlPVOK9WnTFzDAlSBacEqQJXqU6YcwxVp6pT1SnhOK9SnTDmGhKeqc08JT1SvVp0xcw1Up4XinKlSBOK9SnTFzDAnSnheaeE6U8JzXqU6Ycw1Vp6pT1SnqlerTphzDAlSKnNOCVIEr1KdMXMMVKeF4p6pTwnFepTphzDQnSnhOacEqQJzXq06YuYYqVIEpypT1SvUp0w5hoWpFSnBKkVK9SnTFzDFWnhOKeqU8JxXq06YcwwJUgTmnbKkCc16lOmHMMVKwPEGv+RutbVv3vSSQfw+w9/5fXo/xBr3kFrW1b970eQH7vsPf+X16csqV/OfiL4i/V+fJMkn7+1Sovs94xf8380vs7L3ruPs4PC3tUqfJDVSnhKcqVIEr+XqdM93mGqlPCU8JTwlepTphzDAtSBOacEqQJzXq06YuYYqc09Up6pzT1SvUp0w5hgTipAtOVOKkCV6lOmLmGKlSBacqVIqV6tOmHMMC08JzTwlPCc16lOmLmGqnNPVKeqc09Ur1adMOYYE4p4WnqnFPCV6lOmHMNC08LT1TmnqlepTpi5hoSnhOaeEp4TmvVp0w5hqpT1TinKlSKnFepTpi5hgTinhKeE4p4SvUp0w5hoWnqlPCc09Ur1adMXMMCVIEpwSpAlepTphzDFSsDX9f8jda2rfvejyD+H2Hv8Ay+vR/iDX/s5a1tW/e9HkB+77D3/l9enLqlfzn4i+Iv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7ODwt7VKnyQwJxTwnFPCcU8JxX8vU6Z7vMMCc1IqU4JzUgTmvUp0w5hgWnhKeqU8JXqU6Ycw0JT1SnhOaeqV6tOmLmGhOKftp4TinhK9SlTDmGBOaeqU8JzTwnNepTpi5hipUgSnqlPCV6tOmHMNCU9Up4SnqlepTpi5hgXipAtOCcVIE6V6lOmHMMCc09U5p4TmnqnNerTphzDFSpAlOVKkCV6lOmLmGBakVacEqRUr1KdMOYYF4p4SnhOKeE6V6tKmLmGhOaeqc08JzT1TmvUp0xcwxUp4WnqlPCV6lOmHMNC1geINf+z7rW1b970klH8PsPf+X16P8Qa/5G61tW/e9HlB+77D3/l9enLBOa/nTxF8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2sHhb2qVPkhqpTwtPVKeqV/LtOme7zDQlPVKeEp6pXq06YuYYqU8JxT1SnhOK9SnTDmGhKeE5p4TpTwnNepTpi5hirUgWnKlSKlerTphzDAlSKlOCVIqV6lOmHMMVKeE4p6pTwnFepTpi5hgTpUgTmnBOlSBOa9WnTDmGKtPVKeqU8JxXqU6YuYaEp6pTwlPVK9WnTDmGqnFPC8U9Up4TivUp0xcwzbTwnNP2U8JzXqUqYcwxUqRUp6pT1SvVp0xcwwJUipTglSBK9SnTDmGKnFPC8U9Up4TivUp0xcw0JyKwPEGv+QWtbVv3vR5B/D7D3/l9ej/ABBr3kbrW1b970eQH7vsPf8Al9enLhOa/nPxF8Rfq/PkmST9/apUX2e8Yv8Am/ml9nZe9dx9rB4W9qlTbohipzT1SnqnNPVK/l6nTPd5hgTipAlOCcU8JXq06Ycw1Up2ypFSnbK9GNPQXMfHCpUipxTlSpAtf0PTpn+UnMMCVIqc04LUipzXqU6YcwxUp6pxT1SnqnFepTpi5hgTipAlOCcVIEr1adMOYYqU9U4p4Wnha9SnTDmGhKkVKcFp4SvUp0xcw1Up4TinqlPCcV6tOmHMMCcU8JzTwnAp4WvUp0xcw1Up4SnhaeqV6lOmHMNCU9Up4SnqlepTpi5hipUgTinKlPCcV6lOmHMNCcU8JzTwvFPC816tOmLmGKlYPiDX/I3Wtq373o8g/g9h7/y+vR3iDX/ILWtq373pJIP4fYe/8vr05dVr+c/EXxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcfaweFvapUXohipxUgSnBakC1/L1Ome7zDFSpFSnBKeqV6lOmHMNCcU8JTwnFPCdK9WlTFzDAnNSKlOC809Vr1KdMOYaEp4SnqnFPCV6lOmLmGqlPVKeqU9Ur1adMOYaEp4TmnBakCV6lOmLmGKnNPVKeqc09Ur1KdMOYYE4qQJ0pypxUgSvVp0w5hgTmpFSnKlSKtepTpi5hgSpAlOC1IEr1KdMOYYqc09Up6pzT1SvVp0xcwxU4p4SnqnFPCV6lOmLmGqlPVKeFp6rXqU6Ycw0LTwlPC08LXq06Ycw1UrA1/XvI3Wtq373o8gP3PYe/wDL69H+INf8gta2rfvejyD+H2Hv/L69OWVK/nPxF8Rfq/PkmST9/apUX2e8Yv8Am/ml9nZe9dx9nB4W9qlRadEMCcVIE4pwTipAnFfy9Tpnu8wwJTwnNPCU8JzXqUqYcwxUqQJTlWpAterTpi5hgSpFSnBakVK9SnTDmGBOKeE4p4TinhOK9SnTDmGhOaeE5p4Tmnhea9WnTFzDFSnhaeq08LXqU6Ycw0JUipTgtPVK9SnTFzDQnFPCU8JxTwlerSphzDAnNSBOacE5p4XmvUp0xcw1Up4SnqlPC16lOmHMNCU9Up4SnqlerTpi5hgTipAlOC1IEr1KdMOYYE5p6pzTwnNPVea9SnTFzDFSpAnFOVKkCcV6lOmHMMCVg+INf+z7rW1b970eRf4fYe/8vr0d4g1/7PutbVv3vSSQfw+w9/5fXpy4Sv5z8RfEX6vz5Jkk/f2qVF9nvGL/AJv5pfZ2XvXcfaweFvapUWnRDFSnqnFPVKkCV/L1Ome7zDAlPCc08LT1TmvVp0xcw1Up6pxT1SnqnFepTphzDAnFPCU8JwKeEr1KdMXMNVKeqcU9Up6rXq06Ycw0JT1Snhaeq16lOmHMMVKkCcU5UqQJxXqU6YuYYE6U8JzTwnSnhOa9WnTFzDFSpFTinKlSBa9SnTDmGBakVKcFqRVr1KdMOYYqU8JxT1SnhOK9WnTFzDAnSpAnNOCcCpAnNepTphzDFSnqnFPVaeFr1KdMXMNCVIqU4LTwlerTphzDVSnhOKeqU8JxXqU6YuYZsrB8Qa99nLWtq373o8gP3fYe/wDL69HeIdf8jda2rfvejyD+H2Hv/L69OXCV/OfiL4i/V+fJMkn7+1Sovs94xf8AN/NL7Oy967j7WDwt/wB5U+SGBOaeqU8JzT1Sv5ep0z3eYYqcVIFpwWpAtepTpi5hqpT1SnqtPVK9WnTDmGBKkCc04JUgSvUp0w5hipzT1SnqnNPVa9WnTFzDAnFSBKcF4qQJXqU6YcwxUqRUpwSnqlepTphzDQlPCc08JTwlerTpi5hqpzT1SnqnNPVa9SnTFzDAnFPCdKeqcU8JXqU6Ycw1Up6pT1SnqlerTphzDQlPCU4LUgWvUp0xcwxUqRU4pypUipXqU6YcwwJxTwnSnhOKeEr1KdMXMMCc1IqU4JzUirXq06YcwwJWD4g1/wAjda2rfvejyD+H2Hv/AC+vR3iDX/I3Wtq373o8o/h9h7/y+vTlwlfzn4i+Iv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7ODwt7VKnyQwJUipTgtSKlfy9TpnvcwwJxTwnFPCcU8JxXqU6YuYYE5qRU5pwTmpAnNerTpi5hipTwlPVKeFr1KdMOYaEp6pTwtPVK9SnTFzDQnFP2U4JxUgSvUp0w5hgTmnhOaeE5p4TmvVp0w5hipUgSnKtSBa9SnTFzDAlSKlOC1IqV6lOmHMMCcVIEpwTipAlerTpi5hgTmnqnNPCc09V5r1KdMOYYqVIFpyrTwlepTphzDQlSKlOC09Ur1adMXMNCcU8JTwnFPCV6lKmHMNCc09U5p4TmnqvNepTpi5hipWB4g17yA1rat+96PID932Hv8Ay+vR+v6/5G+1tW/e9HkH8PsPf+X16csq8V/OniL4i/V+fJMkn7+1Sovs94xf8380vs7L3ruPtYPC3tUqfJDQlPCU8LTwlfy7Tpnu8w1Up4TinKlSKlerTphzDQlPVKcEqRVr1KdMXMMVKeE4p6pTwnFepTpi5hoTpTwnNOCdKkCc16tKmHMMVKeqcU9UqQJXqU6YuYYEqQJTgtSKterTphzDFSnhOKeqU8JxXqU6YcwwJUgTmnBOlSBOa9SnTFzDFSnqnFPVKeq16tOmHMNCU9Up4WnqtepTpi5hqpTwnFPVKeE4r1KdMOYZsp4Tmn7KeE5r1aVMXMMVKkVOKcqVIFr1KdMOYYFqRUpwWpFWvUp0xcwxUrA8Qa/5G61tW/e9HkB+77D3/l9ej/EGv+RutbVv3vR5B/B7D3/l9enLqlfzn4i+Iv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7WDwt7VKnyQwJUgTmnBKeE5r+XqdM93mGqnNPVKeqc09Ur1adMOYYE4p4SnqvFPCV6lOmLmGqlO2VIq07ZXpRp6BzHxwqVIq04JUgSv6Gp0z/KTmGBKkCc04JUgTmvUp0xcwxUp6pxT1SnqnFerTphzDAnFPCU8JxTwlepTpi5hqpTwtPCU9Ur1KdMOYaEp6pTwlPCc16lOmLmGqlPCcU9Up4TivVp0w5hgXinhKeE4p4SvUp0w5hoWnhaeE5p6pXq06YuYYEqQJTglSBOa9SnTDmGKlSBOKcqU8JxXqU6YuYaF4rA8Qa/5Ba1tW/e9HkH8PsPf+X16P8Qa95Aa1tW/e9HkB+77D3/l9enLBOlfzn4i+Iv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7WDwt7VKnyQ0JzT1SnhOaeqV/L1Ome7zDAlPCU9Up4SvUp0w5hqpT1SnhOaeqV6tOmLmGhOKeF6U8JxTwnSvUpUw5hgTmnqlPCc09U5r1KdMXMNCU8JT1SnhK9WnTDmGhKeqU8JzT1SvUp0xcwwJUgWnBKkCdK9SnTDmGKnNPVKeqc09Ur1adMXMMVOKkCU5U4qQJXqU6YcwwLUipTglSKlepSpi5hgWpAtOVKkCdK9WnTDmGKnNPVKeqc09Ur1KdMOYYqcU8JT1TinhK9SnTFzDQtPVaeEp6pXq06Ycw0LWB4g1/wAjda2rfvejyL/D7D3/AJfXo/xBr/kbrW1b970eRf4fYe/8vr05YJX85+IviL9X58kySfv7VKi+z3jF/wA380vs7L3ruPs4PC3tUqfJDQlPVKeEp6pX8vU6Z7vMMCcVIE4pypxUgTivUp0w5hgSnhOafsp4TmvVpUxcwxUqQLTlSpFSvUp0w5hgSpFSnBKkVK9SnTFzDFTinhOKeqcU8JxXq06Ycw0JzTwnNPCc08JzXqU6YcwxUp4WnqlPVK9SnTFzDQlPVKeEp6pXq06Ycw0JTwnFPCU8JXqU6YuYYF5p4TmnhOaeE5r1KdMOYaqU9Up6pTwnFepTpi5hoSnqlOCVIqV6tOmHMMCVIFpwSpAlepTphzDAvNPVOaeE5p6pzXqU6YuYYqVg+INf8gNa2rfvekkg/h9h7/y+vR2v695G+1tW/e9HkB+77D3/AJfXpy6pxX86eIviL9X58kySfv7VKi+z3jF/zfzS+zsveu4+zg8Le1Sp8kMCcVIEpwTipAlfy9TpnvcwxUp6rT1SnqlepTpi5hoSnqvNPCU8JzXqU6Ycw1Up6pxT1SnqnFepTpi5hgTinhKeE4p4SvVp0w5hqpT1WnqlPCV6lOmLmGhaeEpwSpFTmvUp0w5hipUgTinKlSBOK9WnTDmGBOlPCU8JxTwnNepTpi5hipUirTglSBK9SnTDmGBKkVKcEqQJzXq06YuYYqU8JxT1SnhOK9SnTDmGBOKkCc04JxUgTmvUp0xcwxUp4WnqlPVK9WnTDmGhKeqU8JTwnNepTphzDVSsDxBr/kBrW1b970eQfw+w9/5fXo/xBr/kbrW1b970eQfw+w9/5fXpyypX85+IviL9X58kySfv7VKi+z3jF/zfzS+zsveu4+zg8Le1Spt0QwJxUgTpTgnFSBOlfy9Tpnu8wwJzT1SnhOaeqV6tOmLmGKtSBKcEqQJXqU6YcwxUqRUpwTmpFSvUp0w5hgSpAvNOCVIEr1adMXMMVeaeqU9U5p6pXqU6YcwwJxTwlPVOKeEr1KdMXMNVKeqU8JzT1SvVp0w5hoSnheaeEp4SvUp0xcw1U5p6pT1TmnqlepTphzDAnFPCU9U4p4SvVp0xcw0JT1SnhOaeqV6lOmHMNC08JTglSBK9SnTFzDFSpFSnKlSKlepTphzDAnFPCU8JxTwnSvVp0w5hgTmsHxBr/kbrW1b970klH8PsPf8Al9ejvEGv/Z91rat+96PID9z2Hv8Ay+vTlwnNfzn4i+Iv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7ODwt/3lT5IYqVIFpypTwlfy9Tpnu8w0LT1SnhKkVK9SnTDmGBOKeE4p6pxTwnFerTpi5hgTmnhOaeE5p4TmvUp0w5hqpTwtPVKeEr1KdMOYaEp6pTwlPVK9SnTFzDAnFSBOKcE4qQJXq0qYcwwJzTwnNPCc08JzXqU6YuYYqVIFpypUipXqU6YcwwJUipTglSKlerTpi5hgSpAlOCcU8JXqU6Ycw0LzT1TmnhOaeqc16lOmHMMVKeEp6pTwnFerTpi5hoSnqlPCU9Ur1KdMXMNCU8JTwlPCV6lKmHMNC81ga/r/kFrW1b970eQfw+w9/5fXo7xBr32fda2rfvejyA/d9h7/y+vTl1Tmv508RPEX6vz5Jkk/f2qVF9nvGL/m/ml9nZe9dx9rB4W9qlT5IYq09U4p6pT1Tiv5dp0z3eYaEp4SnBOKkCV6tOmLmGKlSKtOVKkVK9SnTDmGBakC04LUipzXq06YuYYqU8JxT1SnhOK9SnTDmGBKkCc04J0qQJzXqU6YcwxUp6rT1SnqlerTpi5hoWpFWnBKeqc16lOmLmGqlPCcU9Up4TivUp0w5hgTpUgTmnBOKeE5r1adMOYaqU9Vp6pTwlepTpi5hoWnhKcEqRU5r1KdMOYYqVIE4pypUgTivUp0xcwzZTwnNP2U8JzXq0qYcwxUqRVpypUipXqU6YuYYErB8Qa/5G61tW/e9HkH8HsPf+X16O8Qa/5G61tW/e9JJAfu+w9/5fXpy4Sv5z8RfEX6vz5Jkk/f2qVF9nvGL/AJv5pfZ2XvXcfaweFvapU26IYq09Up6pzUipX8vU6Z7vMMCU8JyKeEp4TmvVp0w5hqpzT1SnqnNPVK9SnTFzDFTinhaeE4p4SvUp0w5hoSnbKkVOadsr0o09Bcx8cBOakVKcEp6pX9DU6Z/lJzDQlSBOacEp4WvVp0w5hqpT1TinqlPVOK9SnTFzDAnFPCU8JxTwlepTphzDQnNPVKeE5p6pXqU6Ycw0JTwlPCU8LXq06YuYaqU8JxT1SnhOK9SnTFzDAnFPCU8JxTwlepTphzDQnNPVKcE5qRUr1adMOYYEqQJTgtSBa9SnTFzDFSsDxBr/AJG61tW/e9JJAfuew9/5fXo/xBr/AJG61tW/e9HkH8HsPf8Al9enLqlfzp4i+Iv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7WDwt7VKnyQwJxTwnSnhOKeEr+XadM93mGhOaeqc08JzT1TmvUp0xcwxUp4SnqlPCV6tOmHMNCU9Up4WnqlepTphzDQnFPCU8JxTwlepSpi5hgTmnqnNPCc09U5r1adMXMNVKeEp6pTwtepTphzDAlSKlOC1IqV6lOmHMMCcVIEpypUgSvVp0xcwxU5p6pTwnNPVK9SnTDmGKnFSBKcq8VIFr1KdMXMMCVIqU4JT1SvUp0w5hoTinhKeqU8JXq06YuYaE5p6pT1TmnqlepTphzDFTinhKeq8U8JwK9SnTDmGhKwPEGv/Z91rat+96PIP4fYe/8AL69H+INf8jda2rfvejyL/D7D3/l9enLBOa/nTxF8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2cHhb/vKnyQ1Up4TinqlPVK/l6nTPd5hoSnqlPCU8LXqU6YcwxUp4TinqlPCcV6tOmLmG7KeE5p+ynhOa9SlTDmGKlSBOKcqVIqV6lOmHMMCVIEpwSpFWvVp0xcwxUp4TinqlPCcV6lOmLmGhOaeE5p4TkU8JzXqU6YcwxUp6pxT1SnhK9SnTDmGhKeEp4WnqterTpi5hqpTwnFPVKeE4r1KVMOYYE5p4TmnhORTwnNepTpi5hqpT1TinqlPVa9WnTDmGBKkVKcFqRVr1KdMXMMVKkCU5UqQJXqU6YcwwJzWB4g17yC1rat+96PID932Hv8Ay+vR/iDXvI3Wtq373o8i/wAPsPf37fXpy4Tmv508RfEX6vz5Jkk/f2qVF9nvGL/m/ml9nZe9dx9rB4W9qlReiGKlPVOKeqU9U4r+XqdM93mGBOKkCU4LxTwtepTpi5hoSnqlPCU9Ur1aVMOYaEp4TmnhKeE5r06dMXMNVKeqcU5UqRU4r1adMOYYE4p4SnheKeEr1KdMXMNCU9Up4SnqlepTphzDAlSKlOCVIFr1adMXMMVKeE4p6pTwnFepTphzDQnFPCU8JxTwnNepTphzDAnNSKlOCU9Ur1adMXMNCVIqU4JTwtepTphzDVSnhOKeqU8JxXqU6YuYYE4qQJzTgnFSBOa9SnTDmGKnNPVKeE5p6pXq06YuYaErA8Qa/wDZ91rat+96SSD+H2Hv/L69H+INf8jda2rfvejyD+H2Hv8Ay+vTlglfzn4i+Iv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7WDwt7VKnyQ1Up6pTwtPVa/l6nTPd5hgTipAnSnBOKkCV6tOmLmGBOaeqc08JzT1SvUp0w5hipUgSnKlSBK9SnTFzDFSpFSnBakVK9WnTDmGBKkCU4LUgSvUp0w5hipzT1SnqnNPVK9SnTFzDFTinhOlPVOKeFr1adMOYaEp6pTwlPVK9SnTFzDQnFPCU8JTwlepTphzDVTmnqlOCc1IqV6lOmLmGKnFPCU9U4p4WvVp0w5hoSnqlOCVIqV6lOmHMMCcVIEpypUgSvUp0xcwxUp6pTwlPVK9WnTDmGhOKwPEGveRutbVv3vR5Afu+w9/wCX16P8Qa/5Aa1tW/e9HkH8PsPf+X16csE4r+c/EXxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcfZweFvapU+SGBKkCc07bUgTmv5ep0z3eYYqU8JxT1SnhK9WnTDmGhKeqU8JTwtepTpi5hoTinhOKeqU8JxXqU6YcwwJzTwnNPC808JzXq06Ycw1Up4TinqlPVK9SnTFzDQlPVKeEp4WvUp0w5hgSpAlOVKkCV6lOmLmGBOaeE5p4TmnhOa9SnTDmGKlSBOKcqVIqV6tOmLmGBKkCU4JUirXqU6YcwwJTwlPVKeEr1KdMOYaE5p6pzTwnNPVOa9WnTFzDFSnhOKeqU8JxXqU6Ycw0JTwlPC09Vr1KdMXMNVKwPEGv8AkbrW1b970eUfw+w9/wCX16O8Qa/5G61tW/e9JJB/B7D3/l9enLqlfzn4ieIv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7ODwt7VKm3RDQlPVOaeFp4Tmv5fp0z3uYYqU9U4p6pT1TivUp0xcwwJxUgSnBOKkC16lOmHMMVKkCU4LUipXq06YuYYEqRUpwSpFSvUp0w5hipTwnFPVKeE4r1KdMXMMCcVIE5pwXipAterSphzDAlPVKeEp6pXqU6Ycw0JTwnNPCU9Ur1KdMXMNVKeE4p6pTwnFerTpi5hgTinhOaeF4p4TmvUp0w5hqpT1SnqnNPVK9SnTDmGBKkVKcEqQLXqU6YuYYqVIE4pyrUgTivVp0w5hmynhOafsp4TmvUpUxcwxU5rB1/X/I3Wtq373o8gP3fYe/8vr0d4g1/yC1rat+96PIP4fYe/wDL69OXVK/nPxE8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2sHhb2qVNuiGKlSBKcqcU8JX8vU6Z7vMNCc09Up6pT1WvVp0w5hoSnhKeFp4SvUp0xcw1U5p6pT1TmnqlerTphzDFTinhKeqcU8JXqU6YuYaqU7ZUgWl2/SvSjT0DmPjkJzUipTgnNSKlf0LTpn+UnMMVakC04JxTwterTpi5hqrT1WnqlPVPavUp0xcwwLx3qQJ0pwTjpTwntXqU6Ycw0JzT1WnhOaeqV6tOmHMNVaeFp4SnhK9SnTDmGqlPVeKeqU9Ur1KdMXMMC8U/ZTwnFP2e1erTpi5hoXmnqtPCc09Vr1KdMOYYq1g+INf8jda2rfvejyL/D7D3/l9ejvEGv8AkbrW1b970eQH7nsPf+X16cuE4r+c/ETxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcfaweFvapU+SGBakVacFqRUr+X6dM93mGBKeFp4TinhK9OnTFzDQvNPVeaeE56U9U56V6tOmHMMVaeF4p6p7U8JxXqU6YuYaFp6pTwlPVK9SlTDmGhKeFp6pTwlerSpi5hoXmnqvPenhOelPVOelepSphzDFWnheKeqe1PCcV6lOmLmGBakVKcEqQJzXqU6YcwwJUgWnKlSBa9WnTDmGBeakVacE5qRU9q9SnTFzDFXjvTwvFPVOOlPCcdK9SnTDmGBKkVKcEqQJzXq0qYuYYq08LT1Snha9SnTDmGheaeq08JzT1T2r1KdMXMMVeO9YPiDX/IDWtq373o8g/h9h7/AMvr0dr+v+RvtbVv3vR5Afu+w9/5fXpy4TjpX86eIviL9X58kySfv7VKi+z3jF/zfzS+zsveu4+1g8Le1Sp8kMC9KeE5p4TjpTwnNfy9Tpnu8w1Up4SnqnNPVK9SnTDmGBakC04LUgTmvVp0xcwxVqQLxTlSpAnFepTpi5hm2nhOafsp4TmvUpUw5hipUirTlTmpFSvUp0w5hgWpAtOC1IE5r1adMXMMVKeF4p6pTwnFepTphzDQvSnheaeE6U8Jz0r1KdMXMMVeaeq09U56U9Vr1adMOYaFp6rTwtPCc16lOmLmGqlPCcU9Up4TivUp0w5hgXpUgXmnBKkCc9K9WnTDmGKvNPVaeqc9Keq16lOmLmGBakC04JUgTmvUp0w5hipWD4g1/wAgNa2rfvejyL/D7D3/AJfXo7xBr/kbrW1b970eQH7vsPf+X16cuqV/OniL4i/V+fJMkn7+1Sovs94xf8380vs7L3ruPs4PC3tUqL0QwJUgWnBOKkCV/LtOme7zDFWnqtPVaeqe1erTphzDAvHepAtOCcdKkCV6lOmHMMC809Up4TmnqlepSpi5hoSnhaeE4p4WvVp0xcw1Vp6rT1WnqntXqU6YcwwLx3p4WnhOOlPCdK9WnTDmGhOaeqU8JzT1SvUp0xcwxVqQLTgnFSBa9SnTDmGKtSBeKcqVIqcV6lOmLmGBeKfsp4Tin7K9SnTDmGBOakVKcE5qRUr1adMXMMVakC04JxTwtepTphzDVWnqvFPVKeqcV6lOmHMNC8U8LzTgnFSBOelerTpi5hgTmsDX9f8AI32tq373o8g/h9h7/wAvr0f4g1/yC1rat+96PID932Hv/L69OXVOelfzn4i+Iv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7WDwt7VKi9EMVKeF4p6p7U8JxX8vU6Z7vMNC09Vp4WnqlerTpi5hgXipAlOCcVIEr1KdMOYYF5p6rzTwnPSnqnPSvUp0xcwxUqQLxTlT2qQJxXq06YcwwLUirTgtSKlepTpi5hipUgSnBOKkCV6lOmHMMC809Vp4TmnqntXqU6YcwxV4708LxT1TjpTwnHSvVp0xcw0LT1SnhKeqV6lOmHMNVKeEp6pTwlepTpi5hoXmnqtPCc09U9q9WnTDmGKvHenheKeqcdKeE46V6lOmLmGhKeqU8JTwnNepTphzDAlSBacqVIFr1adMOYYFrB8Qa/5G61tW/e9JJB/D7D3/AJfXo7xBr/kbrW1b970eQfw+w9/5fXpy4Sv5z8RfEX6vz5Jkk/f2qVF9nvGL/m/ml9nZe9dx9nB4W9qlReiGKtPC8U9Vp4Tiv5ep0z3eYbtp4Xmn7PanhOa9SnTDmGKlPVKeqU9Ur1KdMXMNCU9V5p4SnhK9WnTDmGqtPC8U9Up4TivUp0xcw0L0p4XmnhPanhOelepSphzDFSnhKeqc9KeqV6tOmLmGBakC04LUgTmvUp0w5hirUgTinKlSBOK9WnTDmGBelPC808J0p4TnpXqU6YuYYqVIq05U56VIqV6lOmHMMC1IFpwWpAnNerTpi5hipTwlPVKeE4r06dMOYaFp6rzTwlPVOelerTpi5hir9aeq8U9U9qeqcdK9SnTDmGhawPEGv/Z91rat+96PKP4fYe/8vr0f4g1/yA1rat+96PID932Hv/L69OWC1/OfiL4i/V+fJMkn7+1Sovs94xf8380vs7L3ruPtYPC3tUqL0Q0LzT1WnheaeqV/L9Kme5zDQlPCU4JxUgSvUp0w5hirUirxTlSpFT2r1KdMOYYF4708LTwnHSnha9WnTFzDAvNSKlOCc1IqV6lOmHMMCVIFpwTipAlepTpi5hirTwvFPVaeqcV6tOmHMNC8U8LTwnHSn7K9OnTFzDAvNPVKeE5p6pXq06Ycw0JTwtPCcU8LXqU6Ycw1Vp4XinqtPVOK9WnTFzDAvFSBeacE46VIE56V6lOmHMMCc09Up4TmnqlepTpi5hirUgWnBOKkC16tOmLmGKtSBeKcqVIE4r1KdMOYYF4rA8Qa/wCRutbVv3vR5B/D7D3/AJfXo/xBr/kbrW1b970eQH7vsPf+X16cuE6V/OfiJ4i/V+fJMkn7+1Sovs94xf8AN/NL7Oy967j7WDwt/wB5UWnRDAvPenqvNPCc9Keqc9K/l6nTPd5hipTwlPVKeE4r1adMXMNC1Iq04LT1WvUp0w5hoWnhKeqU8JXqU6Ycw1V5p6rT1TmnqntXqU6YuYYq8U8LxT1TjpTwnHSvVp0w5hoWnbKkC0u3616UaeguY+OQnNPVaeF5p6rX9DU6Z/lJzDQtSBacFp4SvUp0w5hoSnqlPVaeq16lOmLmGBeKeF6U8LxTwvSvVpUw5hoXmnqtPC809Vr1KdMXMMVeKkCU8LTwlepTphzDVSnqlOC1Iq16tOmHMMC8U/bTwvFP216lOmLmGheawPEGv+QWtbVv3vR5B/D7D3/l9ejvEGv+QWtbV/3vR5B/D7D3/l9enLhea/nTxE8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2cHhb2qVF6IYq1IFpyrUirX8u06Z7vMMC1IEpwWpFWvVp0w5hipTwlPVaeFr1KdMOYaF5p6rz2p4XmnqvNepTpi5hirTwvFPVaeF4r1adMOYaEp6pTwlPC16lOmLmGqlPC05VqQLXqU6YcwwLzUirz2pwXmpFXmvUp0w5hirTwvFPVaeq8V6lOmLmGBKkVKcFqRVr1adMOYYq1IFpyrUgWvUp0xcwwLzT1Snhaeq16lOmHMNVeKeF4p6rTwvFerTpi5hgSnheaeFp4XmvUp0w5hqrTwtPVaeFr1KVMOYaF5rA8Qa/5Ba1tW/e9HkX+H2Hv/L69H+INf8AI3Wtq373o8i/w+w9/ft9enLBa/nTxF8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2cHhb2qVF6Iaq08JxT1WnheK/l6nTPd5hgXinheaeF4p4XmvUp0w5hqrzT1Wnheaeq16tOmLmGBakVacFqQLXqU6YcwxUqQJxTlWnheK9SlTFzDdlPC808LTwvNepSphzDAvNPVaeF5p6rXq0qYuYaFqRVpwWnhK9SnTDmGqlPCcU9Vp4XivUp0xcw0LTwvPanhaeF5r1adMOYYq809Vp6rzT1WvUp0w5hoWnhKeFp4SvUp0xcw1Up4XinKtSBeK9WlTDmGBakC89qcFqQLzXqU6YuYYq809Vp6rzT1WvUp0w5hgWsHxBr/2fda2rfvekkg/h9h7/AMvr0d4g1/7OGtbV/wB70kkH8PsPf+X16cuFr+dPEXxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcfZweFvapUXohirUipTgtSKtfy7Tpnu8wwLUgWnKtSBa9WnTDmGKtPVaeq09Vr1KdMOYYF4qQL0pwXipAvSvUp0xcwwJzT1Snheaeq16tKmHMNVaeFp6rTwtepTpi5hqrT1Wnhaeq16tOmLmGBeKeF6U8LxTwvSvUp0w5hoXmnqlPC809Vr1KdMOYYFqQLTlWpAterTphzDFWpFSnKtSKtenTpi5hgTin7aeF4p+2vVp0xcwwLzT1Wnheaeq16lOmHMNC1IFpwWnhK9SnTFzDQlPVKeq09Vr1adMOYYE4rB8Qa/5G61tW/e9HkH8PsPf+X16P8AEGv+QGtbV/3vR5B/D7D3/l9enLBa/nPxF8Rfq/PkmST9/apUX2e8Yv8Am/ml9nZe9dx9rB4W9qlT5IaF5p6rz2pwXmpFXmv5epUz3eYYq08LxT1WnheK9WnTFzDQtPVacFqRVr1KdMOYYqVIEpwWpAtepTpi5hgXmnqvPanheaeq816tOmHMMVakC8U5VqQLxXqU6YuYYFqQJTglSKtepSphzDFSpAtOVaeFr1KdMOYaF5p6rTwvNPVa9WnTFzDFXjtTwvFPVeKeF4r1KdMOYaFp4SnhaeF5r1KdMXMNVKeFpyrUgWvVp0w5hoXmnqtPC09Vr1KdMXMMVeKeF4p6rxTwvFepTphzDAtSBKcFqQLzXq06YuYYq1g+INf8jda2rfvejyj+H2Hv/L69Ha/r/kbrW1b970klH8PsPf8Al9enLKtfzn4i+Iv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7WDwt7VKnyQ0LUirTgtSKtfy9Tpnu8wxVp4XinqtPC8V6lOmHMN2U8LzT9tPC816lOmLmGKvNPVKeF5p6rXq06Ycw0LT1WnhaeFr1KdMXMNVaeE4p6rTwvFepTphzDAnSpAvPanBakC816tOmLmGKtPVaeq809Vr1KdMOYYFqRVpwWpAterTpi5hipUgTinKtPC8V6lOmHMNCU8Lz2p4Wnhea9SnTDmGKvNSKtOVeakVa9WnTFzDAtSKtOC08JXqU6Ycw1Up4WnqtPVa9SnTFzDQtPVeaeFp6rzXq06YcwxV+lYGv6/5Aa1tW/e9HkH8PsPf+X16P1/X/I32tq/73o8g/g9h7/y+vTl1Wv5y8RfEX6vz5Jkk/f2qVF9nvGL/m/ml9nZe9dx9nB4W9qlT5IYF47U8L0p4Xinha/l+lTPe5hoXmnqlPC809Vr1KVMXMMCVIEpyrUgWvUpUxcwxVqRVpyrT1WvVp0w5hoXjtTwvSnheKeFr1KdMOYYF5qRUpwXmpFWvUp0xcwwLUgWnKtSBa9SnTDmGKtPC8U9Vp6rXq06YuYYE4qQLTgvFSBa9SlTDmGBeaeqU8LzT1WvUp0xcw1Vp4WnqtPC16tOmHMNVaeF4p4WnqtepTphzDAnFSBeacF4qQLyK9SnTFzDAvNPVaeF5p6rXq06YcwwLUgWnKtSBa9SnTFzDFWsHxBr/kbrW1b970eQfwew9/5fXo7xBr/kFrW1b970eQfwew9/5fXpy6rX85+IniL9X58kySfv7VKi+z3jF/zfzS+zsveu4+1g8Le1Sp8kMC8U8JTwtPC1/L9Kme7zDQnNPVee1PC809V5r06dMOYYq08LxT1WnheK9WnTFzDQtPVaeFp4WvUp0xcw0LxTwlPVaeFr1KdMOYaF5p6rTwvNPVa9WnTDmGKvHanheKeq8U8LxXqU6YuYaFpdntUoWl2V6Uaegcx8cheaeq08JzT1Sv6Gp0z/ACj5hqpTwlPCcU8JXqU6Ycw1V5p6rTwlPVa9WnTDmGBeKeF6U8Jx0p4TjpXqU6YuYaF5p6pTwnNPVK9WnTDmGKlSBKcqVIFr1KdMXMMVeakVacq1IqV6lOmHMMC8VgeIdf8AI3Wtq373o8i/w+w9/wCX16P8Qa/5G61tW/e9JJAfuew9/wCX16csF4r+dPEXxF+r8+SZJP39qlRfZ7xi/wCb+aX2dl713H2sHhb/ALypt0Q0LyKeF5p4TkcU8Jz0r+XadM93mGKtPVKeqU8JxXq06YuYaEp6rzTwlPCV6lOmLmGqtPC09Vp4SvUp0w5hoXmnqvPenhOaeqc9K9WnTDmGKtPVOKeqe1PVOOlepTphzDQlPVeaeFp6rXqU6YuYYq1IFpypUgSvVp0xcwwLyKkVeacE5qRU56V6lOmHMMVaeE4p6p7U9U46V6lOmLmGBakC04LUgTmvUp0w5hirUgSnKlPCcV6tOmHMNCU9Vp4SnqtepTphzDVXinheO9PVPanhOOlepTpi5hgWnheaeFp4TmvVpUxcw1UrA8Qa/wCQGtbVv3vSSRf4fYe/8vr0f4g1/wAjda2rfvejyA/d9h7/AMvr05ZUr+c/EXxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcfaweFvapU+SGhKeEp4SnhOa/l6nTPd5hqrTwvFPVKeF4r1KdMOYYF4p4XmnhOOlPCc9K9SnTFzDQvNPVacE5qRUr1adMXMMCVIEpwTipAlepTphzDFWpAvFOVaeF4r1KdMOYaFp4XmnhKeE56V6tKmLmGBeaeqU8JzT1SvUp0w5hoSnhaeE4p4SvUp0xcw1Vp4XinqtPCcV6tOmHMNC08Lz3p4TpTwnPSvUp0xcwxV5p6pT1TnpT1T2r1KdMOYYEqQLTgnFSBa9WnTDmGqtPC8U5VqQJxXqU6YuYYEqQLz3pwSpAnPSvVp0w5hirzWBr+v+RvtbVv3vR5B/D7D3/l9ej9f1/yC1rat+96PID932Hv/AC+vTllT2r+c/EXxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcfZweFvapU+SGKvFSBKcqcdKeE46V/L1Ome7zDQtSKtOCU9Vr1KdMOYaq08LT1SnhK9SnTDmGqvNPVaeE5p6pXq06YuYYF4p4WnhOOlPCdOK9SnTFzDQvNPVaeF5p6rXqUqYcw0LTwlOVKkCV6tOmHMNVeaeq09Up6pXqU6YuYYF4p4XpTwnHSnhOnFepTphzDQvNPVaeF5p6pXq06YuYYFqQJTgnFSBK9SnTDmGBeakVacqU9Vr1KdMXMNC8U/bTwvFP2e1epTphzDAvNPVaeE5p6pXq06Ycw1Up4SnhOKeEr1KdMXMNVeawPEGv+RutbVv3vR5B/D7D3/l9ej/EGv/Z91rat+96PID932Hv/AC+vTllSv5z8RfEX6vz5Jkk/f2qVF9nvGL/m/ml9nZe9dx9nB4W9qlT5Iaq08LT1Snha/l6nTPe5hgXmpFXnvTgnPSpFTnpXqU6YuYYq08LxT1T2p4TivVp0w5hgSpAvNOCdKkVK9SnTFzDFWpAtOVakC16lOmHMMC809V5708Jz0p6pz0r1adMXMMVakVOKcqe1PCcV6lOmHMNCU9V5p4TpTwlepTphzDVWnhaeq08JXq06YuYaF5p6rTwnNPVK9SnTDmGKvFPCcU9U46U8Jx0r1KdMXMNC08LzTwtPC816tOmHMMVakCU5UqQJXqU6YuYaEp6rTgnNSKlepTphzDFXinheKeqe1PCcdK9WnTFzDAtYPiDX/s5a1tW/e9HkH8HsPf8Al9ejvEGv+RutbVv3vR5Afu+w9/5fXpy4TnpX85+IniL9X58kySfv7VKi+z3jF/zfzS+zsveu4+1g8Le1SovRDAvNSKtOC809Vr+XqdM93mGhakC04JTwnNepTphzDVSnheKeqU8JxXq06YuYYFqQLzTgtSBOelepTphzDAvNPVaeF5p6pXqU6YuYaEp4SnhKeE5r1adMOYaq08LxT1SnheK9SnTFzDAvSpAvPenBakCc9K9SlTDmGKvNPVaeqc9KeqV6tOmHMMCVIEpwTipAlepTpi5hirUgXinKtPC8V6lOmHMNC08Lz3p4TpTwnPSvVp0xcwxV5p6pT1TnpT1SvUp0xcw0JTwtPCcU8JXqU6Ycw1Vp6rT1WnqlerTphzDQtYHiDX/s5a1tW/e9HkH8HsPf+X16P8Qa/wCRutbVv3vR5R/D7D3/AJfXpywWv5z8RPEX6vz5Jkk/f2qVF9nvGL/m/ml9nZe9dx9rB4W9qlRadENVaeq09Up6pX8vU6Z7nMMC8d6eE6U8Jx0p4T2r1KdMOYaE5p6rTwnNPVK9SlTDmGKtSBacEqQJXqU6YuYYq81Iq05Up6pXq06Ycw0LxTwnSnhOOlPCdOK9SnTFzDAvNSKtOCc09Vr1KdMOYaq08LT1SnhK9WnTFzDVSnqvFPCc09Ur1KdMOYYF4qTbTgvFSbPavUp0w5hgXmnqtPC809Vr1adMXMNC08JTlSpAlepTpi5hqpT1WnqlPVK9SnTDmGBeKkC8inBeKkCcjivVp0xcwwLzT1WnhOelPVK9SnTDmGKlYPiDX/I3Wtq373o8i/w+w9/5fXo7xBr/AJG61tW/e9JJAfuew9/5fXpy6pxX85+IniL9X58kySfv7VKi+z3jF/zfzS+zsveu4+1g8Le1SovRDAtSKlOCVIE5r+XqdM93mGBKeFp6pTwlepSpi5hoXmnqvPenhOelPVOelerTphzDFWnheKeqe1PVOK9SnTFzDQlPVKeEp6pXq06Ycw1Vp4WnqlPC16lOmHMNC809Vp4TmnqntXqU6YuYYq8d6eF4p6px0p4TjpXq06YuYYEp2ypAnSnbK9GNPQOY+OQvNPCU8JTwnNf0PTpn+UnMNVKeFp6pTwtepTphzDVWnqtPC09Ur1KdMXMMC8U8LxTwnFSBOK9WlTDmGBeaeq808JzTwnNepTphzDFSpAtOVKkC16lOmLmGKtYPiDX/ACN1rat+96PIP4PYe/8AL69HeINf8jda2rfvejyL/D7D3/l9enLha/nTxF8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2cHhb2qVFp0QxVp4XinqtPCcV/LtOme9zDQtPC808JTwnNerTpi5hirT1XinqnNPVK9SnTDmGhaeq08LUgWvUp0xcwxVp4WnqlPVK9WnTDmGhKeq808JT1TmvUp0xcwxV+lPVeKeq09U4r1KdMOYYFqRVp4SnhK9WnTDmGKtSBKcqVIEr1KdMXMMCVIq804JUgXmvUp0xcwxV+lPVeKeq09U4r1adMOYYFqRVpwSpAlepTpi5hipTwlPVKeq16lOmHMNCU9Vp4WpAtepTphzDFWnheO1PVKeE4r1adMXMMC9KwPEOv+RutbVv3vR5F/h9h7/y+vR/iDX/ACA1rat+96PIP4fYe/8AL69OXCV/OfiJ4i/V+fJMkn7+1Sovs94xf8380vs7L3ruPtYPC3/eVFp0QwLzT1WnhOaeqV/L1Kme7zDAlSBKeEp4WvUp0xcwxVqQLxTwtPVa9SnTDmGBeKeF5p4TipAnIr1adMOYYF5p6rTwnNPVK9SnTFzDAlSBKcq1IFr1KdMOYYq08LxTwtPVK9WlTFzDQtPC808JxTwnIr1KVMOYYF5p6rTwnNPVK9SlTFzDQtPC09Vp4WvVp0w5hqrTwvFPVaeqV6lOmLmGBKkCc08JTwnIr1adMOYYq89qeq09U5p6pXqU6YuYYF4qQLT1Tinha9SnTDmGKtSKlOCVIqV6tKmHMMCVgeINf8jda2rfvejyL/D7D3/l9ej/ABBr/kBrW1b970eQfw+w9/5fXpy4Sv5z8RPEX6vz5Jkk/f2qVF9nvGL/AJv5pfZ2XvXcfZweFvapUXohipzT1WnhOakVK/l6nTPd5iNV47VIF4p6rxTwnFepTphzDAtPVaeEqQLXqU6YcwwLxTwlPVKeEr1adMXMNVKeq08LT1SvUp0w5hgXinhelPC8VIE4r1KdMXMMC809Vp4SnhOa9WnTFzDAvFSBKcqVIFr1KdMOYYFqRVp4WnqtepTphzDAvFPC8U8LxTwnFerTpi5hoXmnqtPCc08JzXqU6YcwxUqQLTlSpAtepTpi5hirT1WnhakVa9WnTDmGBeKfsp4TinhK9SnTFzDAvNPVeaeE5qQJzXq06YcwxUrA8Qa/5G61tW/e9HkH8PsPf+X16P1/X/I3Wtq373pJIP4fYe/8vr05ZUr+cvEXxF+r8+SZJP39qlRfZ7xi/wCb+aX2dl713H2sHhb2qVFp0Q0JTwtPC08LX8vU6Z7nMMVakC09Vp4WvUp0w5hgTmpFXmnBKkVOa9WlTDmGKtPVeKeqU9U4r1KdMXMMC1Iq04JUgWvUp0w5hirUgWnKtSKlerTpi5hgTmnqvNPCVIqc16lOmHMRqv0p6rxUipT1TivUp0xcwwLT1WnhKkC16tKmHMMVaeFp6pT1SvUp0w5hoSnqtPCU9U5r1KdMXMMVaeF47U9VqQLxXq06YcwwL0p4XmnhOlPCc16lOmLmGKtSBKcqVIEr1adMOYYEqRVpwWpAtepTpi5hirWB4g1/yA1rat+96PIP4fYe/wDL69H6/r/kbrW1b970eQfw+w9/5fXpy6pxX85+IviL9X58kySfv7VKi+z3jF/zfzS+zsveu4+1g8Le1SotOiGBeKeF5p4Xinhea/l6nTPd5hgXmnqtPCc1IqV6lOmLmGBaeEp6pTwlerTphzDVWnheKeqU8LXqU6YcwwLUgXmnhaeE5FepTpi5hgXmnqtPCc09Ur1adMOYYEqQJTwlPC16lOmLmGKtSBeKeFp4WvUp0w5hgWpAvNOCVIE5r1adMXMMVeaeq09U5p6pXqU6YcwwJUgSnKnFSBa9SnTDmGKtPC8U8LT1SvVp0xcw0LTwnNPCU8JzXqU6YcwxV5p6rUipzT1SvUp0xcwwLxTwtPVOKeFr1adMXMNVawPEGv8AkbrW1b970kkH8HsPf+X16P8AEGv/AGfda2rfvejyj+D2Hv8Ay+vTllSv5z8RPEX6vz5Jkk/f2qVF9nvGL/m/ml9nZe9dx9rB4W9qlTbohirxUgWnhaeEr+XqdM97mGhKeqU9Up6pXqU6YuYYF4p4XpTwnFPC8V6tOmLmGBeakVaeEp4WvUp0w5hirxUgSnKlSBK9SnTDmGKlPVKeEqRUr1KdMXMMC8U8L0p4XinheK9SnTDmGBeaeq08JzUipXq06YuYYF4p4SnqlPCV6lOmHMNVKeq08LT1SvUp0xcwwLxUm2nheKeEr1aVMOYYF5p6rTwnNPCc16lOmLmGBeKkCU5UqQLXqU6YcwwLUirTwtPVa9WnTFzDAvFSBacF4qQJXqU6YcwwLzWBr+v+RvtbVv3vR5B/D7D3/l9ej/EGv+QWtbVv3vR5B/D7D3/l9enLqnNfzn4ieIv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7WDwt7VKm3REarUgXinqlPVOK/l6nTPd5hgSpFSnBKkC16lOmLmGKtPC09Up4WvVp0w5hoXmnqvNPCU9U5r1KdMXMMVaeF4p6pT1TivVp0w5hoSnhaeEp4WvUp0xcwxVqQLT1Wnha9SnTDmGhKeqU8JT1TmvVp0w5hirxTwvHanqlPCcV6lOmLmGBadt+tShOlLs9q9KNPQXMfHOynhOaeEp4Tmv6Gp0z/KXmGqlPCU9Up4TivUp0xcw0JT1SnhKeqV6tOmLmGKnFSBOKcE4p4TivUp0w5hoTmnhOaeE5p4TmvUp0w5hipWD4g1/wAjda2rfvejyKfuew9/5fXo7X9e8jfa2rfvejyA/d9h7/y+vTl1Sv5z8RfEX6vz5Jkk/f2qVF9nvGL/AJv5pfZ2XvXcfZweFvapU+SGBKkCU4JUgSv5ep0z3eYYqVIE4pypTwnFerTphzDQnSnhOaeEp4TmvUp0xcwxU5p6pT1TmnqlepTphzDQlPCU8JxTwlerTphzDVSnqlPVKeqcV6lOmLmGhOlPCc08JT1TmvUp0w5hipT1TinqlPVOK9WnTFzDQnFPCU4JxUgSvUp0w5hipUipTlSpFSvUp0xcwwJUgTmnBKkVOa9WnTDmGKlPVOKeqU9U4r1KdMXMMCcVIEpwTipAlepTphzDFSnqlPCU8JXqU6Ycw0LT1TmnhKkVK9WnTFzDFSsDxBr3kBrW1b970eQH7vsPf+X16P8AEGv+RutbVv3vR5Afu+w9/wCX16csqV/OfiL4i/V+fJMkn7+1Sovs94xf8380vs7L3ruPtYPC3tUqfJDAnFSbKcE4qTZX8vU6Z7vMMCc09Up4TmnqlepTpi5hipUgSnKlSBK9SnTDmGKnNSKlPVKeqV6tOmLmGBOKkCcinBOKkCV6lOmHMMCc09Up4TmnqlepTphzDFSpAtOCVIEr1adMXMMVOakVKcqU9Ur1KdMXMNCcU8JyKeE4p4TpXqUqYcwwJzT1SnhOaeqV6tOmHMNVKeEp6pTwlepTpi5hqpzT1SnhOaeqV6lOmHMNCU8JzTglSBK9WnTFzDFTmnqlPVOaeqV6lOmHMMCcVIEpypxUgSvVp0xcwxU5rB8Qa/5G61tW/e9HkH8PsPf+X16O8Qa/9n3Wtq373pJIP4fYe/8AL69OXCc1/OXiJ4i/V+fJMkn7+1Sovs94xf8AN/NL7Oy967j7WDwt/wB5U+SGKlSBKcqVIEr+X6dM93mGBOaeqU8JT1SvUp0w5hqpxTwnFPVOKeE4r1KdMXMMCVIE5pwTpTwnNerTphzDVSnhKeqU8LXqU6YuYaEp6pTwlPVK9SnTDmGBOKkCcU4JxUgTivVp0xcwwJTwnNP2U8JzXqUqYcwxUqQJTlSpAlepTpi5hgWpFSnBKkVK9WnTDmGBOKeE4p4TinhOK9SnTDmGhOaeE5p4TmnhOa9SnTFzDFSpAlOVKeEr1KdMOYaEqRUpwSnqlerTpi5hoTinhKeE4p4SvUp0w5hgTmsHxBr3kFrW1b970eQH7nsPf+X16O8Qa95G61tW/e9HkB+77D3/AJfXpy4Tmv5z8RPEX6vz5Jkk/f2qVF9nvGL/AJv5pfZ2XvXcfZweFvapU+SGKnNPVKeqc09Ur+XqdM93mGhKeFpwSpAlerTphzDVSnqlPVKeqcV6lOmHMMCVIqc04JUipzXqU6YuYYqU9U4p6pT1TivUp0xcwwJUgSnBOKkCV6tOmHMMVKkCcU5Up6pxXqU6Ycw0J0p4TmnhKeqc16lOmLmGqlPVOKeqU9U4r1adMOYYE4p4SnhOKeEr1KdMXMNVKeqU9Up6pxXqU6Ycw0JTwlPC09Ur1adMOYYqVIE4pypUgTivUp0xcwwJTwnNPCdKeE5r1KdMOYYqVIqU5UqRUr1adMXMMCVg+INf+z7rW1b970eQfwew9/5fXo7xBr/kbrW1b970eUfw+w9/5fXpy4Sv5z8RfEX6vz5Jkk/f2qVF9nvGL/m/ml9nZe9dx9rB4W9qlT5IYEqRUpypUipX8vU6Z7vMMCcU8JzTwnFPCcivUp0xcwwJzUipTgnNSKlerTphzDFSnhKeqcU8LXqU6YuYaEp6pT1SnqlepTphzDQnFPCc04JxUgTkV6tOmHMMCc09Up4TmnqlepTpi5hipUgSnKlSBK9SnTDmGKnNSKlPVKeqV6tOmLmGBKkCc04JUgTmvUp0w5hipzT1SnqnNPVK9SnTFzDFTipAlOCcVIE6V6tOmHMMVOakVKcqU9Ur1KdMXMNCU8JzTwlPCV6lOmHMNVOaeqU9U5p6pXqU6YcwxU4rA8Qa95G61tW/e9HkB+77D3/l9ej9f17yA1rat+96PID932Hv/L69OWCcV/OniL4i/V+fJMkn7+1Sovs94xf8380vs7L3ruPs4PC3tUqfJDQlPCU8JTwnNfy9Tpnu8w1Up4SnKlSBK9SnTDmGhOaeqU8JT1SvUp0xcwwJxTwnFPCcU8JxXq06Ycw0JTwnNPCU8JzXqU6YuYYqVIEpypUgSvVp0w5hgTmpFSnBKkVK9SnTFzDAnFPCcU8JxTwnFepTphzDAnNSBOacE5qQJzXqU6YcwxUp4SnqlPC16lOmLmGhKeqU8JT1SvVp0w5hoTin7KeE4p4SvUp0xcwwJzTwnNPCc08JzXqU6YcwxUqQJTlSpAlerTpi5hgWpFSnBKkVK9SnTDmGBOKwPEGv+RutbVv3vR5Afu+w9/5fXo/xBr/kbrW1b970eQfwew9/5fXpy4Tiv5z8RfEX6vz5Jkk/f2qVF9nvGL/m/ml9nZe9dx9nB4W9qlTbohgTpUipzTglSKnNfy9Tpnu8wxUp6pxT1SnqnFepTphzDAlSBKcEp4SvVp0w5hqpT1SnqlPCcV6lKmLmGhKeqc08JTwnNerTphzDFSnqnFPVKeqcV6lOmLmGhKeEp4TinhK9SnTDmGqlPVKeqU9U4r1adMXMNCU9UpwSpFSvUp0w5hipTwnFPVKeE4r1KdMOYaE6Uu36VIEpdlelGnoLmPjrbTwnNP208JzX9DU6Z/lJzDVSnhKcqVIqV6lOmHMNCU8LTglSKlerTpi5hipTwnFPVaeF4r1KdMXMNCc1geINf8gta2rfvejyD+H2Hv8Ay+vR/iDX/I3Wtq373o8g/h9h7/y+vTlwvNfzn4ieIv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7WDwt7VKnyQxV5p6pT1Tmnqlfy9Tpnu8wwJUgSnBOKeEr1adMOYaqU8LT1SnhK9SnTFzDQlPCc08LTwvNepTphzDFTmnqlPVOaeqV6tOmLmGhOKeEp4TinhK9SnTDmGhaeFp6pT1WvUp0w5hoWnhOaeEp4TmvVp0xcwxUp6pxT1SnqnFepTphzDAnFSBacE4qQJXqU6YuYYFqRUpwWpAterTphzDAtSBOacEqQJzXqU6YuYYqU9U4p6pT1TivUp0w5hgTipAtOCcU8JXqU6Ycw0JT1SnhaeqV6tOmLmGhKwPEGv+RutbVv3vSSRf4fYe/v2+vR/iDX/I3Wtq373pJIv8PsPf+X16csEr+c/EXxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcfZweFvapU+SGqtPVKeqU9Ur+XqdM97mGBOKkCU4JxUmyvUp0xcwwJzT1WnhOaeqV6tOmHMMVKkC04LUgSvUp0xcwwJUipTlSpFSvUp0w5hgTinhOlPCcU8L0r1KdMXMNC809Up4TmnqlerTphzDFTipAlOVKeEr1KdMOYaqU9Vp4SnqlepTpi5hoXinhOlPC8U8LXq0qYcwwLzT1SnhOaeqV6lOmLmGqnFPCU9Up4SvUp0w5hqpT1WnhaeqV6tOmLmGBakCU4LUgSvUp0w5hipzT1SnqnNPVK9SnTDmGKnFYPiDX/IDWtq373o8g/h9h7/y+vR2v6/5Aa1tW/e9JJB/D7D3/l9enLhOK/nTxF8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2cHhb2qVNuiGBKkCc04JUgTmv5ep0z3eYYqU8LT1Snha9SnTDmGhaeqU8JT1SvUp0xcw1Up4TinqlPCcV6tOmHMMCU8JzTwlPCc16lOmLmGqtPC09Up4WvUp0w5hoWnqlPCU9Ur1adMXMMCcU8JxT1TipAnFepTphzDAlPC80/bTwnNepSphzDFWpAtOVakC16tOmLmGBKkVKcEqRUr1KdMXMMCcU8JxT1TinhOK9SnTDmGheaeF5p4XmnhOa9SnTDmGKlPCU9Up6pXq06YuYaEp6pTwlPVK9SnTDmGhawPEGv+QGtbVv3vR5B/D7D3/l9ej/ABBr/kbrW1b970eQfw+w9/5fXpywSv5z8RPEX6vz5Jkk/f2qVF9nvGL/AJv5pfZ2XvXcfZweFv8AvKm3RDQlPCc08JTwvNfy/Tpnu8wxV5p6rT1TmnqlepTphzDAlSBKcEqQJXqU6YuYYqVIEpypUirXqU6YcwwLUipzTglSBOa9WnTDmGKlPVOKeqU9U4r1KdMXMMCcVIEpwTipAlepTphzDFSnqtPVKeq16lOmLmGhaeqc08LTwnNerTphzDVSnqnFPVKeqcV6lOmLmGBOKeEp4TinhK9SnTDmGhaeFp6pT1WvVp0xcw0LTwlPCU9Ur1KdMOYYqVIE4pypUgTivUp0w5hgTgU8LTwnFPCV6tOmLmGBawfEGv8AkbrW1b970klH8PsPf+X16O8Qa/8AZy1rat+96PIP4PYe/wDL69OXVK/nPxF8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2sHhb2qVPkhirUgWnKtSBa/l6nTPd5hirT1SnhKeqV6lOmLmGhOKeEp4TinhOlerTphzDAnNPVaeE5p6pXqU6Ycw0LTwtPVaeEr1KdMXMNCU9Up6pT1SvVp0w5hgTipAnSnBOKkC9K9SnTFzDAnNPVaeE5p6pXqU6YuYYqcVIFpwSpAlerTphzDAlSKlOVKkVK9SnTDmGBakCU4JUgWvUp0w5hipzT1SnqnNPVK9SnTFzDFTipAlOVOKeEr1adMXMNVKeq08JT1SvUp0w5hoWnhKeFp4WvUp0xcw1U5rA1/X/I32tq373pJIP4fYe/8AL69H+INf+zlrW1b970eQfwew9/5fXpyyrX86eIviL9X58kySfv7VKi+z3jF/zfzS+zsveu4+1g8Le1Spt0QxU4p4TinqlPCcV/L1Ome7zDQlPCc08JTwnNepTpi5hipUgWnKlSBa9SnTDmGBakVKcFqRUr1adMOYYE4p4TinhOKeE4r1KdMXMNCU8JzTwlPCc16lOmHMMVKeFp6pTwterTpi5hoWpFSnBKeqV6lOmHMNCcU8JxTwnFPCcV6lOmLmGBOakCc04JzTwnNerTphzDVWnhaeqU8LXqU6Ycw0LT1SnhKeqV6lOmLmGBOKkCU4JUgTivUp0w5hgTmnheaeF5p4TmvVp0xcwxVqQLTlSpAtepTphzDAlYPiDX/I3Wtq373o8g/h9h7/AMvr0d4g1/yN1rat+96PIv8AD7D3/l9enLhK/nPxF8Rfq/PkmST9/apUX2e8Yv8Am/ml9nZe9dx9nB4W9qlT5IYqVIqU5UqQJX8vU6Z73MMCU9U5p4Snhea9WnTFzDVSnqvFPVaeqcV6lOmHMMCcCnhKeE4p4SvUp0xcw1Up6pT1SnqterSphzDQlPVOaeEp6rzXqU6YuYYqU9V4p6pT1TivUp0w5hoTgU8JTwnFPCV6tOmLmGKlSBKcqVIq16lOmHMMC1Iq04LUgSvUp0xcwxUp4TinqlPCcV6tOmHMMCdKXZUoTpS7K9GNPQOY+OtlPCc0/ZTwnNf0NTpn+UfMNVKeqU5UqRU4r1adMOYYEqRUpwSpFSvUp0w5hipWB4g1/wAjda2rfvekkg/h9h7/AMvr0f4g1/yN1rat+96PID9z2Hv/AC+vTl1Sv5z8RfEX6vz5Jkk/f2qVF9nvGL/m/ml9nZe9dx9nB4W9qlT5IYEqQJzTglSBOa/l6nTPd5hipzT1SnqnNPVK9WnTDmGBOKeEp4TinhK9SnTFzDQlPCU9Up6pXqU6Ycw0JTwnNPCU8JzXq06YuYYqc09Up6pzT1SvUp0w5hqpxTwlPCcU8LXq06YuYaEp6pT1SnqlenTphzDAlSBOacEqQJzXq06YcwxUp6pxT1SnqnFepTpi5hgTipAlOCcVIEr1KdMOYYE5qRUpwTmnqlerTpi5hoSpAnNOCVIEr1KdMOYYqU9U4p6pT1TivVp0xcwwJxTwlPCcU8J0r1KdMOYaE5rA8Qa/5G61tW/e9HkB+77D3/l9ej/EGvfZy1rat+96SSA/d9h7/wAvr05ZU5r+c/ETxF+r8+SZJP39qlRfZ7xi/wCb+aX2dl713H2sHhb2qVPkhqpTwlPVKeEr+XqdM93mGhOaeqU9Up6pXqU6YuYYE4qTZTgnFSbK9WnTDmGBOaeE5p4TmnqnNepTpi5hipUgSnKlSBK9SnTDmGBOakVKcEqRUr1adMXMMCcU8J0p4TinhK9SnTDmGhOaeqc08JzT1TmvUp0xcwxUp4SnqlPCV6tOmHMNCc09Up4SnqlepTphzDQnFPCdKeE4p4SvUpUxcwwJzT1TmnhOaeqc16lOmHMMVKkCU9Up4WvVp0xcw0JT1SnBKkVK9SnTDmGKlSBKcqcVIEr1KdMXMMVOawNf17yN9rat+96PID932Hv/AC+vR/iDXvILWtq373o8in7vsPf+X16cuqV/OniL4i/V+fJMkn7+1Sovs94xf8380vs7L3ruPtYPC3tUqfJDFSnhOKeqU8JxX8vU6Z7vMMCdKkCc04J0qQJzXqU6YcwxUp6pT1SnhOK9SnTFzDQlPVKeEp6pXq06Ycw1Up4TinKlSBOK9SnTFzDAnSnhOaeE6U8JzXqU6Ycw1Up6pT1SnhOK9WnTDmGhKeqU8JTwlepTpi5hipxTwnFPVKeE4r1KdMXMN2U8JzT9lPCc16lKmHMMVKkCcU5Up6pxXq06YuYaEqRUpwSpFSvUp0w5hipTwnFPVKeE4r1KdMOYaE5p4TmnhORTwnNerTpi5hipTwnFPVKeqcV6lOmHMNCVgeINf+z7rW1b970eQH7vsPf+X16P8Qa/5G61tW/e9HkH8PsPf+X16csEr+dPEXxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcfZweFvapUXohqpTwnFPCU8JX8vU6Z7vMMCVIE5pwSpAnNepTphzDFTmnqlPVOaeqV6lOmLmGBOKkCU4JxUgSvUp0w5hipUipTlSpFSvVp0xcwwJUgTmnBKkCc16lOmHMMVKeqcU9Up6pxXqU6YcwwJxUgSnBOKkCV6tOmLmGBKeEp4TmnqlepTphzDQlPCc08JTwnNepTpi5hqpT1TinKlSKnFerTphzDAnFPCU8JxTwlepTpi5hoSnqlPCc09Ur1KdMOYYEqQJzTglSKlepTphzDFSnhOKeqU8JxXqU6YuYaE4rA8Q699n3Wtq373o8gP3fYe/wDL69H+INe8gNa2rfvejyA/d9h7/wAvr05bZX86eIviL9X58kySfv7VKi+z3jF/zfzS+zsveu4+zg8Lf95U+SGBOakVKcE5qRU5r+XqdM97mGBKeEp6pTwlepTpi5hoTmnqlPVKeqV6tOmHMNCcU8J0p4TinhOlepTpi5hgTmnqlPCc09U5r1KdMOYaqU8JT1SnhK9WnTFzDQnNPVKeqU9Ur1KdMOYYE4qQJ0pwTipAnSvUp0w5hgTmnqnNPCc09U5r1adMXMMVKkCU5UqQJXqU6YcwwJzUipTglSKlepTpi5hgSpAnSnBOKkCV6lOmHMMVOaeqU9U5p6pXq06YuYYqcU8JT1TinhK9SnTDmGhOaeqU8JT1SvUp0xcw1UrA8Qa/5G61tW/e9HkH8PsPf+X16O8Qa/5G61tW/e9JJAfuew9/5fXpy4Tiv508RfEX6vz5Jkk/f2qVF9nvGL/m/ml9nZe9dx9rB4W9qlT5IaEp6pTwlPVK/l6nTPd5hipTwnFPVKeE4r1KdMOYaEp4TmnhOlPCc16tOmLmGKlSBKcqVIE4r1KdMOYYEqRUpwSpFSvUp0xcwxU4p4TinhOKeE4r1KdMOYZsqQJzTtlSBOa9WnTFzDFSnqlPVKeE4r1KdMOYaEp6pTwlPVK9SnTDmGqnFPCcU9Up4TivVp0xcwwJzTwnNPCc08JzXqU6Ycw1Up6pT1SnhOK9SnTFzDQlPVKeEp4SvVp0w5hgTipAlOCVIE4r1KdMXMMCc08JzTwnNPCc16lOmHMMVKwfEGveQGtbVv3vSSRT932Hv/L69Ha/r3kb7W1b970eQH7vsPf+X16cuqV/OfiL4i/V+fJMkn7+1Sovs94xf8380vs7L3ruPs4PC3tUqfJDAnFSBKcE4qQJX8vU6Z7vMMVKeqU9Up6pXq06Ycw0JTwnNPCU9U5r1KdMOYaqU9U4p6pT1TivUp0xcwwJxTwlPCcU8JXq06Ycw1Up6pTwlPCV6lKmLmGhKeE5p4SnhOa9SnTDmGKlPVOKeqU9U4r1adMXMMCcVIEpwTipAlepTphzDFSpFSnBKkVK9SnTDmGBKkVOacEqQJzXqU6YuYYqU8JxT1SnhOK9WnTFzDAnFLs9qlCcUu36V6Uaegcx8dbKeE5p+2nhea/oanTP8pOYYq1IFp4XmnqtepTpi5hgWsHxBr/kbrW1b970kkX+H2Hv/L69HeINf8jda2rfvejyL/B7D3/l9enLha/nPxF8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2sHhb2qVPkhirUipTgtSKlfy9Tpnu8wwJTwnNPCVIF6V6tOmHMMVOaeqU9V5p6r9a9SnTFzDFXinhKeq8U8LXqU6Ycw1Vp6pTwtPVK9WnTFzDQlPCc09Vp4XpXqU6YcwxU5p6rUirzT1X616lOmHMRheKkCU9V4p4SvVp0xcwwJUipTwlPVa9SnTFzDAlSBacq1IFr1KdMOYYqU9U4p6rzUirXq06YcxGE4qQJTwvHenhOlepTpi5hgTmnqlPC81Iq16lOmHMMC08LT1WpAterTpi5hipT1SnqvNPVa9SnTDmGBOKwPEGv8AkbrW1b970eQfw+w9/wCX16P8Qa/5Aa1tW/e9HkH8HsPf+X16cuF4r+c/ETxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcfZweFvapU26IYE5p4TmnheaeE5r+XqdM97mGKlSBKeq09Vr1KdMXMMC1IqU8LT1WvVp0w5hgTinhKeEqQLxXqU6YuYYE5p4TmnheaeE5r1KdMOYYqU8LT1WpFWvVp0xcwwLUipTgtSKlepTphzDAnFPCU8JTwtepSphzDQnNPVOaeF5p6rz3r1adMXMMVaeFp6rTwvFepTpi5hoWnqlPC09Ur1KdMOYYE4qQJT1Wnha9SnTDmGBOaeqc1IF5p6rz3r1adMXMRqtSBKeq08LxXqU6YcwwLUipTglSKlepTpi5hgSsHxBr/kbrW1b970eQfw+w9/5fXo7xBr/kbrW1b970eQfw+w9/5fXpy4Sv508RfEX6vz5Jkk/f2qVF9nvGL/AJv5pfZ2XvXcfaweFvapU+SGBKkCU4LUirzX8vU6Z7vMMVKeE4p6rTwvFepTphzDAvSpAnNOC9KkCV6lOmLmGKlPVKeqU8JXq06Ycw0JT1WnhaeFr1KdMXMMVKkCcU9Vp4XivUp0xcwwJ0p4TmnheKeE5r1adMOYYqVIEp6pT1WvUp0w5hgWpFWnBakVa9SnTDmGKlPCcU9UqQLxXqU6YuYZsp4TmnhaeE5r1aVMXMMVKkCU4LzUirXqU6YcwwLUirTgtSBa9WnTFzDFSnhOKeqU8LxXqU6Ycw0JTwnNPC9KeF5716lOmHMMVKwNf1/yN1rat+96PIP4fYe/8vr0fr+v+QWtbVv3vR5B/D7D3/l9enLqtfzp4i+Iv1fnyTJJ+/tUqL7PeMX/ADfzS+zsveu4+zg8Le1Sp8kMCcU8LT1Xinha/l6nTPd5hqrT1SnqtPVK9SlTDmGBKkCc04JUgWvUp0xcwxU5p6pT1Xmnqv1r1KdMOYYE4qQJTlXipAterTpi5hirUipTgtSKlepTphzDAlSBKcEqQLXqU6YcwxUp6pxT1WnqterTpi5hgXinhKeF471IEr1KdMOYYEp6pTwnNPVK9SlTFzDQlPCU9Vp4WvVp0w5hipUipxT1WnqtepTpi5hgXinhKeF4708JXqU6YcwwJzUipTwnNPVa9SnTDmGBKkC05VqQLXq06YuYYqVgeINf8jda2rfvekko/h9h7/y+vR/iDX/ILWtq373o8g/g9h7/AMvr05dVr+c/EXxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcfaweFvapU+SGBOKftp4XinheK/l6nTPc5hgTmpFTmnheaeE5r1KdMOYYqU8JT1SnqterTphzDQtPVKeFp6rXqU6YuYaE4p4SnhKeEr1KdMOYYE5p6pzUgXmnqvNepTpi5hipTwlPVaeF4r1adMOYYFqRUp4WnqlepTpi5hgTipAlOCVIFr1adMOYYE5p6pzTwvNPVea9SnTDmGKlSBacq1IF4r1KdMXMMC1IqU4LUipXqU6YcwxUp4SnhKeFr1adMXMNCc09Up4XmnqtepTphzDFXinhaeq8d6eF4r1KdMXMNCVgeINf8AI3Wtq373o8g/g9h7/wAvr0f4h1/yN1rat+96PIP4fYe/8vr05YLzX86eIviL9X58kySfv7VKi+z3jF/zfzS+zsveu4+1g8Lf95U26IaqU8JT1Wnqlfy9Tpnu8w0JT1SnhKeq816lOmLmGKlPCcU9VqQLxXq06YcwwL0p4TmnhelPC816lKmHMMVKkVKcqVIEr1KdMXMMCVIFpwWpFXmvUp0w5hipTwnFPVaeF4r1adMXMM2VIE5p+2nhOa9SnTDmGKlPVKeqU8JXqU6YuYaEp6rTwtPC16tOmHMNVKeE4p6rTwvFepTpi5hgTkU8JzTwvSpAvNepTphzDFSnhKeqU9Vr1adMOYYFqRVpwWpFWvUp0xcwxUqQJTlSpAnFepTphzDAnIrA8Qa/5Ba1tW/e9HkH8PsPf+X16P8AEGv+RutbVv3vR5F/g9h7/wAvr05cLyK/nTxF8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2cHhb2qVPkhipzT1SnqvNPVa/l2nTPd5hgTinhKeE4p4WvVp0w5hqrT1Snhaeq16lOmLmGhKeE5p4Snha9SnTDmGqlPVOKeq09V4r1adMOYYF4p4WnheO9PC16lOmLmGhKeqU8LzT1SvUpUw5hoSnhOaeEp4WvUp0xcwxUp6pxT1WpFWvVp0w5iMLxUgSnheO9PC16lOmLmGBKkVKcE5qRUr1KdMOYYEqQLTglSBa9WnTDmGKlPCcU9Vp4XivUp0xcwwLxS7amC8UbfrXpRp6C5j46C08Jz0p4Wnhea/oanTP8AKTmGheawNf1/yN1rat+96PID932Hv/L69H+INf8AILWtq373o8g/h9h7/wAvr05ZV5r+c/EXxF+r8+SZJP39qlRfZ7xi/wCb+aX2dl713H2sHhb2qVPkhirUgWnKtSBa/l6nTPd5hgTmpFSnBKkVK9SnTDmGBOKkCU5Vp4WvVp0xcw1U56U9U9qeq809Vr1KdMOYYqcdKeEp6rxTwtepTpi5hoTmnqlPCU9Vr1adMOYaE4p4WnhaeFr1KdMXMNVOelPVPanBOakVa9WnTDmGKnHSnhKeq8U8LwK9SnTFzDAnNSKlOCVIq16lOmHMMVakC05V4qQLXq06YcwxUp6pTwlPVK9SnTFzDQnHSnhPanheKeF6V6lOmHMMCc09Vp4XmnqterTpi5hoSnhKeq8U8JXqU6Ycw1UrA1/X/I3Wtq373o8gP3fYe/8AL69H+INf8jda2rfvejyL/D7D39+316csq1/OfiL4i/V+fJMkn7+1Sovs94xf8380vs7L3ruPs4PC3tUqfJDVTinhOKeqU8JxX8vU6Z7vMMCc9KeE56U8LyKeF5r1KdMOYaqU9Vp6rT1XivVp0xcwwLUipTwtPCV6lOmHMMVKkCcU5Up4XivUp0w5hoTnpTwnPSnheRTwvNerTpi5hirUgSnKtPVeK9SnTDmGhKkVKcEqRUr1KdMXMMVKeEp6rTwterTphzDQnPSnqnPSnheaeq89q9SnTFzDFT2p6pxT1WnheK9SnTDmGhKeE5p4SnqlepTpi5hqpTwtOVakC16tKmHMMCc9KkVOelOC81Iq816lOmHMMVPanqnFPVaeq8V6lOmLmGBKwfEGv/Z91rat+96SSA/d9h7/AMvr0d4g1/yN1rat+96PIP4fYe/8vr05cLX86eIviL9X58kySfv7VKi+z3jF/wA380vs7L3ruPtYPC3/AHlT5IYqVIqU4JUipX8u06Z7vMMC1Iq04LUirXq06YuYYqU8Jx0p6rTwnFepTphzDAnHSpAnNOC8VIF5r1KdMXMMCc09Up4SnqterTphzDQtPCc08LT1WvUp0xcw1Up4TjpT1SnhOK9SnTDmGBOOlPCc9KeF4p4XmvVp0w5hqpzT1Snheaeq16lOmLmGBakCc04LUgSvVp0w5hipUgTinKlSBOK9SnTFzDNlPCc9KeFp4XmvUpUw5hipzT1Wnheaeq16tOmLmGhakCc04LTwlepTphzDVSnhOKeqU8LxXqU6Ycw0JWB4g17yC1rat+96PID932Hv/L69H+INf8jda2rfvejyD+H2Hv8Ay+vTlglfzp4i+Iv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7ODwt7VKnyQ1U56U9U9qeq809V+lfy7Tpnu8wxU46U8JT1XinhelerTphzDQnNPVKeEp6pXqU6YuYYE4qQJTgtSBa9SnTDmGKnPSnqntT1Xmnqv0r1adMXMMVOOlSBKcq8VIFr1KdMOYYE5qRUpwSpFSvUp0xcwwJxUgWnKtSBa9WnTDmGKlPVPanqtPVK9SnTFzDAnHSpAnSnBeKeF6V6lOmHMNCc09Up4TmnqterSphzDQnFPC08LTwtepTpi5hqpT1T2p4SnqlepTphzDAnHSnhOlPC8U8L0r1adMXMNCc09Up4XmnqtepTphzDFWsHxBr/kbrW1b970eUH7vsPf+X16O8Qa/wCRutbVv3vSSQfw+w9/5fXpy6rX85+IviL9X58kySfv7VKi+z3jF/zfzS+zsveu4+1g8Le1SovRDAtSKlOC1Iq1/L1Ome5zDAnFPCU9Up4SvUp0w5hoTnpTwnPSnheaeF5r1KdMOYYqU8JxT1Wnha9WnTFzDQtPVKeFp4SvUp0w5hoTinhKeqU8JXqU6YuYaE56U9U56U4LzUirz2r1adMOYYqe1PC8U9Vp4XivUp0xcwwLUipTwtPCV6lOmHMMVKkCU5UqQLXq06YcwwJz0p6pz0p4XmnqvPavUp0xcwxU9qkCcU5VqQLxXq06YcwwJUipTglSKlepTpi5hipTwtPVaeFr1KdMOYaF5p6p7U8LzT1WvUp0xcwxU46VgeINf8gNa2rfvejyA/d9h7/y+vR+v6/5G+1tW/e9HkH8PsPf+X16cuF4r+dPEXxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcfaweFvapU+SGBOnFPCc08LxTwvNfy9Tpnu8w1Up6pTwlPVK9SnTFzDQlPCU4LUirXqU6YcwxVqQJx0pyrTwnFerTpi5hoTjpTwnNPC8U8LzXqU6YcwxUqRUpyrzUipXqU6YcwwLUirTgtSKterTpi5hipTwnFPVaeE4r1KdMOYbsp4TmnbKkC816lOmLmGKnNPVKeq809Vr1adMOYaFp4Tmnhaeq16lOmLmGqlPCcU9Up4TivUp0w5hgTpUgTnpTgtSBee1erTphzDFTnpT1SnqvNPVa9SnTFzDAtSBOacFqQJXqU6YcwxUrB8Qa/5G61tW/e9HkB+57D3/l9ejvEGv+RutbVv3vR5B/D7D3/l9enLqtfzp4i+Iv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7ODwt/3lTbohgTipAlOCVIEr+XqdM93mGKnPSnqntT1Xmnqv0r1KdMOYYqcdKeFp6rxTwvSvUp0xcw0JzT1SnqtPVK9SnTDmGhOKeEp4SnhK9SnTFzDVWnqntT1WnqterTphzDAnHSnhKeF47U8L0r1KdMOYaE5p6pTwnNPVK9SlTFzDAnFSBacFqQLXq06YuYYq1Iqe1OVakVa9SnTDmGBOOlPCU8LxTwvSvUp0w5hgTmpFSnBeakVK9WnTFzDAnFSBacq1IFr1KdMOYYqU9U4p6rT1SvUp0xcw0Jx0o2e1TBOKNv0r0o09A5j46C1geINf8gta2r/vejyD+H2Hv/L69H+INf8AI3Wtq373o8i/w+w9/wCX16cuFrxfEXxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcf8vsHhb2qVV6IYF5p6rzTwvPenqvNfy9Tpnu8wxVqQLTlSnhK9SnTFcaFp6rTwtPVa9WnTDmGqtPC08LTwlepTphzDQvNPVaeF5p6rXq06YuYYq8U8LT1XinheK9SnTDmGhaeq08LT1WvUp0xcw1Vp4WnKlSBK9WnTC4xV5qRVpwXmpFWvUp0xcwxV4p4XinqvHenheK9SnTDmGBakVacFqRUr1adMOYYFqQJTlSpAlepTpi5hirT1WnqvNPVa9SnTDmGheKeF6U8LxTwvSvUp0xXGBeaeq08LzT1SvVp0w5hqrWB4g1/7PutbVv3vSSQfw+w9/wCX16P8Qa/5G61tW/e9HkH8PsPf+X16csqV/OfiL4i/V+fJMkn7+1Sovs94xf8AN/NL7Oy967j7ODwt7VKvyQ0LT1WnhKeF5r+XqdM93mGKtSBeKeq08LxXqU6YXGBeRTwvNPC8inhea9WnTFcaq08LTlSpFSvUp0w5hgSpFWnBKkVea9SnTDmGKtPC8U9Vp4XivVp0xcw0LyKeF5p4XpTwvNepTphzDFWnqtPVKeEr1adMVxoSnhaeFp6rzXqU6Ycw1Vp4WnqtPCV6lKmLmGheaeq808LyKeq816lOmHMMVaeq8U9Vp6rxXqU6YuYaFp6rTgtSBa9WnTDmGKtSBacq1IEr1KdMXMMC1Iq804LUirzXq06YcwxVrA1/X/IDWtq/73o8g/h9h7/y+vR+v6/5G+1tW/e9HkH8PsPf+X16csq8V/OfiL4i/V+fJMkn7+1Sovs94xf8380vs7L3ruPtYPC3tUqfJDAvFSBacF4qQLX8u06Z7vMMC809Vp4XmnqterTpi5hoWpAtOCVIEr1KdMLjFWnheKeq08LxXqU6YrjAvFSBacF4qQLXq06YcwwLzT1Wnheaeq16lOmLmGhaeEp4Snha9WnTDmGqtPC8U9Vp4XivUp0w5hgXinheaeF4p4XmvUp0xcw0LzT1WnheaeqV6tOmHMMC1IEpwSpAtepTpi5hirTwvFPVaeF4r1KdMOYaFp4XmnhaeF5r1aVMXMMC809Vp4TmnqlepTphzDQlPC08JTwtepTpi5hqrWB4g1/yN1rat+96PKP4fYe/8vr0f4g1/wAjda2rfvejyD+H2Hv/AC+vTllWv5z8RfEX6vz5Jks/f2qVF9nvGL/m/ml9nZe9dx9rB4W9qlT5Iaq08LT1Wnha/l6nTPd5hqrzT1WnqvNPVfrXq06YcwxV4p4WnqvFPCcV6lOmLmGhaeq04LUirXqUqYXGKtSBacq1IFr1adMXMMC809Vp6rzT1WvUp0w5hirxUgWnKvFSBOK9SnTFzDAtPVaeFp6rXq06Ycw1VqQLTgtPCV6lOmLmGhaeq08LzT1WvVp0w5hgXipAvSnBeKeF6V6lOmHMNC809Vp4XmnqtepSpi5hqrTwtOVKkCV6lOmHMNVaeq08LzT1WvUp0xcwwLxTwtPC8U8L0r1adMOYaF5rA8Qa/wCQWtbVv3vR5B/B7D3/AJfXo/xBr/kFrW1b970eQfw+w9/5fXpywXmv5z8RfEX6vz5Jks/f2qVF9nvGL/m/ml9nZe9dx9nB4W9qlRadEMVakVacq1IFr+XqdM93mGBakC04JUgXmvVp0w5hgWnheKeq08LxXp06Ycw0LyKeF5p4XkU8LzXq06YuYYq09Vp6rT1SvUp0w5hoWnqtPCU8LzXqU6YuYYq1IFp6rTwterTphzDAvNSKvNOC81Iq8969SnTFzDFWnheKeq09U4r1adMOYYEqRVpwSpFXmvUp0xcwxVqQLTlWpAtepTphzDAvNPVeaeF5FPVee9erTpi5hirUirxTlWnhOK9SnTDmGhKeFp4WnqvNepTphzDVWnhaeq08JXq06YuYaFrA8Qa/5Ba1tW/e9HkH8HsPf+X16P8AEGv+RutbVv3vR5B/B7D3/l9enLBa/nPxF8Rfq/PkmST9/apUX2e8Yv8Am/ml9nZe9dx9rB4W9qlRadENVaeF4p6rTwvFfy9Tpnu8wwLxTwtPC8U8LXqU6YuYaFp6rTwvNPVa9SnTDmGBakVacEqQJXq06YuYYq08LxT1WnheK9SnTDmGheKeF5p4Xinhea9SlTFzDAvNPVaeF5p6rXq06Ycw0LUgWnBKkCV6lOmHMMVaeF4p6rTwvFepTpi5hgWpAvNOC1IF5r1adMOYYF5p6rTwvNPVa9SnTFzDQtPCU8JTwterTphcaq08LxT1WnheK9SnTFzDAtSBeacFqQLz3r1KdMOYYq809Vp6rzT1SvUp0w5hgWsHxBr/AJG61tW/e9HkX+H2Hv79vr0d4g1/yA1rat+96SSL/D7D3/l9enLhK/nPxF8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2cHhb2qVF6IYFqRVpwSpFWv5fp0z3eYYFp4WnqtSBa9SnTDmGKvNPVaeq809V+tepTpi5hirxTwtPVeKeEr1adMOYaFp6rTwtPVa9SnTFzDVWnhaeq08LXqU6Ycw1Vp6rT1XmnqtepTphcYF4p4WnheKeFr1KdMXMNC809Vp4XmnqterSphzDFWpAtOVakC16lOmLmGBakVacq809Vr1adMOYaF4p4XpTwvFPC16lOmK4wLzUirTgvNSKtepTphcYq1IFpwWnhK9WnTFzDQtPVaeF5p6rXqU6YcwwLxS7aw/EGv8AkBrW1b970eRf4PYe/wDL69Od/tK9/wCfu4/7+N/jX5Dn3irlGR42WApU5VnDSTi1ZPrG73a620T03Tt6VLBTqx5m7HxgE4qQJ0pwXinhK/H6dM/zJ5hoTnpT1TnpTwvNPVee1erTpi5hip7U8JxT1WnheK9SnTDmGhaeqU8LT1WvUp0xcw1Up4SnqlPCV6tOmHMNVOaeqe1PC809Vr1KdMOYYqcdKeE46U9V47U8LxXqU6YuYaFp6pTwtPCV6tOmHMMCcVIEpypUgWvUp0xcwxU5qRU9qcF5qRVr1KdMOYYqcdKeE46U9V47U8LxXq06YuYYEqRUpwWpAlepTphzDFSpAlOVKeFr1KdMOYaEp6pT1WnqtepTpi5hoTjpTwnHSnBOKkC8V6tOmHMMCc1geINf8gta2rfvekkgP3fYe/8AL69H+Idf8jda2rfvejyD+H2Hv/L69OXC81/OfiL4i/V+fJMkn7+1Sovs94xf8380vs7L3ruPs4PC3/eVNuiGKlPCcU9V5p6pX8vU6Z7vMNCU9Up4WnqtepTphzDFWpAnFOVakC8V6tOmLmGBORxTwnPSnhOlPC816lOmHMMVKkVKcq1Iq8V6lOmHMMCVIEpwWpFWvVp0xcwxVp4TinqtPCcV6lOmHMNCe1PCc9KeE6U8Lz2r1adMXMMVKeqU9Vp6rXqU6Ycw0LT1Wnhaeq16lOmLmGqlPCcU9Vp4SvUp0w5hoSnqnPSnhKeq816tOmLmGKntT1TjpT1X6U9V4r1KdMOYYFqQJzTgvSpFWvUp0xcwxUqQJxTlSpAterTphzDAlYHiDX/ILWtq373o8gP3fYe/8vr0f4g1/wAjda2rfvejyD+H2Hv/AC+vTlwlfzn4i+Iv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7WDwt7VKm3RDFSnqnHSnqtPVa/l6nTPd5hgTjpUgWnBeO1SBelepTpi5hgXmnqlPC809Vr1KdMOYaE4p4SnhKeEr1adMXMNVKeF4p6rTwvFepTphzDAnHSpAtOC8U8LXqU6YuYaE5p6pTwvNPVK9WnTDmGBOKkCU4LUgWvUp0xcwxVqQLxTlWpAvFepTphzDAnHSnhOelPC8U8LzXq06YcwwJzUipTgvNSKtepTpi5hgTipAtOC1IFr1KdMOYYq08JxT1WnheK9SnTFzDQlPCc9KeEp4XmvVpUw5hgTmnqlPC809Vr1KdMXMNCcVgeINf+z7rW1b970eUH7vsPf+X16P8AEGv+RutbVv3vR5B/D7D3/l9enLBeK/nPxF8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2sHhb2qVF6IaEp6rTwtPVa/l6nTPd5hoSnhOlOVeKkCV6tOmHMMCc1Iqe1OVOakVa9SnTFzDFTjpTwnHSnqvHanheK9SnTDmGBakVacFqRVr1adMXMMVKkCdKcF4qQJXqU6YcwwJzT1T2p4XmnqtepTpi5hipx0p4TjpT1XjtTwvFerTphzDQtPVKeFp6rXqU6YuYaqU8JT1SnhK9SnTDmGqlPVaeFp6rXq06YcwwJx0p4TpxTwvFPC8V6lOmLmGhOaeqU8LzTwlepSphzDAnFSBKcqVIFr1adMXMNVKeq05VqRVr1KdMOYYE46VgeINf8gNa2rfvejyA/d9h7/y+vR/iDX/IDWtq373pJIP4fYe/8vr05YLxX85+IviL9X58kySfv7VKi+z3jF/zfzS+zsveu4+zg8Lf95UXohoTkcU8Jz0p4XkU8LzX8vU6Z7vMMVKeqU9Vp6rxXq06Ycw0JUipTglPC16lOmLmGqtPC8U9Vp4XivUpUw5hoTkcU8Jz0p4Wnhea9SnTDmGKlPCcU9Vp6rxXq06YuYaEp6pTwtPVa9SnTDmGKtSBKcq1IFr1KdMXMMCc9KkVOelOCVIq816tOmHMMVPanqnHSnqv0p6rxXqU6YuYYE6VIEpwWpFWvUp0w5hipUgSnKtPCV6tOmLmGhOaeqc9KeEp6rzXqU6YcwxU9qeqcdKeq/SnqvFepTpi5hoWnqtPC09Vr1KdMOYaqVgeINf8jda2rfvejyA/d9h7/wAvr0f4g1/yN1rat+96PIP4PYe/8vr05ZVr+dPETxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcfaweFvapU+SGhKeE5p4WnhK/l6nTPd5hqpTwnFPVKeF4r1KdMXMMCcdKeEp4Xinha9SnTDmGBeakVacF5qRVr1adMXMMCVIE5pwSpAlepTphzDFSnhOKeq08LxXqU6YuYaE46U8Jz0p4Xinhea9WnTDmGBeaeqU8LzT1WvUp0w5hoTinhKeEp4SvUp0xcw1Up4XinqtPC8V6tOmHMMCVIE56U4LUgXmvUp0xcwwJzT1Snheaeq16lOmHMMCcVIEpwWpAterTpi5hqrTwvFOVakC8V6lOmHMMCdKkCc9KcFqQJzXqU6YcwxU56Vga/r/AJG+1tW/e9HkB+77D3/l9ej9f1/yC1rat+96PIP4fYe/8vr05ZVr+dPEXxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcfZweFvapU+SGKnHSpAnFOVeKkC8Cv5ep0z3eYYEqRUpwWnqtepTphzDVWnhaeq8U8JXqU6YuYaqc9Keqe1PVOaeq16tOmHMMVOOlPCcU9V47U8LxXqU6YuYaEp6rTwtPVa9SlTDmGhKeEpyrxUgSvUp0xcw0JzT1SnqlPVa9WnTDmGBOOlPCdOKeF4p4XpXqU6YuYaF5p6rTgvNSKtepTphzDFSpAlOC8VIEr1adMOYYE5qRUpwWnqtepTpi5hoTjpTwnTinheKeF6V6lOmHMMC809Up4XmnqterTpi5hqpTwlPVKeEr1KdMOYaqVgeINf8jda2rfvejyA/d9h7/wAvr0f4g1/yN1rat+96PIv8PsPf+X16csqV/OfiJ4i/V+fJMkn7+1Sovs94xf8AN/NL7Oy967j7ODwt7VKm3RDVSl2e1SKtO2/Sv5bjT0Pd5j45VKkCU5UqQJX9DU6Z/lJzDAnIp6rzTwnNPVOa9WnTDmGKlSKnFOVKeE4r1KdMXMNC08JTwlPCc16lOmHMNVKeFp6pTwlerTphzDQlPVaeFp6pXqU6YuYYqU8JxT1TinhOK9SnTFzDQlPCc08JTwnNerTphzDFSpAtOVKkCV6lOmHMMC1IqU4JUipXqU6YuYYqU8JxT1SnhOK9WnTDmGBKkCc04JUgTmvUp0xcwxUqQLTlSnhK9SnTDmGhaeqU8JUipXq06YuYYE4rA8Qa/wCQGtbVv3vSSRf4fYe/8vr0f4g1/wAjda2rfvejyD+H2Hv/AC+vTlgnFfzn4i+Iv1fnyTJJ+/tUqL7PeMX/ADfzS+zsveu4+1g8Le1Spt0QwJUgTmnBKkCc1/L1Ome7zDAnNPVKeE5p6pXqU6YuYaFp4WnBKkCV6tOmHMNVaeE4p6pTwnFepTphzDAlSBOacE6VIE5r1KdMXMMVOaeqU9U5p6pXq06YcwwLUgWnBKkCV6lOmLmGKlPCcU9Up4TivUp0w5hoSnhOaeEp4TmvVp0xcwxU5p6pT1TmnqlepTphzDQtPCU8JxTwlepTphzDVSnqtPVKeqV6tOmLmGhKeF5p4WnhOa9SnTDmGKtPVOKeqU9U4r1KdMXMNCcU8JTgnFSBK9WnTDmGKlYPiDX/ACN1rat+96PIP4fYe/8AL69HeINf+z7rW1b970eQfw+w9/5fXpy6pX85+IviL9X58kySfv7VKi+z3jF/zfzS+zsveu4+zg8Le1Spt0QwJUgWnKlSBK/l6nTPe5hipzT1WnqlPVK9SnTFzDQvFPCdKeE4p4TpXqU6YuYYE5p6pTwnNPVK9WnTDmGhKeFp6pTwtepTphzDQtPVaeqc09Ur1KdMXMMCcVJspwTipNlepTphzDAnNPVKeE5p6pXq06YuYYq1IFpypUgSvUp0w5hqrT1SnKnNSKlepTpi5hgTipAnSnBOKkCV6tOmHMMCc09Up4TmnqlepTphzDFWpAtOVKkCV6lOmLmGBKeqU9U5p6pXq06Ycw0JxTwnSnhOKeEr1KVMXMMCc1g6/r/kb7W1b970eQfw+w9/5fXo7xBr3kFrW1b970eQH7vsPf8Al9enLqnNfzn4ieIv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7WDwt7VKm3RDFSnqnFPVKeqcV/L1Ome7zDQtPVaeEp6pzXq06YuYYqVIEp6pTwlepTphzDQnNPVKeEp6pXqU6YuYYq8U8JxT1TinhOK9WnTDmGBKkCc04JUgTmvUpUw5hipUgSnKlSBK9SnTFzDAlPVaeEp6pXq06Ycw1V4p4TinqnFPCcV6lOmLmGBKeE5p4SnhOa9SnTDmGqlPC09Up4SvVp0xcw0LT1WnhaeqV6lOmHMMCcVIE4pwTipAnFepTphzDAlPCc08JTwnNerSpi5hipUgWnKlSBK9SnTFzDQtYHiDX/ACC1rat+96PIP4PYe/8AL69HeINf8jda2rfvejyD+H2Hv/L69OXCV/OfiL4i/V+fJMkn7+1Sovs94xf8380vs7L3ruPtYPC3tUqbdEMVakC8U5UqQJxX8vU6Z7vMMCU8JzTwnSnhOa9SnTDmGKnNSKlOVOaeqV6tOmLmGhakC04JTwtepTphzDVWnhOKeqU8JxXqU6YuYaEp4TmnhOlPCc16tOmHMMVOaeqU9U5p6pXqU6Ycw0LTwtPCU8JXqU6YuYYqVIqU9Up6pXq06YcwwJUipzTgnSpAnNepTpi5hipT1TinqlPVOK9SnTDmGBKkC04JxUgSvUp0xcwxUqQJTlSnqlerTphzDQlSKnNOCU9U5r1KdMXMNVaeqcU9Up6pxXqU6YcwwJWB4g1/yN1rat+96PIv8PsPf+X16P8AEGveQGtbVv3vR5Afu+w9/wCX16cuE6V/OniJ4i/V+fJMkn7+1Sovs94xf8380vs7L3ruPs4PC3tUqfJDAnNPVaeE5p6pX8vU6Z73MNVKeEpypUgSvUp0xcw1Up6pxTwlPVK9SnTDmGBeKeEp4Tin7K9SnTFzDQnNPVKeE5p6pXq06YcwwJUgWnKlSBK9SnTFzDFSpFWnKlSKlerTphzDAnFPCcinhOKeE5FepTphzDAnNSKlOCc09Ur1KdMXMNCU8LT1Snha9SnTDmGhaeFp6pzT1SvVp0xcwwJxUgTkU8JxTwnIr1KdMXMMCc09Up4TmnqlerTphzDFWpAtOVKkCV6lOmHMNVaeqU9U5p6pXqU6YuYYErB8Qa/5G61tW/e9HkH8HsPf+X16O8Qa/wCRutbVv3vR5F/g9h7/AMvr05cJX86eIniL9X58kySfv7VKi+z3jF/zfzS+zsveu4+1g8Le1Sp8kMCc1IqU4JzUipX8u06Z7vMMVOKeE4p6pxTwnFerTpi5hgSpAtOCVIE5r1KdMOYYFp4SnqlPCV6lOmHMNCc09Up4TmnqlerTpi5hipxTwnFPVOKeE4r1KdMXMNCU8LTwlPCc16lOmHMNVKeEp6pTwlerTphzDQlPVKeEp6pXqU6YuYYF4p4XinhOKeE4r1KdMOYaEp4TmnhKeE5r1adMXMMVKkCU5UqQJXqU6YcwwLUirTglSKlepTpi5hgXinhOKeE4p4TivUp0w5hgTmpAnNOCc1IE5r1adMOYYqVgeINf8gNa2rfvejyD+H2Hv/L69H6/r3kbrW1b970eQH7vsPf+X16csqV/OfiL4i/V+fJMkn7+1Sovs94xf8380vs7L3ruPtYPC3tUqfJDQlPCU8JTwlfy9Tpnucw1UpdlSqlLsr0o09A5j45VKeEp6rTwtf0NTpn+UnMNCU9U5p4SnqnNepTpi5hipT1TinqlPVOK9SnTDmGhKeqU8JTwterTpi5hqpTwlPVKeFr1KdMOYaEp6pTwlPVK9SnTDmGKlPCcU9Up4TivVp0xcw0J0p4TmnhaeF5r1KdMXMMVKkCcU5UqQJXqU6YcwwJUipTglSKlerTphzDFSnhOKeqU8JxXqU6YuYYE6VIE5pwXpUgTmvUp0w5hipTwnFPVKeqV6tOmLmGhKwPEGv8A2fda2rfvejyL/D7D3/l9ej/EGv8A2fda2rfvekkg/h9h7/y+vTlglfzn4i+Iv1fnyTJJ+/tUqL7PeMX/ADfzS+zsveu4+1g8Le1Sp8kNVKeE4p6pTwtfy9Tpnu8wwJUgTmnBKkC816lOmHMMCc09Up4XmnqlerTpi5hgTipAlOCVIEr1KdMXMMVKkCcU5UqQLXqU6YcwwJUgTmnBKkCc16tOmHMMVOaeqU9U5p6pXqU6YuYYE4qQJTgnFSBK9SnTDmGKlPCcU8LTwterTpi5hoSnhOaeEp4TmvUp0w5hipzT1SnqnNPVK9SnTFzDQnFPCU8JxTwlerTphzDVSnhKeq09Ur1KdMOYaEp6pzTwlPCc16lOmLmGKlPVOKeqU9U4r1adMOYYE4rB8Qa/9n3Wtq373pJIP4fYe/8AL69H+INf8gNa2rfvejyD+H2Hv/L69OWCcCv5z8RfEX6vz5Jkk/f2qVF9nvGL/m/ml9nZe9dx9nB4W9qlT5IYE5qRUpwTmpAtfy9Tpnu8wxU4qQJTgtSBa9SnTDmGKlPVKeEp6pXqU6Ycw0JxTwnFPCcU8JwK9WnTFzDAnNPVKeF5p6rXqU6Ycw0JTwlPVKeEr1adMXMNVKeqU9Up6pXqU6YcwwJxUmynBOKk216lOmLmGBOaeqU8LzT1TmvUp0w5hgSpAlOVKkCV6lOmLmGBOakVKcqVIq16tOmHMMCcU8J0p4TinhOlepTpi5hoTmnqlPCc09Ur1KdMOYYqU8JT1TinhK9WnTDmGqlPVKeFp6rXqU6YuYaE4rA8Qa95G61tW/e9HkB+77D3/l9ej/EGv+QGtbVv3vR5B/D7D3/l9enLBa/nPxE8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2sHhb/vKi9ENCc09U5p4SnqnNfy9Tpnu8wxUp4TinqlPVOK9SnTFzDQnSnhOaeEp6pXq06YcwxUqQJTlWpAtepTphzDAlSKlOC1IqV6tOmLmGKnFPCcU9Up4TivUp0xcwwJ0qQJzTglSBea9SnTDmGKlPC09Vp4WvVp0w5hoSnqlPC09Ur1KdMXMNVKeE4p6pTwnFepTphzDAnSnhOaeEp4XmvVp0xcw1Up4SnqlPC16lOmHMNCU9Up4SnqlepTpi5hgTipAnFOVKeE4r1adMOYaEp4Tmn7aeE5r1KVMOYYqVg+INe8gNa2rfvejyA/d9h7/AMvr0d4g1/yN1rat+96PIP4PYe/v2+vTl1Wv5z8RPEX6vz5Jkk/f2qVF9nvGL/m/ml9nZe9dx9nB4W9qlRadEMC1IEpwWpAtfy9Tpnu8wxUp4TinqlPCcV6lOmHMNCU8JzTwlPCc16tOmLmGKnNPVKeq809Ur1KdMOYaEp4SnhKeEr1KdMXMNVKeE4p6pTwterSphzDQlPCc04JUgTmvUp0xcwxU5p6pT1XmnqlerTphzDAnFSBKcE4qQJXqU6YcwxUqRU4pypUgWvUp0xcwwJUipzTgtSKnNepTphzDFSnqnFPVKeqcV6lOmLmGBOKkCU4JxUgSvVp0w5hipT1SnhaeqV6lOmLmGhKeqc08LTwnNepTphzDVSsDX9e8jfa2rfvejyA/d9h7/wAvr0f4g1/yN1rat+96SSD+D2Hv/L69OWVK/nTxF8Rfq/PkmST9/apUX2e8Yv8Am/ml9nZe9dx9rB4W9qlRadEMCcU8J0p4TinhOlfy7Tpnucw0JzT1SnhOaeqV6tOmHMMVOKkC04LUgWvUp0w5hqpT1SnqtPVK9SnTFzDAnFP2U8JxTwlerTphzDQnNPVKeE5p6rXqU6YuYYqcVIEpwWpAterTphzDFSpFSnBKeqV6lOmLmGhOKeEp4TinhOlepTphzDAnNSKlOC809Vr1adMOYaEp4SnqnFPCV6lOmLmGqlPVKeqU9Ur1KdMOYYE4qQJ0pwXipAnSvVp0xcwwJzT1SnheaeqV6lOmLmGBKkCU5U4qQJXqU6YcwwJzWD4g1/yN1rat+96PIP4fYe/8vr0d4g1/yN1rat+96SSL/D7D39+316cuEr+dPETxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcfaweFvapUWnRDFSpAlOVKkCV/LtOme7zDAlPVKeFp6pXq06YuYaqcU8JxT1TinhOK9SnTDmGBOlSBOacEp4TmvUp0xcw1Up4SnqlPC16tOmHMNCU9Up4WnqlepTphzDFTinhOKeqU8JxXqU6YuYaE6U8JzTwlPCc16tOmHMMVKkCU5VqQLXqU6YuYYEqRUpwWpFSvUp0w5hgTinhOKeE4p4TivVp0xcw3ZTwnNPCU8LzXqU6YcwxUqQLTlWnha9WnTDmGhKkVKcFqRUr1KdMXMMCcU8JxTwnFPCcV6lOmLmGBOawfEGveQWtbVv3vSSQH7vsPf+X16O8Qa/5G61tW/e9HkH8PsPf+X16cuE5r+c/EXxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcfaweFvapU+SGKnNPVKeqc09Vr+XqdM93mGhKeEp4Wnha9SnTDmGqlLsqVUpdlelGnoLmPjlVp4WnqlPVK/oelTP8pOYaEp6pzTwlPVOa9SnTDmGKlPVOKeqU9U4r1KdMXMNCU8LTwlPCV6lOmHMNVaeqU9Up4TivUp0xcw0JT1TmnBKkVK9WnTDmGKlPC8U9Up4TivUp0w5hoTpTwvNPCdKeE5r1KdMXMMVKkVKcqU9Ur1adMOYaEqRU5pwSpAlepTpi5hirTwvFPVKeE4r1KdMOYYE6VIE5pwSpAnNerTpi5hipWB4g1/yN1rat+96SSD+H2Hv/L69H+INe8gta2rfvejyA/d9h7/y+vTllSv5z8RPEX6vz5Jkk/f2qVF9nvGL/m/ml9nZe9dx9rB4W9qlT5IaqU8JTwnFPCV/L1Ome7zDVSnhKeqU8JXqU6YuYYFqQLzTgnFSBOa9WnTDmGBOaeqU8JzT1SvUp0w5hipUgSnKlSBK9SnTFzDFSpAlOCVIEr1adMOYYFp4TmnhKkCc16lOmLmGKnNPVKeqc09Ur1KdMOYYE4p4WnqnFPCV6tOmLmGqlPC09Up6pXqU6Ycw0JTwnNPCU8JzXqU6YcwxU5p6pT1TmnqlerTpi5hqpxTwtPVOKeEr1KdMOYaFp4WnKnNSKlepTpi5hgSpAnNOCVIE5r1adMOYYqVga/r/AJAa1tW/e9HkH8PsPf8Al9ej/EGv/Zy1rat+96PID932Hv8Ay+vTl1Sv5z8RfEX6vz5Jkk/f2qVF9nvGL/m/ml9nZe9dx9nB4W9qlT5IYE4p4TinhOKeE4r+XqdM93mGBKkVKcEqQJXqU6YcwwLTwlPVKeEr1adMXMNVKeqU8JzT1SvUp0w5hoTinhOKcE4qQJxXqU6YcwwJzT1SnhOaeE5r1adMXMNC08JT1SnhK9SnTDmGhKeqU8JzT1SvUp0xcwwJxUm2nBOKeEr1adMOYaE5p6pTwnNPCc16lOmLmGKlSBKcqVIEr1KdMOYYFqRUpwSpFSvUp0xcwwLxTwtPCcU8J0r1KdMOYaE5p6pzTwnNPVOa9WnTDmGKlPCU9Up4SvUp0xcw0LWB4g1/7PutbVv3vSSUfw+w9/5fXo/xBr/2fda2rfvejyA/c9h7/wAvr05YJzX85+IniL9X58kySfv7VKi+z3jF/wA380vs7L3ruPtYPC3tUqfJDVSnhKeqU8JX8vUqZ7vMNC09U5p4TpT1TmvVp0xcwxUp6pxT1SnqnFepTphzDAlSBacEqQJXqU6YuYYqVIFpypUipXq06YcwwJUipTglSKlepTphzDFSnhOKeqU8JxXqU6YuYYEqQJzTgnSpAnNerSphzDFWnhaeqU9Ur1KdMXMNCU9U5p4SnqlepTpi5hqpTwnFOVKkCcV6tOmHMMCdKeE5p4TpTwnNepTphzDVWnqlPVKeE4r1KdMOYaEp6pTglSKlerTpi5hipxTwvFPVKeE4r1KdMXMN21geINf8gta2rfvejyD+H2Hv/L69H+Ide8jda2rfvejyA/d9h7/y+vTlgnNfzn4ieIv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7WDwt7VKnyQwJzUipTgnNSKlfy9Tpnu8wwLUgSnKlSBK9SnTDmGKlPCU9Up4SvVp0xcw0JTwvNPCU8JzXqU6YcwxU5p6pT1TmnqlerTpi5hoTinhKeE4p4SvUp0w5hqpTwlPVKeEr1KdMXMMC1IF5pwSpAnNerTphzDFTmnqlPVOaeqV6lOmHMMCcVIEpypxUgSvUp0xcwxUqRVpwSpFSvVp0xcwwJUgTmnBKkCc16lOmHMMVKeqcU9Up6pxXqU6YcwwJxTwlPCcVIEr1KdMOYYqU8LTwlPVK9SnTFzDQlYHiDX/I3Wtq373o8g/g9h7/y+vR/iDX/I3Wtq373pJIv8PsPf+X16csEr+dPEXxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcfZweFvapU+SGhKeqU9U5p6pX8vU6Z7vMMCcU8J0p4TinhOK9SnTDmGhOaeqU8JzT1SvUp0w5hirUgSnBKkCV6lOmLmGKlSKlOCc1IqV6tOmLmGBOKfsp4Tin7K9SnTDmGBOakVKcE5qRUr1adMOYYFp4SnqlPCV6lOmLmGqlPVKeE5p6pXqU6Ycw0JxTwvSnhOKeE6V6tOmLmGBOakVKcE5p6pzXqU6Ycw0JTwlPVKeEr1KdMXMNCU9Up4TmnqlerTphzDAnFSBacE4qQJ0r1KdMOYYE5p6pTwnNPVOa9SnTFzDFSsHxBr3kBrW1b970kkH8PsPf+X16O1/XvI32tq373pJID932Hv/AC+vTl1Tiv508RfEX6vz5Jkk/f2qVF9nvGL/AJv5pfZ2XvXcfaweFvapU+SGBKkVKcEqQJzX8u06Z7vMMVKkC05Up4SvVp0xcw0LT1SnhKeqV6lOmHMNVKeE4p6pTwnFepTphzDAlPCc08JTwnNerTpi5hqpTwtPVKeEr1KdMXMNCU9Up4SnqlerTphzDFSnhOKeqU8JxXqU6Ycw0JTwnNPCdKeE5r1KdMXMMVKkC05UqRUr1adMOYYEqRUpwSpFSvUp0xcwxU4p4TinqnFPCcV6lOmHMN2U8JzTtlSBOa9WnTFzDFWnhaeqU9Ur1KdMOYaEp6pTwlPVK9SnTDmGqnFYHiDX/IDWtq373pJIv8PsPf8Al9ej/EGv+RutbVv3vR5B/D7D3/l9enLBOK/nPxE8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2cHhb2qVPkhoSnhOaeEp4Tmv5ep0z3eYYqc09Up6pzT1SvVp0w5hoWnhKcE4qQJXqU6YuYaqUuypFSnbK9KNPQOY+OVSnqnFPVKeEr+hqVM/yk5hoSnhOaeFp6pzXqU6YuYYqU9U4p6pT1TivVp0w5hoTinhKeE4FPCV6lOmLmGKlSKnFOVKkVa9SnTDmGBKkVKcFqRVr1KdMXMMVKeE4p6pTwnFepTphzDAnSpAnNOCdKkCc16tOmHMMVKeqcU9Up4WvUp0xcw0LUipTgtSKterTphzDFSnhOKeqU8JxXqU6YuYYE6Vg+INe+zlrW1b970eQH7vsPf+X16O8Qa/5Aa1tW/e9HkH8PsPf+X16cuE5Ffzn4ieIv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7WDwt7VKm3RDAnNPVKeE5p6pX8vU6Z7vMMVOKkCU5VqQLXqU6Ycw1Up6pT1WnqlerTpi5hgTipAnIpwTipAlepTphzDAnNPVKeE5p6pXqU6YuYYqcVIFpwWpAterTphzDFSpFSnKtPVK9SnTFzDQlPCc08JTwlepTphzDVTmnqlPVOaeq16tOmHMMVOKeEp6pxTwlepTpi5hqpT1SnhKeqV6lOmLmGhKeE5p4SnhK9WnTDmGKnNPVKeqc09Vr1KdMOYYE4qQJ0pypxUgSvUp0xcw1Up6pTlSpFSvUp0w5hgSsHxBr/kbrW1b970eQfw+w9/5fXo7xBr/AJG61tW/e9HlH8PsPf8Al9enLhK/nTxE8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2cHhb2qVNuiGKlSKlOC1IqV/L1Ome7zDAnFPCcU8JxTwnFepTphzDAlSBOacE5p4TmvVp0xcw1Up4SnqlPCV6lOmHMNCU9Up4WnqlepTpi5hgTipAnFOCcVIE4r1adMOYYE5p6pzTwnNPCc16lOmHMMVKkCU5UqQLXqU6YuYYEqRUpwWpFSvVp0w5hgTin7KeE4p4SvUp0xcw0JzTwnNPCc08JzXqU6YcwxUqQJTlWnha9SnTFzDQlSKlOC09Ur1adMOYaE4p4SnhOKeEr1KdMOYaE5p6pzTwnNPVea9SnTFzDFSsDxBr/kBrW1b970eQH7vsPf+X16P1/X/I32tq373o8g/h9h7/y+vTllTiv508RfEX6vz5Jkk/f2qVF9nvGL/m/ml9nZe9dx9nB4W9qlTbohoTpTwlPC08JX8u06Z73MNVKeE4p6pT1SvVpUxcw0JT1TmnBKkCc16lOmHMMVKeqcU9Up6rxXqU6YuYYEqQJTgtSBK9WnTDmGKlSBOKcqVIqV6lOmLmGBKkCU4JUirXqU6YcwxUp4TinqlPCcV6tOmHMMCdKkCc04J0p4TmvUp0xcw1Up6pxT1SnhK9SnTDmGhKeEp4WnqterTpi5hipUgTinKlSBOK9SnTDmGBKeE5p4TpTwnNepTpi5hipUipxTlSpFWvVp0w5hgSpFSnBakVa9SnTDmGKlYHiDX/I3Wtq373pJID932Hv/AC+vR/iDX/I3Wtq373o8g/g9h7/y+vTl1Sv5z8RPEX6vz5Jkk/f2qVF9nvGL/m/ml9nZe9dx9nB4W9qlT5IYE4p4TmnhKeE5Ffy9Spnu8wwJzUipTgnNSKlerTpi5hipxUgSnBKeFr1KdMOYaEp6pT1WnqlepTphzDQlPCc08JTwnNerTpi5hipzT1SnqnNPVK9SnTDmGhOKeEp6rxTwlepTpi5hqpT1SnqtPVK9WlTDmGBKkCc04JUgTmvUp0w5hipzT1SnqnNPVK9SnTFzDAnFSBacF4qQJXq06YuYYqVIqU5Vp6pXqU6Ycw0JUgTmnBKeFr1KdMXMNVKeqcU9Up6pxXqU6YcwwJxTwlPCcU8JXq06Ycw0JzWB4g1/yN1rat+96PID9z2Hv/L69H+INf8AI3Wtq373o8i/w+w9/wCX16csEr+c/ETxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcfZweFv+8qfJDVSnhKeqU8JX8vU6Z7vMNVKeqU8LT1SvUp0w5hgTinhOKeE4p4TivUp0xcw0JzT1TmnhOaeqc16tOmHMMVKkCU5UqQJXqU6YcwxUqRUpwWpFSvUp0xcwwJxT9lPCcU8JXq06YcwwJzUipzTgnNSBOa9SnTFzDFSnhKeqU8JXqU6Ycw0JT1SnhaeqV6tOmLmGhOKeEp4TinhK9SnTDmGBOaeqc08JzT1TmvUp0w5hqpTwlPVKeFr1adMXMNCU9UpwWpFSvUp0w5hgTipAlOCcVIEr1KdMXMMCc1ga/r3kFrW1b970eQH7vsPf8Al9ej/EGv+QWtbVv3vR5B/D7D3/l9enLqnNfzp4i+Iv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7WDwt7VKi9EMVKeqcU9Up6pxX8u06Z7vMMCdKkCU4LTwlerTpi5hqpTwnFPVKeEr1KdMOYaEp6pTwlPCV6lOmLmGqlPCcU9Up4TivVp0w5hgTpTwnNPC9KeE5r1KdMOYaqU8JxT1SnqlerTpi5hoSnqlPCU8JXqU6YuYYqU8JxT1SnhOK9SnTDmGhOlPCc08L0p4TmvVp0w5hipUgTinKlSKlepTpi5hgSpAlOCVIq16lOmHMMVKeE4p6pTwnFepTpi5hmypAnNO2VIE5r1adMOYYqU9U4p6pTwlepTpi5hoSsDxBr/kbrW1b970kkX+H2Hv/L69H+INf8jda2rfvejyD+H2Hv8Ay+vTlglfzn4i+Iv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7WDwt7VKnyQ1Up4SnhaeqV/L1Ome7zDQlPCc08JTwnNerTphzDFTmnqlPVOaeqV6lOmLmGBOKkCU4JxUgSvUp0w5hgSnbKkVadsr0o09Bcx8cheaeq08JzT1Wv6GpUz/KTmGhaeF5p4WnhOa9SnTDmGqtPVeO9OVKkVOOlerTpi5hgTinhKeE46U8J0r1KdMOYaF5p6rTwnNPVa9SnTDmGBakC04JUgTmvVp0xcwxVp4XinqlPCcV6lOmLmGheKeFp4TjpTwlepTphzDAvNPVaeF5p6pXqU6Ycw0JUgSnBKeE5r1KdMXMNVawPEGv8AkBrW1b970eQfw+w9/wCX16P8Qa/5G61tW/e9HkB+77D3/l9enLKlfzp4ieIv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7WDwt7VKi9ENC8U8L0p4TinhK/l6nTPd5hgXmnqvNPCc9Keqc9K9SlTFzDVWnhaeq08JXq06Ycw0LT1SnhOaeqV6lOmHMMC8VIF6U4JxUgWvUp0xcwwLz3p6rzTwnPSnqnPSvVp0xcwxVqQJTlSpAlepTphzDAlSKlOCc1IqV6lKmLmGKtSBacE4p4WvVp0w5hqrzT1X609U56U9U9q9SnTDmGKvFPCU9U46U8JxXqU6YuYaEp6rTwlPVK9SnTDmGqtPC08JTwnSvVp0xcw1V5p6r9aeqc9Keqe1epTphzDFXinhKeqcdKeE46V6lOmLmGBawfEGv+RutbVv3vSSQfw+w9/wCX16O8Qa/9n3Wtq373o8o/h9h7/wAvr05cJzX86eIniL9X58kySfv7VKi+z3jF/wA380vs7L3ruPtYPC3/AHlRadEMVKkVacqVIE4r+XqdM93mGBakVacFqRUr1KdMXMMVeKeF4p6pxTwnFerTphzDNlSBOads9qkCc16lOmHMMVaeq09Up4SvUp0xcw0LT1SnhKeqV6tOmHMNVeKeF4p6pTwnFepTpi5hgXmnheaeE56U8Jz0r1KdMOYaq09Vp6rTwlepTpi5hgWpFSnBKkCc16tOmHMMCVIF4pypUgTivUp0w5hgXmnheaeE5HFPCc9K9SnTFzDFWpFWnKtPVK9WnTDmGhakVKcEqRUr1KdMXMMVaeFp6pTwtepTphzDQvNYHiDX/ILWtq373o8g/h9h7/y+vR/iDX/I3Wtq373o8gP3fYe/8vr05YJzX86eIviL9X58kySfv7VKi+z3jF/zfzS+zsveu4+zg8Le1Spt0Q1Vp6rx3p6p7U9U46V/LtOme9zDAvFPCU8Jx0p4SvVpUxcw1Up4SnhOaeqV6lKmLmGBakC804LUgTmvUpUw5hirT1XjvT1T2p6px0r1adMOYYF4qQJTgnHSpAlepTpi5hipUirTgnNSKlepTphzDAtSBacFqQJzXq06YuYYq08LxT1SnhOK9SnTDmGBeKkCU4Jx0qQJXqUqYuYYF5p6rTwnNPVa9WnTDmGhaeq08LTwnNepTphzDVWnheKeqU8JxXqU6YuYYF4p4TmnhOOlPCc9K9SnTDmGheaeq08LzT1WvVp0xcwwLWD4g1/yN1rat+96PIP4fYe/8vr0d4g1/wAgNa2rfvejyA/d9h7/AMvr05cLX85+IviL9X58kySfv7VKi+z3jF/zfzS+zsveu4+1g8Le1Sp8kMC1IqU4JzUipX8vU6Z7vMMCcU8L0p4TinhOlerSpi5hoXmnqvNPCc9Keqc9K9SnTDmGKtPC09Vp4WvUp0xcw1Vp6pTwnNPVK9WnTDmGhKeF6U8JxTwlepTphzDVXmnqv1p6pz0p6p7V6lOmLmGKvFPC09U46U8JXq06Ycw0LT1SnhOaeqV6dOmLmGKtSBelOCcVIFr1adMOYYq809V+tPVOelPVPavUp0xcwxV4qQJTlTjpUgSvVp0w5hgSpFSnBOakVK9SnTDmGKtSBacq1IFr1KdMXMMVaeq09Up6p7V6tOmHMMC8d6wPEGv+QGtbVv3vR5B/D7D3/l9ej/EGv+QGtbVv3vR5Afu+w9/5fXpy4TjpX85+IniL9X58kySfv7VKi+z3jF/zfzS+zsveu4+zg8Le1SovRDAtPCc0/ZTwnNfy9Spnu8w1Up6rT1SnhOK9SnTDmGhaeq08LT1SvVp0xcwwLxUgXinKnFPCcV6lOmHMNC808JzTwnPSnhOelepTpi5hipUirTlSpAnFepTphzDAtSKtOC1IqV6tOmHMMCU8LxTwnFPCcV6lOmLmGheaeE5p4TnpTwnPSvUp0w5hirT1WnqlPCV6tOmLmGhaeqU8JT1SvUp0w5hoSnhaeqU8JXqU6YuYaF5p6rz3p4TnpT1TnpXqU6YcwxVp4XinqntTwnFerTphzDAtSKlOCVIE5r1KdMXMMCVg+INf8jda2rfvejyL/B7D39+316O8Qa/5G61tW/e9HkB+77D3/l9enLhOK/nPxF8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2cHhb/vKi9EMCVIF5pwSpAnNfy9TpnvcwxVp6rx3p6p7U9U46V6tOmLmGBeKkC04Jx0qQJXqU6YcwxUp6pT1SnqlerTpi5hoSpFXmnBKeEr1KdMOYaq08LxT1SnhOOlepTpi5hgXpTwlPCcdKeE5r1KdMOYaqU8JTwnNPVK9WnTFzDAtSBaeFp4TmvUp0w5hirUgXinKlSBOOlerTpi5hgXpTwnNPCcdKeE56V6dOmHMMVKkVacqc1IqV6tOmHMMC1IFpwWpAnNepTpi5hipTwvFPVKeE4r1adMOYbtp4Tmn7KeE56V6lOmLmGBeawNf1/wAjda2rfvejyD+H2Hv/AC+vR/iDX/ILWtq373pJID932Hv/AC+vTllTnpX85+IviL9X58kySfv7VKi+z3jF/wA380vs7L3ruPtYPC3tUqL0Q0JTwtPVKeFr+XqdM93mGhaeq08JzT1SvVp0xcw0JTwvIp4TinhK9SlTDmGKvNPVaeqc9Keqe1epTphzDFXipAtOVOOlSBa9SnTFzDAtO2/WpAnNO2e1elGnoLmPjkLzT1Wnheaeq1/Q1Kmf5S8w0LTwlOCVIFr1aVMXMMVKkVacq1Iq16lOmHMMC8dqeFp4Xinha9SnTFzDAvNSKtOC81Iq16tOmHMMC1IEpwSpAtepTphzDFSnheKeq08LxXqU6YuYaF4p4WnheKeFr1aVMXMMC809Vp4XmnqtepTphzDQlYHiDX/s+61tW/e9JJB/D7D3/l9ej/EGv/Z91rat+96SSD+H2Hv/AC+vTlglfzn4ieIv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7WDwt7VKnyQ0JT1SnhKeq1/L1Ome7zDAvFSBacF4qQLXqU6YuYYF57U9V5p4XmnqvNerTphzDVWnhacq1IFr1KdMXMMCVIqU4LUirXqU6YcwwLxUgWnBeKkC16tOmLmGBee1PVeaeF5p6rzXqU6YcwxVp4SnqtPC16lOmLmGhKeq08LT1WvVp0w5hoWnhaeFp4SvUpUw5hoTmnqtPVeaeq16lOmLmGKvFPC8CnqvFPC8V6lOmHMNC09Vp4WnqterTpi5hirxUgSnhaeEr1KdMOYYqc1Iq04LzUirXqU6YuYYq8dqwPEGv+QGtbVv3vR5B/D7D3/l9ej9f1/wAgNa2r/vejyD+H2Hv/AC+vTlgvFfzp4ieIv1fnyTJJ+/tUqL7PeMX/ADfzS+zsveu4+1g8Le1Sp8kMC9KkC804LUgXmv5ep0z3eYYq1IFpyrUgWvUpUw5hgWpAlOCVIq16tOmLmGKlPCcU9Vp4XivUp0w5hm2pAvNO21IF5r1KdMXMMVaeq8U9Vp4WvVp0w5hoSnqlPCU8LXqU6Ycw1Up4XinKtSBeK9SlTFzDAvIp4XmnhaeF5r1KdMOYaq09V4p6rT1WvVp0xcwwJUipTgtSKtepTpi5hirTwvFPVaeF4r1KdMOYaF5FPC808LTwvNerTphzDFWnheKeq09Vr1KdMXMNCU8LTwtPVa9SnTDmGqtYHiDX/IDWtq373o8g/h9h7/y+vR/iDX/I3Wtq373pJKP4fYe/8vr05ZVr+dPETxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcfZweFvapUXohoWnheaeFp4Wv5dp0z3uYaq09V4pyrUirxXq06YuYYF4p4WnheKeFr1KdMOYaEp6rTgvNSKtepTpi5hgWpAvNOC1IFr1adMXMMVKeq8U9Vp6rXqU6YcwwLxUgSnBeKkC16lOmHMMC809Vp4XmnqterTpi5hoWpFWnBaeEr1KdMOYaqU8JxT1WnheK9SnTFzDAvFSBeacF4qQLXqU6YcwwLzT1Wnheaeq16tKmLmGhaeEpwSpAlepTphzDVSnheKcq1IF4r1KdMOYYF4p4XmnheKeF5r1adMXMNC81ga/r/kbrW1b970eQfw+w9/5fXo/xBr/AJBa1tX/AHvR5B/D7D3/AJfXpyyrzX85+IviL9X58kySfv7VKi+z3jF/zfzS+zsveu4+1g8Le1SovRDFWpAtOVakC1/L1Ome7zDFWpFSnBKeq16tKmLmGhOKeFp4Xinha9SlTDmGhee1PVeaeF5p6rzXqUqYcwxVp4WnqtPC16tOmLmGhKeqU8JT1WvUp0xcw1Vp4WnqtPC16lOmHMNVeaeq/SnBeakVa9SnTDmGKvFPC09V4p4WvVp0xcwwJUipTgtSKtepSphzDAtSBacq1IFr1KdMXMMVeaeq09V5p6rXq06YcwxV4qQLwKcq8VIF4r1KdMXMMCVIq04LUirXqU6YcwxV4qQLTgtPCV6tOmHMNCVga/r/AJG61tW/e9HkH8HsPf8Al9ej/EGv+QWtbVv3vR5B/B7D3/l9enLBa/nPxF8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2cHhb2qVF6IaF4p4TinqtPC8V/L1Ome7zDNtPC808LTwvNerSphzDVSnhacq1Iq16dOmLmGhaeq04LUirXq06YcwxUp4TinqtPC8V6lOmLmGheRTwvNPC8inhea9SnTDmGKtSBacq1IFr1adMXMMC1IEpwSpFWvUp0w5hipTwlPVaeF4r1KdMOYaF5FPC808LyKeF5r1adMXMMVaeq8U9Vp4WvUp0w5hoSnqlPCU8LXqU6YuYaqU8LT1Wnha9SnTDmGheaeq89qcF5qRV5r1aVMXMMVaeF4p6rT1XivUp0w5hgSsHxBr/AJG61tW/e9HkX+H2Hv79vr0d4g1/7PutbV/3vR5B/D7D3/l9enLha/nPxF8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2cHhb2qVF6IYEqRUpwWnqtfy9Tpnu8w0LUgXmnBakC816tOmHMMVaeq8dqeq09V4r1KdMOYYF4qQLTgvFSBa9WlTFzDAlPVKeF5p6rXqU6Ycw0LT1WnhaeFr1KdMXMNVaeE4p6rTwvFepTphzDAvFPC808LxTwtepTpi5hoSnqtPC809Vr1adMOYYFqRVpwWpAtepTphzDFSpAnFOVaeF4r1adMXMNC8U8LzTwvFPC816lOmHMMC81Iq04LzUirXqU6YuYYFqRVpwWpAlerTphzDFSnhOKeq08LxXqU6YuYYFrB8Qa/5Ba1tW/e9HkH8PsPf+X16P8Q6/5G61tX/e9HkH8PsPf+X16csFr+c/EXxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcfaweFvapU+SGBee1PVaeF5p6rzX8vU6Z7vMNVaeFp6rTwterTpi5hqrT1Snhaeq16lOmHMMCVIEpyrUgWvUp0w5hirzT1X6U9V5p6rXqU6YuYYq8VIF6U5V4qQLXq06YcwxVp236VIFp2yvSjT0FzHxyF5p6pTwnNPVK/oalTP8pOYYEqQLTgnFSBa9SnTDmGKtSKtOVakVPavUp0xcwwLx3p4WnhOOlPCdK9WnTDmGBOakVKcE5qRUr1KdMXMMVakC04JxUgWvUp0w5hirT1XinqlPVOK9WnTFzDQvFP2U4JxUmyvUp0w5hgTmsDxBr/kbrW1b970kkH8PsPf+X16P8Qa/wCQWtbVv3vR5Afu+w9/5fXpywTmv508RPEX6vz5Jkk/f2qVF9nvGL/m/ml9nZe9dx9rB4W9qlRadENVKeEp6pTwnFfy7Tpnucw0LT1Wnhaeq16tOmHMMC8VIEpwTipAlepTphzDAvPenqvNPCc9Keqc9K9SlTFzDFSpAvFOVPapAnFepTphzDAtSKtOC1IqV6lOmLmGBeKkCU4JxTwlerTphzDQvNPVeaeE56U9U56V6lOmLmGKlPC8U9U9qeF4r1KdMOYaFp6rTwtPVK9WlTDmGqlPCU8JxTwlepTpi5hoXmnqtPCc09U9q9SnTDmGKvHenheKeqcdKeE46V6tOmLmGhaeqU8JT1SvUp0w5hipUgSnKlSBa9WnTFzDAvNYHiDX/I3Wtq373pJIP4fYe/8AL69H+INf8jda2rfvejyA/d9h7/y+vTl1Sv5z8RfEX6vz5Jkk/f2qVF9nvGL/AJv5pfZ2XvXcfaweFvapUWnRDFWnheKeq08Jx0r+XqdM93mGBelSBeacE6cVIE5r1KdMXMMVaeqU9Up4TivUp0w5hoSnqvNPCU8JXq06Ycw1Vp4XinqtPCcV6lOmLmGbakC807Z7U8JzXqU6Ycw1Up6pT1SnqlerTpi5hoSnqvNOC1Iq16lOmHMMVakC8U5UqQJxXqU6YuYYF6U8LzTwntTwnPSvVp0w5hipUgSnKnPSpFSvUp0w5hgWpAtOC1IE5r1KdMXMMVaeE4p6pTwnFerTphzDQvSnheaeE6U8Jz0r1KdMXMMVKeq09U56U9Ur1KdMOYaFrA8Qa/8AZ91rat+96PIP4PYe/wDL69H+INf8jda2rfvejyA/c9h7/wAvr05YJ0r+dPEXxF+r8+SZJP39qlRfZ7xi/wCb+aX2dl713H2cHhb2qVFp0Q1V5p6rTwlPVK/l2nTPd5hoSnhKeEp4TmvVp0w5hirUirxTlSpFT2r1KdMXMMC8U8LTwnHSnha9WnTDmGBeakVacE5qRUr1KdMOYYEqQJTgnFSBK9SnTFzDFWnqvFPVaeqe1erTphzDAvHepAtOCcdKkC16lOmLmGBeaeqU8JzT1SvUp0w5hoSnhaeE4p4SvUp0xcw1Vp4XinqtPVOK9SnTDmGBeKkC04Jx0p+yvVpUw5hoTmnqlPCc09Ur1KdMXMMCVIFpwTipAtepTpi5hqrTwvFOVakVOK9WnTDmGBeKwPEGv+RutbVv3vR5B/D7D3/l9ej/ABBr/kBrW1b970kkB+77D3/l9enLhOlfzn4i+Iv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7WDwt7VKnyQwLz3p6rzTwnPSnqnPSv5ep0z3eYYqVIEpypTwnFerTpi5hoWpFWnBKeq16dOmHMNC8U8LTwnFPCdK9WlTFzDQvPenqvNPCc9Keqc9K9SnTDmGKlPCU9U9qeE4r1adMOYaFp6rTwtPVa9SnTFzDQtPCU5UqQJXqU6Ycw1V5p6rTlTmpFT2r1adMXMMVeKeF4p6px0p4TjpXqU6YcwwLUirTgtSKlepTpi5hipUgSnBOKkCV6tOmHMMC809Vp6pzT1T2r1KdMOYYq8VIF4pypx0qQJx0r1KdMXMMC1Iq04JT1SvVp0xcw1UrA8Qa/5G61tW/e9HkX+H2Hv/L69H+INf8jda2rfvejyA/c9h7/y+vTllSv5z8RfEX6vz5Jkk/f2qVF9nvGL/m/ml9nZe9dx9rB4W9qlT5IaEp6pTwlPVK/l6nTPd5hqrTwvFPVKeF4r1KdMOYZtp4Xmn7Panhea9SlTFzDFWpAtOVKkCcV6tOmHMMCVIF5pwSpFSvUp0xcwxVp4XinqtPC8V6tOmHMNC8inheaeE5HFPCc9K9SnTDmGKtPVKeqU8JxXqU6YuYaEqRV5pwSnhK9WnTFzDVWnheKeq08JxXqU6Ycw0L0p4XmnhPanhOelepTpi5hipT1SnqlPVK9SnTDmGhKeq808LT1WvUp0w5hqrTwtOVKkCV6tOmLmGBeRUirzTgnNSKnPSvUp0w5hirWB4g1/yA1rat+96PIP4fYe/wDL69H6/r/kb7W1b970eQH7vsPf+X16csqcdK/nPxE8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2cHhb2qVPkhgTipAtOCcdKkCdK/l+nTPe5hgXmpFWnBeakVa9SnTFzDAtSBeacEqQJzXqU6YcwxVp6rxT1SnqnHSvVp0xcwwJxTwtPCcdKeFr06dMXMNC809Vp4XmnqlerTphzDQlPCU8JTwnNepTphzDVWnheKeqU8LxXq06YcwwLxTwtPCcdKeFr1KdMXMNC809VpwTmpFSvUp0xcwwJUgSnBOKkCV6tOmHMMVaeF4p6rTwvFepTpi5hoXinheaeE46U8Jz0r1KdMOYYF5p6pTwnNPVK9WnTDmGhKeFp4TinhK9SnTFzDVWsDxBr/kbrW1b970eQfw+w9/5fXo/wAQa/5G61tW/e9JJAfu+w9/5fXpyypX85+IniL9X58kySfv7VKi+z3jF/zfzS+zsveu4+1g8Le1SotOiGheKeF6U8LxTwtfy9Tpnu8wwLz3p6rzTwnPSnqnPSvUp0xcw1Vp4SnqlPCcV6tOmHMNCU9VpwSpFWvUp0xcwxVqQLTglSBOlepSphzDFXmnqv1p6pz0p6p7V6tOmLmGKvFSBKcqcdKkCcdK9SnTDmGBadsqQJTtlelGnoHMfHITmnqlPCc09Ur+hqVM/wAo+YYq1IFpyrUgWvUpUw5hirT1SnhKkVK9WnTDmGBeKeF6U8JxTwnSvUp0xcwwLzUipTgnNSKlerTphzDAtSBacq1IEr1KdMXMMVaeqU9Up6pXqU6YcwwJxWD4h1/yN1rat+96PIP4fYe/8vr0f4g1/wAgNa2rfvejyD+H2Hv/AC+vTlgnFfzp4ieIv1fnyTJJ+/tUqL7PeMX/ADfzS+zsveu4+1g8Le1SovRDAvNPC81IE6U8JzX8u06Z7vMMVaeq09Up6rXq06YuYaFp6rTwtPCV6lOmLmGBeKkCU5UqQJXqU6YcwwLzT1XntTwnIqRV5r1adMOYjVakC8U9Up6pxXqU6YcwwLUirTglSKlepTpi5hipTwlPVKeEr1KdMXMNC809V57U8LzT1XmvUp0w5hirTwvFPVKeE4r1adMXMNC08JTwlPVK9SnTDmGqlPC09Up4WvUpUw5hoXmnqtPC09Ur1adMOYYq8dqeF4p6pTwnFepTpi5hgWpAlPCU8JzXq06YuYYqVg+INf8AI3Wtq373o8o/h9h7/wAvr0d4g1/yN1rat+96SSj+H2Hv/L69OXVK/nPxF8Rfq/PkmST9/apUX2e8Yv8Am/ml9nZe9dx9rB4W9qlT5IYFqRVpwWpAtfy9Tpnu8wxVp4XinqtPCcV6lOmHMMC8VIF5p4TinhOa9SnTFzDFXmnqlPCc09Ur1aVMXMNC09Vp4Wnha9SnTDmGqtPC8U9Up4TivUp0w5hmynheaeEqQJzXq06YuYYq809Up4TmnqlepTphzDAtSKtPC08JXqU6YuYYq1IE4pypUgTivVpUw5hgTpTwvPanhKkC816lOmLmI1WpFWnqnNPVK9SnTDmGBakVacFqQJXq06YcwxUp4TinqlPCV6lOmLmGhKeF57U8JTwvNerTphzDFXmsDX9f8jfa2rfvejyD+H2Hv/L69H6/r/kFrW1b970eQfw+w9/5fXpy6rX85+IviL9X58kySfv7VKi+z3jF/wA380vs7L3ruPs4PC3tUqbdEMVeKeFp6pxTwlfy9Tpnu8w1Vp6rTwlPVK9SnTDmGBKkCU8JTwtepTphzDFWpFWnhaeq16tOmLmGBeO1PC9KeE4p4TpXqU6YuYYF5qRUpwTmpFSvUp0w5hgSpAlOVakC16tOmHMMVaeq08LT1SvUp0xcwwLx2qQL0p4TinhK9SnTDmGBeaeqU8JzT1SvVp0xcw0LTwtPVaeFr06dMOYaq08LxT1WnqlerTpi5hgTinhaeE4qTZXqU6YcwwLzT1SnhOaeqV6lKmHMMVakC05VqQLXq06YuYYq1g+INf8AI3Wtq373o8g/g9h7/wAvr0d4g1/yN1rat+96PIP4PYe/8vr05cLX85+IviL9X58kySfv7VKi+z3jF/zfzS+zsveu4+zg8Le1SotOiGBeKkC05UqQJX8vU6Z73MMCc09V5p4TmnqnNepTpi5hirTwvFPVKkVOK9WnTDmGBaeq08LUirXqUqYuYYF4p4SnqlPCV6lKmHMNCc09V57U8JyKeqc16tKmLmGKtPC8U9Up6pxXqU6Ycw0LT1WnhaeEr1KdMOYYqVIEpypUgWvVp0xcwwLzUirTwlPVa9SnTDmGKvHanheKeq8U8JxXqU6YuYYFqRVpwSpAnNerSphzDFSpAtOVKkC16lOmLmGBeaeq08LUirXqU6YcxGq8dqeF4qRUp4TivVp0w5hgWsDxBr/kFrW1b970eRf4fYe/8vr0f4g1/wAjda2rfvejyD+H2Hv/AC+vTlwnNfzn4i+Iv1fnyTJJ+/tUqL7PeMX/ADfzS+zsveu4+zg8Lf8AeVFp0QxVp4XinhOaeqV/L1Ome7zDQlPC08LTwtepTphzDFWpAvFPVaeF4r1KdMXMM208LzTwlPCc16tOmHMMVakVKeE5p6pXqU6YuYYFqRVpwWpAterTphzDFWnheKeq1IE4r1KdMXMMCdKeF5p4SnhOa9SnTDmGKtPVeKeqc1IqV6tOmHMMC09Vp4WpAtepTpi5hirTwvFPVKeE4r1KdMOYYE6VIF57U8JTwnNerTpi5hirT1XinqnNPVK9SnTDmGBakVaeFp4SvUp0xcwxVqQJT1SnhK9SnTDmGBKwfEGv+QWtbVv3vR5F/h9h7/y+vR3iDX/I3Wtq373pJIv8HsPf37fXpy4Sv5z8RPEX6vz5Jkk/f2qVF9nvGL/m/ml9nZe9dx9nB4W9qlRadEMVKeq09U5qRUr+X6dM93mIwvHapAtPC8U8J0r1KdMOYYF5p6rTwvNSKlepTphzDAtPCU9Up4SvUp0xcw1Vp6rT1TmnqterTphzDAvHanhelPC8VIE6V6lKmLmGBeaeq08JzT1SvUp0w5hgSpAlPCU8LXq06YuYaq08LxTwtPVa9SnTDmGBeKftp4TinhK9SnTDmGBeakVKeE5p6pXq06YuYYEqQJTlWpAtepTpi5hirTwvFPC1IqV6lOmHMMC8U8LzTwnFPCcivVp0xcwwLzT1WnhOakVK9SnTDmGBawPEGv8AkbrW1b970eQfw+w9/wCX16P8Qa/5G61tW/e9JJB/D7D3/l9enLBOK/nPxE8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2sHhb2qVF6IaEp6rTwtPC1/L1Ome7zDAvFSBaeFp4SvUp0xcwwLzT1XmpAnNPVOa9WnTDmI1WpAlPVKeqcV6lOmLmGBKkVacFqQLXqU6YcwxV4qQJTlSpAlerTphzDFTmnqtPCc1IqV6lOmLmI1XjtUgXinqvFPCcV6tOmLmGBads9qkCU7b9K9GNPQOY+OQnNPVKeEp4Sv6GpUz/ACk5hgSpAlOVKkCV6tOmLmGKnNSKlOVKkVK9SnTDmGBOKeE4p4TinhOK9SnTDmGBOakVKcE5qRU5r1adMXMMVKeEp6pTwlepTphzDQnNYHiDX/I3Wtq373o8g/h9h7/y+vR/iDX/ALPutbVv3vSSQfw+w9/5fXpywTmv508RfEX6vz5Jkk/f2qVF9nvGL/m/ml9nZe9dx9nB4W9qlTbohqpTwnFPVKeE4r+XadM93mGhKeE5pwTpUgTmvVp0w5hipTwlPVKeqV6lOmHMMCVIqc04JUipXqU6YuYYqVIEpypUgSvVp0w5hgSpFTmnBKkVOa9SnTFzDFSnqnFPVKeqcV6lOmHMMCVIE5pwTpUipXqU6YuYYqVIEpypTwlepTphzDQlPVOaeEp6pzXq06YcwxUp6pxT1SnqnFepTpi5hoSnhOaeE6U8JXqU6YuYaqU8JT1SnhOK9WnTDmGhKeqU8JT1SvUp0w5hipTwnFPVKeE4r1KdMXMNCdKwPEGv/Z91rat+96PID9z2Hv8Ay+vR/iDXvI3Wtq373o8gP3fYe/8AL69OWCV/OniL4i/V+fJMkn7+1Sovs94xf8380vs7L3ruPtYPC3/eVNuiGBOakVKcE5qRUr+XqdM93mGBKkCU4JUgSvUp0xcwxUp4TinqlPCcV6lOmHMNCcU8JzTwnFPCc16tOmHMMCc09Up4TmnqlepTpi5hoSnhKeE4p4SvUp0xcw1Up4TinqlPCcV6tOmHMMCVIE5pwSpAnNepTphzDAnNPVKeE5p6pXqU6YuYYEqQJTgnFSBK9WnTDmGKlSBOKcqVIEr1KdMXMMCVIE5pwSpAnNepTphzDFTmnqlPVOaeqV6tOmLmGBOKkCU4JxUgSvUp0w5hipTwnFPCU8JXqU6Ycw0JWB4g17yC1rat+96PIP4fYe/8vr0f4g1/yN1rat+96PIP4fYe/wDL69OWCV/OniL4i/V+fJMkn7+1Sovs94xf8380vs7L3ruPs4PC3tUqfJDQnNPVKeqc09Ur+XqdM93mGKnFPCcU9U4p4TivUp0xcw0JT1SnhKeqV6lOmHMMVKkCU5UqQJXq06YcwxU5qRUp6pT1SvUp0w5hgTinhOlPCcU8JxXqU6YuYaE5p6pTgnNSBK9WnTFzDFSpAtOCVIEr1KdMOYYqc09Up6pT1SvUp0xcw0JxTwnSnhOKeE4r1adMOYYE5p6pTwnNPVK9SnTDmGqlPCU9Up4SvUp0xcw1U5p6pTwnNPVK9SnTDmGBOKk2U4JxUmyvUp0xcwwJzT1SnhOaeqc16tOmHMMCVg+INe8jda2rfvekkgP3fYe/8vr0dr+v+RutbVv3vR5Afu+w9/5fXpy4Sv5z8RfEX6vz5Jkk/f2qVF9nvGL/AJv5pfZ2XvXcfZweFvapU+SGBakVOacEqRUr+XqdM93mGKlSBKcqVIEr1KdMOYYE5p6pzTwlPVOa9WnTDmGKlSKnFOVKeqcV6lOmLmGhKeqc08J0p4TmvUp0w5hqpTwlPVKeEr1aVMXMNCc09U5p4SnqnNepTphzDFSnhOKeqU9U4r1KdMXMMCVIqc04JUipXq06YcwxUqQJTlSpAlepTphzDAtSKlOCVIqV6lOmLmGKnFPCcU9Up4TivVp0w5hgSpAnNOCdKkCc16lOmLmGKlSBKcqU8JxXqU6Ycw0JT1SnhKeqV6tOmLmGqnFYHiDXvIDWtq373pJID932Hv8Ay+vR+v695G61tW/e9HkB+57D3/l9enLBOK/nPxF8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2sHhb2qVPkhgTipAnNOCcVIE5r+XqdM93mGBOaeqU8JzT1SvUp0xcw0JTwtOCVIEr1KdMOYaqU8JxT1SnhOK9WnTFzDAlPCc08JTwnNepSphzDQnNPVKeE5p6pXq06YcwwJUgSnBKkCV6lOmLmGKlSBOKcqU8JxXqU6Ycw0J0p4TmnhKeE5r1adMXMMVOakVKcqc1IqV6lOmHMMCU8JTwnFPCV6lOmLmGqlPCcU9Up4TivVp0w5hoSnhOaeEp4TmvUp0w5hipzT1SnqnNPVK9SnTFzDAlSBKcE4qQJXq06YcwxUrB8Qa/wCRutbVv3vR5F/h9h7/AMvr0d4g1/7PutbVv3vR5F/h9h7/AMvr05dUr+c/EXxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcfZweFvapU+SGBOKkCU5U4qQJX8vU6Z7vMMCVIqU5UqRUr06dMOYYE4p4SnhOKeE6V6tOmLmGBOakVKcE5p6pXqU6Ycw1Up4SnqnFPC16tOmLmGhKeqU9Up6pXqU6YcwwJxTwlPCcU8J0r1KdMOYaE5p6pTwnNPVK9WnTFzDFSpAlOVKkCV6lOmHMNVOaeqU9Up6pXqU6YuYYE4p+ynhOKfsr1adMOYaE5p6pTwnNPVK9SnTFzDFSpAtOCVIEr1KdMOYYqc1IqU5Up6pXq06YuYaE4p4TkU8JxTwnSvUp0w5hgTmsHX9e8jda2rfvejyA/d9h7/AMvr0d4g17yC1rat+96PID932Hv/AC+vTl1Tmv5z8RPEX6vz5Jkk/f2qVF9nvGL/AJv5pfZ2XvXcfaweFvapUXohipT1TinqlPVOK/l6nTPd5hoSnqnNPCU9Ur1KdMXMNVKeEpypUgSvVp0w5hoTmnqnNOCc1Iqc16lOmLmGKlPVOKeqU8JxXqU6YcwwJUipzTgnSpFSvVp0xcwxUqQJTlSpAlepTphzDAnNSKlOCVIqV6lOmHMMVOKeE4p6pxTwnFerTpi5hgSl2VKE6U7b9a9GNPQXMfHITmnhKeEp4Tmv6HpUz/KXmGKlSBKcqVIFr1KdMXMMC1IqU4LUirXqU6YcwwJxTwnFPCcU8JxXq06YuYYE5qRU5pwTmpAnNepTphzDFSsDxBr/AJG61tW/e9HkH8PsPf8Al9ej9f1/yN1rat+96SSD+H2Hv/L69OWVK/nPxF8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2sHhb2qVPkhoSnqlPCU8LX8vU6Z7nMNVaeE4p6pTwvFerTphzDAnSpAnNOCVIE5r1KdMXMMVKeqU9U5p6pXqU6YcwwJUgWnBakC16tOmHMMVakC05VqQLXqU6YuYYEqRU5pwSpFTmvUp0w5hipT1TinqlPVOK9WnTFzDAtSBacEqQLXqU6YcwxUp4SnqtPVK9SlTFzDQlPVOaeEp6pzXqU6YcwxUp6pxT1SnqnFerTpi5hoWnhKeEp4WvUp0w5hqpTwlOVKkVK9SnTDmGhKeEpwSpFTmvUp0xcwxUrA8Qa/5Aa1tW/e9HkH8PsPf+X16P1/X/ACN1rat+96PIP4fYe/8AL69OXVOK/nTxF8Rfq/PkmST9/apUX2e8Yv8Am/ml9nZe9dx9rB4W9qlT5IYE4p+2nhOKftr+XqdM93mGBeakVKcE5qRVr1KdMXMMCVIEpypTwlepTphzDVSnqlPVKeqcV6tOmLmGBOKkC804LxUgXmvUp0w5hgTmnqlPCc09Ur1KdMOYaEp4SnqlPCV6tOmLmGhaeFp6pTwtepTphzDAlSBOacFqQJyK9SnTFzDAnNPVKeE5p6pXq06YcwxUqQJTglSBa9SnTFzDFWpFSnBakC16lOmHMMCVIE5pwSnhOa9WnTDmGqnNPVKeqc09Ur1KdMXMMCcU8JT1Tinha9SnTFzDVWsDxBr/AJG61tW/e9JJB/B7D3/l9ej/ABBr/wBn3Wtq373o8g/g9h7/AMvr05ZUr+dPEXxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcfaweFv+8qfJDQtPC09Vp4Sv5ep0z3eYaE5p6pTwnNPVK9SnTDmGKnFPCcU9U4p4TivUp0xcw0JTwtOCVIFr1adMOYYqVIFpwWpAlepTpi5hgSpFSnKlSKlepTphzDAnFPCcCnhOKeF4r1adMXMMC1IEpwSpAtepTphzDFSpAlOVKeEr1KdMXMNVKeqU8JT1SvVp0w5hgTipAvFOC8VIF4r1KdMOYYF5p6pzTwnNPCc16lOmLmGqlPCU9Up4SvUp0w5hqpT1WnhaeqV6tOmLmGBOKk204LxTwlepTphzDQnNYHiDX/ILWtq373o8g/h9h7/AMvr0f4g1/yC1rat+96PIP4fYe/8vr05YJzX85+IviL9X58kySfv7VKi+z3jF/zfzS+zsveu4+zg8Le1Sp8kMVKkVOKcqVIqV/L1Ome7zDAlSKlOCVIEr1KdMOYYqU8LT1Snha9WnTDmGhKeqc08LT1TmvUp0xcwxUp6pxT1SnqnFepTphzDQlPVKeEp4WvVp0xcw1Vp4WnqlPC16lKmHMNCU9U5pwSpFTmvUp0w5hipT1TinqlPVOK9WnTFzDQlPC04JUgWvUp0xcwxVqQLTlWpFSvUp0w5hgSpFSnBKkVOa9WnTDmGKlPCcU9Up4TivUp0xcwwLUgXmnBOlSBea9SnTDmGKlPCU9Vp6pXq06YuYaErA8Qa/wCQWtbVv3vR5B/D7D3/AJfXo/xBr/kbrW1b970eRf4fYe/v2+vTlglfzn4i+Iv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7WDwt7VKnyQ1Up4TinqlPVOK/l6nTPd5hgTipAnNOCcVIF5r1KdMXMMC809Vp4TmnqlerTphzDAtSBKcFqQJXqU6YuYYqVIE4pypUgSvUp0w5hgSnheaeE4p4XmvVpUw5hoXmnqlPCc09Ur1KdMXMMCVIEpypTwlepTphzDVSnhaeqU8JXq06YuYaEp4TmnhaeE5r1KdMOYYqc09Up6pzT1SvUp0xcw0JxTwlPCcU8JXq06Ycw0LTwtPVKeFr1KdMOYaEp4TmnBakCc16lOmLmGKnNPVKeqc09Ur1KdMOYYE4rB8Qa/9n3Wtq373o8g/h9h7/y+vR3iDX/IDWtq373pJIP4fYe/8vr05cJxX86eIviL9X58kySfv7VKi+z3jF/zfzS+zsveu4+zg8Le1Spt0QwJUipTglSKlfy9Tpnu8wxVqQLTlWpAtepTphzDFWnqlPCU9Ur1KdMOYaE4p4TpTwnFPCdK9SnTFzDAnNPC08JT1SvVp0xcw0LTwtPVaeEr1KdMOYaEp6pT1SnqlepTpi5hgTinhOBTwnFPCcV6tOmHMNC809Vp4TmnqlepTphzDFSpAtOC1IEr1KdMXMMCVIqU5UqRUr1adMOYYE4p4SnhOKftr1KdMXMNC809U5p4TmnqlepTphzDFSpAlOVKeEr1adMXMNVKeq08JT1SvUp0w5hoTisDxBr/AJG61tW/e9HkH8PsPf8Al9ej/EGv+RutbVv3vSSQfw+w9/5fXpywSv5z8RPEX6vz5Jkk/f2qVF9nvGL/AJv5pfZ2XvXcfaweFv8AvKnyQ0JT1Tmnheaeq81/L1Ome5zDFWnqnFPVKeE4r1KdMOYaEp4SnhKeqV6tOmHMNVKeFpypUgSvUp0xcwwJUipzTgtSKnNerTphzDFSnqnFPVKeqcV6lOmLmGBKkVKcEqQJXqU6YcwxVp4WnqlSBa9WnTFzDAtSKlOCU9Ur1KdMOYaqU8JxT1SnhOK9SnTDmGBKXZUoSl2e1elGnoLmPjoJTwnNP2U8JzX9DUqZ/lJzDFSpAlOVKeEr1KdMOYaFqRUpwSpFSvVp0xcwwJxTwnFPCcU8JxXqU6YcwwJzWD4g17yC1rat+96PID9z2Hv/AC+vR3iDXvI3Wtq373o8gP3fYe/8vr05cJzX85+IviL9X58kySfv7VKi+z3jF/zfzS+zsveu4+zg8Le1Spt0QxU5p6pT1Tmnqlfy9Tpnu8w0JTwlPC08JXq06Ycw1Up4TinqlPCcV6lOmHMMCdKkCc04JUgTmvUp0xcwxU5p6pT1TmnqlerTpi5hgSpAtOCVIEr1KdMOYYqVIE4pypT1TivUp0w5hoTpUipzTglPVOa9WnTFzDVSnqnFPVKeqcV6lOmHMMCU8JTwnFPCV6lOmLmGqlPCcU9Up6pxXqUqYcw0J0p4TmnhKeqc16tOmLmGKlPVOKeqU9U4r1KdMOYaE4p4SnBOKkCV6lOmLmGqlPVKcqVIqcV6tOmHMMCVg+INf+z7rW1b970eQfw+w9/5fXo7xBr/AJG61tW/e9HlH8PsPf8Al9enLhK/nPxF8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2sHhb2qVPkhipUipTlSpFSv5ep0z3eYYE4p+ynhOKfsr1KdMXMMCc1IqU4JzT1SvUp0w5hoTinhKeqcU8JXq06YuYaEp6pT1SnqlepTphzDAnFSBOacE4qQJyK9SnTFzDAnNPVKeE5p6pXq06YcwxUqQJTlTipAlepTphzDVSnqlPVKeqV6lOmLmGBOKkCc04JxUgTkV6tOmHMMCc09Up4TmnqlepTpi5hipUgSnKlSBK9WnTDmGKnNSKlOVKeqV6lOmLmGhKeE5p4SnhOa9SnTDmGqnNPVKeqc09Ur1KdMXMMVOKwPEGv+RutbVv3vR5Afu+w9/wCX16P8Qa95Aa1tW/e9HkB+77D3/l9enLBOK/nPxF8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2sHhb2qVNuiGhKeEp4SnhOa/l+nTPd5hqpTwlPVKeEr1KdMXMNCc09Up4TmnqlepTphzDFTinhOKeqcU8JxXq06YcwwJUgTmnBKkCc16lOmLmGKlSBKcqVIEr1KdMOYYE5qRUpwSpFSvVp0xcwwJxTwnFPCcU8JxXqU6YcwwJUgTmnBKkCc16lOmLmGKlPCU9Up4SvVp0w5hoTmnqlPCU9Ur1KdMOYYE4qQJxTgnFSBOK9SnTFzDAnNPCc08JzTwnNepTphzDFSpAlOVKkC16tOmLmGhKeqU4JUipXqU6YcwwJxWB4g1/yN1rat+96PIP4fYe/wDL69H+INf8jda2rfvejyD+D2Hv/L69OXCcV/OfiL4i/V+fJMkn7+1Sovs94xf8380vs7L3ruPs4PC3/eVPkhgTpTwnNPCU8JzX8v06Z7vMMVOakVKcqc1IqV6lOmHMMCVIE5pwSnhK9SnTFzDVSnqlPVKeE4r1KdMOYaE6U9U5p4SnqnNepTphzDFSnqnFPVKeqcV6tOmLmGhKeEp4SnhK9SnTDmGqlPVKeqU9U4r1KVMXMNCU9U5p4SnhOa9WnTDmGKlPVOKeqU9U4r1KdMXMMCVIEpwTipAlepTphzDFSpAnFOVKkVOK9WnTDmGBKkVKcEqRUr1KdMXMMVKeE4p6pTwnFerTphzDAnSpAnNOCdKkCc16dOmLmGKlYHiDX/I3Wtq373o8i/w+w9/5fXo/xBr/AJBa1tW/e9HkX+H2Hv8Ay+vTllSv508RPEX6vz5Jkk/f2qVF9nvGL/m/ml9nZe9dx9rB4W9qlT5IaqU8JTwnFPCV/L1Ome7zDVSnqnFPCU9Ur1KdMXMMCcVIE5pwTipAnNerTphzDAnNPVKeE5p6pXqU6YuYYE4qQJTlTipAlepTphzDFSpAlOVKkVK9WnTDmGBKeE5p4TinhORXqUqYuYYE5qRUpwTmpFSvUp0w5hgTinhKeqcU8JXq06YuYaEp4SnqlPVK9SnTDmGhKeE5p4SnhOa9SnTFzDFTmnqlPVOaeqV6lOmHMNVOKeEp4TinhK9WnTDmGqlPVKeqU9Ur1KdMXMMCVIE5pwSpAnNepTpi5hipzWBr+veRvtbVv3vR5Afu+w9/5fXo/wAQa95Ba1tW/e9HkB+77D3/AJfXpy6pX86eIviL9X58kySfv7VKi+z3jF/zfzS+zsveu4+1g8Le1Spt0QxU4p4TinqnFPCcV/L1Ome7zDAlSBKcEqQJzXqU6YcwwJTwlPVKeEr1adMXMNCc09Up6pT1SvUp0w5hoTinhOKeE4p4TivUp0xcwwJTwlPCU8JzXqU6Ycw1Up4SnqlPCV6lOmHMNCc09Up6pT1SvVp0xcwwJxTwnFPCcU8JxXqU6YuYaE5p4TmnhOaeqc16lOmHMMVKkCU5UqQJXq06YcwwJzUipTglSKlepTpi5hgTinhKeE4p+yvUp0w5hoTmnhOacE5qQJzXq06YuYYqU8JT1SnhK9SnTDmGhOawPEGv+RutbVv3vSSQH7vsPf8Al9ej/EGv/Z91rat+96PIP4fYe/8AL69OWVK/nPxF8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2cHhb2qVNuiGqlPCU9Up4Tiv5ep0z3uYaEp6pzTwlPVOa9WnTFzDFSnqnFPVKeqcV6lOmHMMCVIE5pwTpUgSvUp0xcwxUqQJTlSpAnFerTphzDAnSpFTmnBKkVOa9SnTFzDFSnqnFPVKeqcV6lOmHMMCVIE5pwSpAlerTpi5hipT1SnqlPCcV6lOmHMNCU9Up4SnqlepTpi5hqpTwnFPVKeE4r1adMOYYE6Uu36VKE6Uu2vRjT0DmPjoJTwvNP208LzX9DU6Z/lHzDFWnhaeq09Ur1adMOYaEp6pTwlSBea9SnTDmGBOKwPEGv+QGtbVv3vR5B/D7D3/l9ej/EGv+RutbVv3vR5B/D7D3/l9enLBK/nPxF8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2cHhb2qVPkhoSnhOaeFp4Xmv5ep0z3eYYqc09Vp6rz3p6rXq06YcwwJUgWnheKeEr1KdMXMMVKkCcU9Up6rXqU6YcwwJUgTmnBakC816tOmLmGKvNPVaeq896eq16lOmHMMCVIEpypxUgSvUp0xcwxUqQJTgvNSKterTphzDAtPVOaeFqQLzXqU6YcwxUp6pxT1WnqvHevUp0xcwwJxTwlPCcU8LXqU6Ycw1Up6rTwvNPVa9WlTFzDQtPVOaeEp4SvUp0w5hipT1TipFWnqvFerTpi5hgTinhKeF4p4WvUp0w5hgWsHxBr/kbrW1b970eUfw+w9/5fXo/wAQa/5Ba1tW/e9HkH8PsPf+X16csF5r+c/EXxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcfaweFvapU+SGBKkC05VqQLX8vU6Z7vMMVakVKcFqRUr1KdMXMMCcU/ZTwvFPC16lOmHMMCc09Up4XmpAvNerTpi5hirTwtPVaeEr1KdMOYaq09Up4SnqlepTphzDAnFSBKeF4p4XpXq06YuYYE5p6rTwvPenqvNepTphzDAtSBaeq08JXqU6YuYYEqRUp4SnqterTphzDAnFPCdKeF4qQL0r1KdMXMMC809Vp4XnvT1XmvUp0w5hipxUgWnKtSBK9WnTFzDAlPVKeFqRVr1KdMOYYFp4SnqtPC16lOmLmGqnNYGv6/5G+1tW/e9JJB/D7D3/l9ej/EGv+QWtbVv3vR5B/D7D3/l9enLKtfzp4i+Iv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7WDwt7VKnyQxU4p4XipFWnheO9fy9Tpnu8wwJTwnNPCU8JzXqU6YcwxUqQJT1WnqtepTpi5hgWpFSnhaeq816tOmLmGKnFPCcU9Vp4XjvXqU6YcwwJUgTmnhOlPCc16lOmHMMVKeFp6rUirXqU6YuYYFqRUpwWpFSvVp0w5hgTinhOKeq8U8LxXqU6YuYYEp4Tmn7KkC816tOmHMMVaeFp6rT1WvUp0w5hoWnqlPC09Ur1KdMXMMCcVIE4p6rTwvFepTphzDAnNPCc08LzTwvNerTpi5hirUgWnqtPC16lOmHMMC1g+INf8AI3Wtq373o8g/h9h7/wAvr0d4g1/yN1rat+96PIv8PsPf+X16cuFr+c/EXxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcfZweFvapU+SGKlPCcU9UqQJX8vU6Z7vMMCU8JzTwtSBea9WnTDmI1TmnqtSKvPenqtepTpi5hgWnhaeF4p4WvVp0w5hqpT1SnqlPCV6lKmLmGhKeqc08LTwvNepTphzDFSnqvFSKtPVeO9epTphzDAnAp4SnheKeEr1KdMXMNVKeEp6pT1WvVp0w5hgWpFTmnBakC816lOmLmGKlPVeKeq09V4716lOmHMMCcCpAlOCcVIEr1adMXMMVKkCU4LzUirXqU6YcwwLUirTgtSBa9SnTDmGKlPCcU9Vp4XivVp0xcwwJ0rA8Q6/5G61tW/e9HkX+H2Hv/L69H+INf8AIDWtq373o8g/h9h7/wAvr05fbX85+IniL9X58kySfv7VKi+z3jF/zfzS+zsveu4+zg8Lf95U26IYE5p6pTwnNPVK/l6nTPe5hoSnhaeq08LXqU6YuYaq09Up6rT1SvVp0w5hgTipAnIpwXipAvSvUp0xcwwJzT1Snheaeq816lOmHMMCVIFpyrUgWvVp0xcwxVqRUpwWpFSvUp0w5hgTinhKeE4p4XpXqUqYcwwJzUipTwvPenqvNepTpi5hirTwtPVaeEr1adMOYaq09Up4SnqlepTpi5hoSnhOaeq08LXqU6YcwxU5p6rUirzT1X616tOmLmGBeKeEp6rxTwlepTphzDAlSKlPCU9Vr1KVMOYYErB8Qa/5G61tW/e9HkX+H2Hv79vr0d4g1/yA1rat+96PIv8AD7D3/l9enLhK/nTxE8Rfq/PkmST9/apUX2e8Yv8Am/ml9nZe9dx9nB4W9qlT5IYEqRUpwWpFWv5ep0z3eYYqcU8LxT1WnheO9epTphzDAlSBKcEqQJzXqU6YuYYqU8JT1SnqterTphzDQtPVKeFqRVr1KdMXMMCcU8JxT1XinheK9SnTDmGBOaeE5p+ynhOa9WlTFzDVSnhKeq09Vr1KdMOYaFp6pTwtPVK9SnTDmGBOKeE4p6rxUgXivUp0xcwwJzTwnNPC808LzXq06YcwxUqQLTlWpFWvUp0xcwwLUipTgtSKlepTphzDAnFPCU8JTwvFerTpi5hgTmpAnNPC808LzXqU6YcwxVrA8Qa/5G61tW/e9HlH8PsPf+X16P1/X/I32tq373o8g/h9h7/y+vTllWv5z8RfEX6vz5Jkk/f2qVF9nvGL/m/ml9nZe9dx9nB4W9qlT5IaEp4WnheKeFr+XqdM93mGqlPCU9Up6pXq06Ycw0JT1TmnhKeF5r1KdMOYYqU9U4p6rT1XjvXqU6YuYYFqQJTwvFPC16tOmHMMVKkVKcqVIEr1KdMXMMCVIE5pwWpAvNepTphzDFSnqvFPVaeq8d69WnTFzDAtSBKcF4qQJXqU6YcwxUp6pT1SnqtepTphzDQlPVaeFp4WvUp0xcw1Up4TinqtPC8V6tOmLmGBOlLt+tSheKXZXpRp6BzHx1s9qeF5p+2nhea/oalTP8pOYYqU8JxT1WnqlepTpi5hoSsDxBr/ANn3Wtq373pJID932Hv/AC+vR/iDX/I3Wtq373o8g/h9h7/y+vTlglfzn4i+Iv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7WDwt7VKnyQ0JzT1SnqlPVa/l6nTPd5hoWnhOelPC08LzXqU6YcwxU56U9U9qeq809Vr1adMXMNVOKeEpyrxUgSvUp0w5hqpT1SnBakVa9SnTFzDAtSBOelOC1IE5r1adMOYYqc9Keqe1PVeaeq16lOmLmGBOKkCdKcq8VIFr1KdMOYYqU9Vp6rT1WvVp0w5hoWpAnNOC08JXqU6YuYaqU9U46U9Up6rXq06YcwwJx0p4TpTwvHanha9SnTFzDQvNPVaeF5p6rXqUqYcw0JTwnNPC08JXq06YuYYqVIqcdKcq1Iq16lOmHMMCcdKwPEGv+RutbVv3vR5Afu+w9/5fXo/xBr/AJAa1tWHm9HkH8PsPf8Al9enLBeK/nPxF8Rfq/PkmST9/apUX2e8Yv8Am/ml9nZe9dx9nB4W9qlT5IaE56U9U5p4Xmnhea/l6nTPd5hirUgWnKtSBa9SnTDmGBOakVKcEqRUr1adMOYYE4p+ynheKeFr1KdMXMMCc9KkC804LzUgXmvUp0w5hirTwlPVaeFr1KdMXMNCc09Up4SnqterTphzDQnFPC04LxUgWvUpUxcwwJz0p6pz0p4XmnqvNepTphzDFSpAlPVaeEr1KdMXMMCc1IqU4JUirXq06YcwwLxUgWnBeKkC16lOmHMMCc9Keqc9KeF5p6rzXq06YuYYqU8JxT1WnhK9SnTDmGhKeq08JT1WvUp0xcw0JWB4g1/yN1rat+96PKP4fYe/8vr0f4g1/wAjda2rfvekkg/g9h7/AMvr05YLX86eIniL9X58kySfv7VKi+z3jF/zfzS+zsveu4+1g8Le1Sp8kNC09Up4WnhK/l2nTPd5hqp7U8Jx0pypUgXivVp0xcwwJ0p4TmnhelPCc16lOmHMNVKeq05VqRV4r1KdMXMMC1IqU8LTwlerTphzDFSnhOOlPVKeF4r1KdMOYYE9qkCc04L0qQLzXqU6YuYYq1IEpyrT1XivVp0w5hoSpFSnBKkVK9SnTFzDFSnhOKeq08LxXqU6YcwzZ7VIE5p22pAvNerTpi5hirT1SnqtPC8V6lOmHMNCU8JzTwlPVK9WnTFzDVSnheKeq08LxXqU6YcwwJyOKeE56U8LyKeF5r1KdMOYaqVgeINf8jda2rfvekkgP3PYe/8AL69H6/r/AJG+1tW/e9HkH8PsPf8Al9enLKtfzn4i+Iv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7ODwt7VKnyQwJxUgSnBeKkCV/L1Ome7zDFSpFSnKlSKlerTphzDAlPCc9KeFp4XmvUp0xcw1U56U9U9qeq89qeq16lOmHMMVOKeEp4XinhK9WnTFzDQnNPVKeqU9Vr1KdMOYaFp4TmnhaeF5r1KdMOYaqe1PVOOlPVKeq8V6tOmLmGBOOlPCU8Lx2p4SvUp0w5hoTmnqlPC809Vr1KVMXMMC1IE5pwWpAlepTphzDFT2p6px0p6pT1XivUp0xcwwJx0qQJ0pwXjtUgWvVp0w5hgTmpFWnBeaeq16lOmLmGhKkCc04LTwlerTphzDVSsDxBr/kbrW1b970eQH7nsPf8Al9ej/EGv+RutbVv3vR5B/D7D3/l9enLKlfzn4i+Iv1fnyTJJ+/tUqL7PeMX/ADfzS+zsveu4+zg8Le1Sp8kNCcU/ZTwnFP2V/L1Ome9zDAnPSnqnNPC808LzXqU6YuYaqU8LT1Wnha9SnTDmGhOaeqU8JT1SvVp0xcwwJxUgSnBOKkC16lOmHMMCc9Keqc9KeF57U9V5r1KdMXMMVakC05VqQLXq06YcwwJzUipTglSKlepTpi5hgTinhKeF4p4WvUpUw5hoTnpT1TnpTwvPanqvNerTpi5hirTwlPVaeFr1KdMOYaE5p6pTwlPVa9SnTDmGhOKeFp4Wnha9WnTFzDVTnpT1T2p4TmnqtepTphzDFTjpTwlPVeKeF4FepTpi5hoTmsDxBr/kbrW1b970eQH7vsPf+X16O8Qa/wDZ91rat+96SSL/AA+w9/5fXpy4Tmv508RPEX6vz5Jkk/f2qVF9nvGL/m/ml9nZe9dx9rB4W/7yp8kMVKkCcU5UqRVr+XqdM93mGBakVKcFqRVr1KdMXMMVPanhOOlPVKeF4r1KdMOYYE6VIE5pwXpUgXmvVp0w5hipTwnFPVaeFr1KdMXMNC09Up4WnhK9SnTDmGqnFPCcU9Up4TivVp0xcwzZTwnNP208LzXqUqYcw1Up6rT1WnqvFepTpi5hoWnqlPC08JXq06YcwxUqQJxTlSnheK9SnTFzDQnPSnhOelPC8inhea9SnTDmGKtSBKcq1Iq8V6lOmLmGBKkVKcEqRUr1KdMOYYqU8JxT1WnheK9WnTDmGhORxWB4g1/yC1rat+96PID932Hv/L69H+Idf8jda2rfvejyD+H2Hv8Ay+vTlgvNfzn4i+Iv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7ODwt7VKnyQxU56U9U9qeq89qeq1/L1Ome7zDQvFPC08LxTwterTphzDVSnqlPCU9Ur1KdMXMNCU8JzTgtSBea9SnTDmGKntT1TjpT1WnqvFepTpi5hgTjpUgSnBeKkC16tOmHMMVKkVKcEqRVr1KdMOYYFqQLzTgtSBea9SnTFzDFT2p6px0p6rT1XivVp0w5hgTjpUgSnBeKeEr1KdMXMNCc09Up4SnqtepTphzDQtPCc08LT1WvVp0xcw1Up4TjpT1SnhOK9SnTDmGBOOlLsqULxRt+lelGnoLmPjsLTwvNOC1IE5r+hqVM/wApOYYq1ga/r/kbrW1b970klH8PsPf+X16P8Qa/5Ba1tW/e9HkH8PsPf+X16csqV/OfiJ4i/V+fJMkn7+1Sovs94xf8380vs7L3ruPtYPC3tUqLTohqrTwtPVaeFr+XqdM93mGqtPVaeFp6rXqU6Ycw0LTwtOCVIFr1adMXMMVeaeq09V5p6rXqU6YcwwLxUgWnKvFSBa9SnTFzDFWpFWnKtSKlerTphzDAtSBacEqQL0r1KdMXMMVeaeq09V5p6r9a9WnTDmGBeKeFp6rxTwtepTpi5hqrT1WnhaeqV6lOmHMNCU8LTwlPC16tOmHMNVaeq09Vp6rXqU6YrjAvFPC08Lx3p4SvUp0w5hoXmnqtPCc09Ur1aVMXMMCVIFpyrUgWvUp0w5hirWDr+v8AkbrW1b970klH8PsPf+X16O8Qa/5G61tW/e9HkH8PsPf+X16cuq1/OfiL4i/V+fJMkn7+1Sovs94xf8380vs7L3ruPs4PC3tUqLTohgXinheKeF4p4Xiv5ep0z3eYaF5p4XmnheaeE5r1KdMOYYq08JT1SnhK9WnTDmGhaeq08LT1WvUp0xcw0LxTwtPC8U8LxXqUqYcwwLzUgXmnBeaeE5r1adMXMNVaeEp6pT1WvUp0wuNC09Vp4WnqtepTpi5hgXipAtOCVIEr1KdMOYYF5p6rzTwvNPVea9WnTFzDFWpAtOVakC8V6lOmHMMC1Iq04LUipXqU6YcwwLxTwtPCU8LXq06YuYaF5p6rzTwvNPVee9epTphzDFWnheKeq08LxXqU6YuYaFrA8Qa/5G61tW/e9HkH8HsPf+X16P8AEGv+RutbVv3vR5F/h9h7/wAvr05YLX86eIniL9X58kySfv7VKi+z3jF/zfzS+zsveu4+1g8Le1SovRDVWnqtPVaeqV/LtOme7zDQtPVaeEp4XmvVp0xXGKtSBeKcq1IF4r1KdMOYYFp4XmnhelPC816lOmLmGKtSBacqVIqV6tOmHMMCVIq04JUirzXqU6YuYYq08LxT1WnheK9SnTC4wL0qQLzTgvSpAvNerTphzDFWnqtPVKeEr1KdMXMNCU8LTwtSKvNerTphzDFWnheKeq08LxXqU6YuYZtqQLzTttSBOa9SnTDmGKtPVaeqU9Vr1adMVxoWnqtOC1IFr1KdMOYaq08LxT1WnheK9SnTFzDAvSsDxBr/AJBa1tX/AHvR5B/D7D3/AJfXo/xBr/kbrW1b970eQfw+w9/5fXpy4XkV/OniL4i/V+fJMkn7+1Sovs94xf8AN/NL7Oy967j7WDwt7VKq9EMVeaeq09V5709Vr+XadM93mGKvFSBKcE4p4WvVp0wuNC09Vp6rzT1WvUp0xcw0LTwvNPCU8LyK9SnTDmGqvNPVaeq809Vr1adMXMMVeKeFp6rxTwtepTphzDVWnqtPC09Vr1KVMXMNC08LTwlPC16tOmFxqrT1WnKtSKvFepTphzDAvFPC08Lx3p4WvUp0xcw0LzT1WnheaeqV6tOmHMMCVIFpwSpAtepTpi5hirT1WnqtPVa9SnTDmGBeKkC04Lx3qQLXqU6YuYYF5qRVpwTmnqlerTphzDQlYHiDX/I3Wtq/73o8i/w+w9/ft9ej/EGv+QGtbVv3vSSRf4fYe/8AL69OWCV/OfiL4i/V+fJMln7+1Sovs94xf8380vs7L3ruPs4PC3tUqfJDQlPVaeFp6rX8vU6Z7vMNC8U8LTwvFPC16lOmHMMC808LzTwvNPC816lOmFxqrTwtOVKkCV6tOmLmGhKeq04LUirXqU6YcwwLxUgWnBeKkC16lOmLmGBeaeq808Lz3p6rzXq06YcwxVqQLTlSnhK9SnTFzDQtSKtOC1Iq16lOmHMMC8U8LTwvFPCV6tKmLmGheaeq808LzT1XmvUp0w5hirTwtPVKeF4r1adMOYaFp6rTwtPVa9SnTFzDVWnhacqVIEr1KdMOYYq81Iq04LzUirXq06YuYYq8VgeINf8AIDWtq/73o8g/h9h7/wAvr0fr+v8AkBrW1b970eQfw+w9/wCX16csF4r+c/EXxF+r8+SZJP39qlRfZ7xi/wCb+aX2dl713H2sHhb2qVPkhoXpTwvNOC1IF5r+XqVM93mGKtSKtOVakC16lOmLmGBakC04JUgXmvUp0wuMVaeF4p6rTwvFerTpi5hgXpUgXmnBelSBea9SnTDmGKtPVaeq09Ur1KdMOYaFp6rTwlPC816tOmLmGqtPC8U9Vp4XivUp0w5hm2nheaftp4XmvUpUxcw1Vp4WnKlSKlerTphzDAlSKtOCVIq816lOmLmGKtPC8U9Vp4XivUp0w5hoXkU8LzTwvSnhea9WnTDmGKtPVaeqU8JXqU6YuYaEp4WnhakVea9SnTDmGKtYHiDX/I3Wtq373o8g/h9h7/y+vR/iDX/I3Wtq373pJIP4fYe/8vr05ZVr+c/EXxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcfZweFvapUWnRDQtPC808LTwvNfy9Tpnu8wxV5p6rT1XnvT1WvUp0w5hoXinhKeqcU8JXq06YuYaq09Vp6rzT1WvUp0w5hgWpAvNOCVIEr1KdMXMMVaeq8U9Vp6rxXq06YcwwLxUgWnBeKkC16lOmHMMC81Iq04LzUirXqU6YuYYFqQLTglSBK9WnTDmGKtPVeKeq09V4r1KdMXMMC8U8LTwvHenha9SnTDmGheaeq08LzT1WvVp0xcw0LTwlPCU8LXqU6Ycw1Vp4XinqtPC8V6lOmHMMC8UbamC8UbfrXpRp6C5j462Vg+INf8AILWtq373o8gP3fYe/wDL69H+Idf8jda2rfvejyD+H2Hv/L69OWCV4viJ4i/V+fJMkn7+1Sovs94xf8380vs7L3ruP+X2Dwt7VKnyQwJz0p6pz0p4XntT1Wv5ep0z3eYaqU8LT1Wnha9SnTDmGhOaeqU9Vp6pXq06YuYYE4qQJTgtSBa9SnTDmGKnPSnqntT1Xmnqv0r1adMXMMVOOlSBKcq8VIF6V6lOmHMMCc1IqU4JUipXqU6YuYYE4qQJTgtPC16tOmHMNVOelPVPanqvNPVfpXqU6YuYYqcdKeEp6rxTwtepTphzDQnNPVKeEp6pXq06Ycw0JxTwtPVaeFr1KdMXMNVKeqe1PVaeqV6lOmHMMCcdKeE6U8LxTwvSvUp0xcw0JzT1SnhOaeq16tKmHMMCcVg+INf8jda2rfvejyg/d9h7/wAvr0d4g1/yN1rat+96SSD+H2Hv/L69OXC1/OfiJ4i/V+fJMkn7+1Sovs94xf8AN/NL7Oy967j7ODwt7VKnyQwLUirTgtSKtfy9Tpnu8wxU4p4TjpTwvFPCcV6lOmHMNCc9KeE5p4Xmnhea9WnTFzDFSnhOKeq09Vr1KdMOYaFp6pTwtPVa9SnTDmGhOKeEp6pTwlerTpi5hgTnpTwnPSnheaeF5r1KdMOYaqU8JxT1Wnha9SnTFzDAtSKlPC08JXq06YcwwJxUgSnKlSBK9SnTFzDAnPSnqnPSnheaeq89q9SnTDmGKntUgXinKtSBeK9SnTDmGBakVKcFqQJXq06YuYYqU8JT1Snha9SnTFzDQnPSnqnPSnheaeq89q9SnTDmGKntWB4g1/yA1rat+96PID9z2Hv/AC+vR+v6/wCRvtbVv3vR5B/D7D3/AJfXpy6rx2r+dPEXxF+r8+SZJP39qlRfZ7xi/wCb+aX2dl713H2sHhb2qVPkhgTjpTwtPC8U8LX8u06Z7vMNVKeE4p4SnqlerTpi5hoSnqlPC09Vr1KdMOYYq1IE46U5VqQLxXqU6YuYYE6cU8JzTwvFPC816tOmHMMVKkVKcEqRUr1KdMXMMCVIEpwWpFWvVp0w5hipTwnHSnqtPCcV6lOmLmGBOOlSBOacF4qQLzXqU6YcwxUp6pT1XmnqterTphzDQtPVaeFp6rXqU6YuYaqU8JxT1WnhOK9SnTDmGbKkCc07ZTwvNerTpi5hqpzT1SnqvNPVa9SnTDmGBakCc04LUirXqU6YuYYqVg+INf8AI3Wtq373o8gP3PYe/wDL69HeINf8jda2rfvejyD+H2Hv/L69OXVa/nPxE8Rfq/PkmST9/apUX2e8Yv8Am/ml9nZe9dx9rB4W9qlT5IYEqQJzTglSBK/l6nTPd5hipz0p6p7U9V5p6r9K9WnTDmGKnHSpAtOVeKeFr1KdMXMNVaeqU9Vp6rXqU6Ycw0JxTwlPCU8JXq06YuYaqc9Keqe1PVeaeq/SvUp0w5hipx0p4WnqvFPC9K9SnTFzDQnNPVKeq09Ur1adMOYaE4p4SnBakC16lOmHMMVakVPanKtSKtepTpi5hgTjpTwlPC8dqeF6V6tOmLmGBOakVKcE5qRUr1KdMOYYE4qQLTgtSBa9SnTDmGKtPVPanqtPVa9WnTFzDAnHSpAnSnBeKkC9K9SnTDmGBOawPEGv+QWtbVv3vR5Afu+w9/5fXo/xBr/kFrW1b970eQfw+w9/5fXpy4Xmv5z8RfEX6vz5Jkk/f2qVF9nvGL/m/ml9nZe9dx9nB4W9qlTbohipTwnFPVaeFr+XqdM93mGhKeq08LT1WvUp0w5hoXinhKcF4qQLXqU6YcwwJz0p4TmnheaeF5r1adMXMMVKkCcU5VqQLXqU6YcwwLUirTgtSKtepTpi5hgTipAlOC8VIEr1adMOYYE56U9U56U8LzT1XntXqU6YuYYqe1PCcU9Vp4XivUp0w5hoWnqlPC09Vr1adMOYaE4p4SnqlPCV6lKmLmGhOelPVOelPC809V57V6tOmHMMVPanhOKeq08LxXqU6YuYaFp6pTwtPCV6lOmHMMCcVIEpypUgWvVp0xcwwJzWD4g1/wAjda2rfvejyA/d9h7/AMvr0d4g1/yN1rat+96PIv8AD7D3/l9enLha/nPxF8Rfq/PkmST9/apUX2e8Yv8Am/ml9nZe9dx9rB4W9qlTbohipTwnHSnqtPC8V/L1Ome7zDAnTipAvNOC9KkC816lOmLmGKlPVKeq09Ur1KdMOYaEqRUpwSnha9WnTFzDVWnhOOlPVaeF4r1KdMOYYE6cVIE5pwXipAvNepTpi5hipTwnFPVeaeqV6tOmHMNCU9Up4WnqtepTphzDVWnhOKcq1IF4r1KdMXMM2e1PCc0/ZTwvNerSphzDFSpFSnKvNSKlepTpi5hgSpAlOC1Iq16lOmHMMVKeE4p6rTwnFerTpi5hoT2p4TnpTwnSnhee1epTphzDFTnpT1SnqtPVa9SnTDmGhawPEGv/AGfda2rfvejyD+H2Hv8Ay+vR/iDX/IDWtq373o8g/h9h7/y+vTlgtfzp4i+Iv1fnyTJJ+/tUqL7PeMX/ADfzS+zsveu4+zg8Le1SovRDVSnqtPVaeq1/L1Kme7zDQlPCc9KeFp4SvUp0w5hipz0p6p7U9V5p6r9K9SnTFzDFTjpUgTpTlXipAtepTphzDAlSKlOVakVa9SnTFzDAlSBOacEqQJXq06YcwxUp6px0p6rT1WvUp0w5hgTjpUgWnBeO1SBelepTpi5hgXmnqlPC809Vr1adMOYaE4p4SnhKeEr1KdMXMNVKeqe1PVaeq16lOmHMMCcdKeFp4XjtTwvSvVp0xcw0JzT1SnheaeqV6lOmHMMCcVIEpwWpAtepTpi5hqrTwvFOVakC8V6tOmHMMCcdKNntWH4g1/yA1rat+96PIP4fYe/8vr057+0r3/n7n/7+N/jX5Bn/AIq5RkeNlgKVOVZw0k4tWT6xu92uttE9N07elSwVSrHmbsfGATinhKeE4p4SvyClTP8AMnmGheaeqc08JzT1TmvUp0xcwxUp4SnqlPCcV6tOmHMNCU9Up4SnqlepTpi5hirUgSnKlSBK9SnTDmGKvNSKlOCc1IqV6tOmLmGKnFPCcU9U4p4TivUp0w5hgSpFSnBKkVK9SnTDmGKtSBKcqVIEr1adMXMMCc09Up4TmnqlepTphzDFTinhOKeqcU8JxXqU6YuYaEp6pTwlPCV6tOmHMNVaeEp4SnhK9SnTFzDVSnqlPCc09Ur1KdMOYYE4p4TinhOKeE4r1adMOYaErA8Qa/5Ba1tW/e9HkH8HsPf+X16P8Q699n3Wtq373o8gP3fYe/8AL69OWCc1/OfiJ4i/V+fJMkn7+1Sovs94xf8AN/NL7Oy967j7ODwt/wB7U+SGKlSKtOVKkVK/l6nTPd5hgWpAlOCVIqc16lOmHMMVKeE4p6pTwnFerTpi5hoTpTwnNPCU8JzXqU6YcwxUp6rT1SnhK9SnTDmGhKeqU8JTwnNerTpi5hqpTwnFPVKeE4r1KVMXMNCdKeE5pwTpUgTmvUp0w5hipT1WnqlPVK9WnTDmGhKeqU4JUgTmvUp0xcwxUqQJTlSpAlepTphzDAvNSKnNOCVIqc16tOmLmGKlPCcU9Up6pxXqU6YcwwJUgSnBKkCc16lOmLmGKlSBKcqU8JXqU6Ycw0LWB4g1/wAgta2rfvejyD+H2Hv/AC+vR/iDX/I3Wtq373o8g/h9h7/y+vTlgtfzn4i+Iv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7WDwt7VKnyQ1Vp6pT1SnqnFfy9TpnucwwJxTwlPCcU8JXq06Ycw0JzT1SnhOaeqV6lOmHMNC08LTglSBK9SnTFzDFSpAnFPVKeqcV6tOmHMMCcU8JTwnFP2V6lOmLmGBOakVKcE5qRUr1KdMOYYFqQLTglSBK9WnTFzDFSnhOKeqU9U4r1KdMOYaE4p4TmnhOKeE5r1KdMOYYE5p6pTwnNPVK9WnTFzDQtPCU9Up4SvUp0w5hqpTwlPVKeE4r1KdMXMMCcVIE5pwSpAnNerTphzDAnNPVKeE5p6pXqU6YuYYFrB8Qa/5G61tW/e9HkX+H2Hv/L69HeINe8gNa2rfvekkin7vsPf+X16cuEr+c/EXxF+r8+SZJP39qlRfZ7xi/wCb+aX2dl713H2sHhb2qVNuiGBakVKcEqRUr+XqdM93mGBKkCU5UqQJXq06YuYYqc09Vp6pzT1SvUp0w5hipxUgSnKnFSBOK9SnTDmGBKkVKcEp6pXqU6YuYaEp4SnqlPC16tOmHMNC809Vp4TmnqlepTpi5hipxTwnFPVOKeE4r1adMXMNCU9Up4SnqlepTphzDFWpAtOVKkCV6lOmHMNVaeqU9U5p6pXqU6YcwwJxTwnSnhOKeE4r1adMXMNCc09UpwTmpFSvUp0xcwxVqQLTglPCV6tOmHMNCU9Up6pzT1SvUp0w5hoTisDxBr/kBrW1b970eQfw+w9/5fXo/wAQa95Aa1tW/e9HkB+77D3/AJfXpywTiv5z8RPEX6vz5Jkk/f2qVF9nvGL/AJv5pfZ2XvXcfZweFvapU26IaE5FPCc08JyKeE5r+XqdM93mGKlPVaeqU9Ur1KdMOYaFp6rTwlPVOa9SnTFzDVSnhOKeqU8JxXq06YcwwJyKeE5p4SnhOa9SnTDmGqlPVaeqU9Ur1KdMXMMC1IEpwSpFTmvVp0w5hipUgSnKlSBK9SnTFzDAnIp6rzTwnNPVOa9SnTDmGKlSKnFOVKkCcV6tOmLmGBKeqU8JTwnNepTphzDVSnhKeqU8JXqUqYcw0LzT1XmnhKeqc16tOmLmGKlPVOKeqU9U4r1KdMXMNCU9Up4SnhOa9SnTDmGKlYPiDX/IDWtq373o8g/h9h7/AMvr0d4g1/yN1rat+96PIP4fYe/8vr05dUr+dPEXxF+r8+SZJP39qlRfZ7xi/wCb+aX2dl713H2sHhb2qVNuiGBKkC04JUgSv5ep0z3eYYq1IF4pypTwnFepTpi5hoTinhKeE4p4SvUpUw5hgTmpFSnBOaeqV6tOmLmGhakC04JUgWvUp0w5hirTwnFPVKeE4r1KdMXMMCcVIE5pwTipAnNepTphzDAnNPVKeE5p6pXq06Ycw0LTwtPCU8JXqU6YuYaqU8JxT1SnhOK9SnTDmGBKeE5p4SnhOa9WlTFzDQnNPVKeE5p6pXqU6YcwwLUgWnBKkCV6lOmLmGKlSBOKcqU8JxXq06Ycw0JTwnNPCU8JzXqU6YuYYqc1g6/r/kb7W1b970kkH8PsPf8Al9ejtf17yC1rat+96PID932Hv/L69OXVK/nTxF8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2sHhb2qVNuiGKnFPCU9U4p4Sv5ep0z3eYaFp6pTwlPVK9SnTDmGqlPCU5UqQJ0r1KdMXMNVOaeqU8JzT1SvUp0w5hipxTwlPVOKeE4r1adMXMNC09UpwSpFSvUp0w5hgSpAtOVKkCV6lOmHMMVOakVacqU9Ur1KdMXMNCcU8J0p4TinhOlerTpi5hgTmpFSnBOaeqV6lOmHMNVaeFp6pTwtepTpi5hoWnqtPVOaeqV6tOmHMMCcU8JTwnFPCdK9SnTDmGhOaeqU8JzT1SvUp0xcwxVqQLTlSpAlerTphzDVWsDxBr/kbrW1b970kkH8PsPf8Al9ejvEGv/Z91rat+96PIP4PYe/8AL69OXVK/nPxF8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2cHhb2qVNuiGBaXZUqpS7K/luNPQ93mPjoJTwlPVKeEr+h6VM/yk5hoTmnqnNOCc1Iqc16lOmHMMVKeE4p6pTwnFepTpi5hoSnhKcFqRVr1KdMOYYEqQJTlSpAlerTphzDAnNSKlOCc09Ur1KdMXMNVOKeE4p6pxTwvFepTpi5hgSpAlOCVIEr1adMOYYqU8JT1SnhK9SnTDmGhOaeqU8JT1SvUp0xcwxU4p4TinqnFPC8V6tOmHMNCU8JzTwlPCV6lOmLmGqlPCU5UqQJXqU6Ycw1Up6pTwtPVK9WnTDmGBOKwPEGveQGtbVv3vR5Afu+w9/5fXo/xBr/kbrW1b970klH8PsPf+X16cuE4r+c/EXxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcfZweFvapU26IZsp4Tmn7aeE5r+XqVM93mGKlSKlOVOakVK9SnTFzDAlSKlOCVIFr1KdMOYYqU8JxT1WnhOK9WnTDmGhOlPCc08J0p4TmvUp0w5hipzT1SnqlPVK9WnTFzDQlPVKeEp4WvUp0xcw1Up4TinqlPCcV6lOmHMMCdKkCc04JUgTmvVp0xcwxU5p6pT1TmnqlepTphzDAlSBKcEqQLXqU6YcwxUqQJxTlSpAlerTpi5hgSpFTmnBKkVOa9SnTDmGKlPVOKeqU9U4r1KdMXMMCdKkCU4LUgSvVp0w5hipWB4g1/yN1rat+96SSA/c9h7/wAvr0f4g1/yN1rat+96PIP4PYe/8vr05ZUr+c/ETxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcfaweFvapU26IaEp4SnhaeEr+XqdM93mGqlPVKeqU9Ur1KdMXMMCcU8J0p4Tinha9SnTFzDQnNPVKeF5p6pXqU6YcwwJxUgSnBKkCV6lOmHMMVKkCcU5UqRUr1adMXMMCcU8JTwnFP216lOmHMMCc1IqU4JzUipXq06YuYYE4qQJTlSpAlepTphzDFSnqlPC09Ur1KdMXMNCcU8JzTwnFPCc16tOmHMMCc09Up4TmnqlepTphzDQnFPCU9Up4SvUp0xcw1Up4SnqtPVK9WnTDmGBOKkCc04JUgTkV6lOmLmGBOawNf17yN9rat+96PID932Hv/L69H+INf8AILWtq373o8g/h9h7/wAvr05ZU5r+c/EXxF+r8+SZJP39qlRfZ7xi/wCb+aX2dl713H2sHhb2qVNuiGKlSBOKcqVIE4r+XqdM93mGBKkVKcEqQLXqU6YuYYqcVIEpwWpAterTphzDFTmnqlPCc09Ur1KdMXMMVOKeE4p6pxUgTivUp0w5hgSnqlPC08LXq06Ycw0JTwlPVKeEr1KdMXMNVOaeqU8JzT1SvVp0w5hipxTwnFPVOKeF4r1KdMXMNCU8JTwtPCV6lOmHMMCVIEpypUgSvVp0xcwwJzUipTlSpFSvUp0w5hgTinhOKeE4p4XivUp0w5hgSpAlOCc1IEr1adMXMMVKeEp6pTwlepTphzDVSsDxBr/kbrW1b970eQH7vsPf+X16P8Qa/wCRutbVv3vSSRf4fYe/v2+vTllSv5z8RfEX6vz5Jkk/f2qVF9nvGL/m/ml9nZe9dx9nB4W9qlT5IaqU8JxT1SnhOK/l6nTPd5hoSnhOacE6VIF5r1KdMOYYqU8JT1SnqnFerTpi5hoSnhOaeEp6pXqU6YcwxUqQJxTlWpAvFepTpi5hgTpTwnNPCdKeE5r1KdMOYaqU9UpypUipxXqU6YcwwJUipTglSBa9WnTFzDFSnhKeq08LXqU6Ycw0JT1TmnhKeqc16tOmLmGKlPVOKeqU9U4r1KdMOYaEp6pTwlPC16lOmLmGqlPCU9Up4WvVpUw5hoSnqnNPCU9U5r1KdMXMMVKeqcU9Up6pxXqU6YcwwJ0rB8Qa/wDZ91rat+96SSD+H2Hv/L69HeINf8gNa2rfvejyD+H2Hv8Ay+vTlwlfzp4i+Iv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7ODwt7VKnyQwJzUipTgvNSKtfy9TpnvcwwLUgSnBakC16lOmLmGKlPCcU9Up4TivUp0w5hoTin7KeE4p4SvUp0xcwwJzT1SnheaeqV6tOmHMNCU8JTwtPCV6lOmLmGqlPCcU9Up6pXqU6YcwwJxUgTmnBOKkC816tOmHMMCc09Up4TmnqlepTpi5hgTipAlOCVIEr1KdMOYYqVIE4p6pTwterTpi5hgSnhOaeEp4XmvUpUxcw0JzT1SnBOakVK9WnTDmGBOKkCU5UqQJXqU6YcwxUp4SnhaeqV6lOmLmGhKwPEGveRutbVv3vR5Afu+w9/5fXo/xBr/AJG61tW/e9HkH8PsPf8Al9enLBa/nTxF8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2sHhb/vKnyQ1U5p6pT1Tmnqlfy7Tpnu8wxU4p4TinqnFPCcV6tOmLmGhKeqU8JT1SvUpUw5hqpxTwlOC1IFr1KdMOYYqc1IqU5U5qRUr1adMXMMVOKeE4p6pxTwnFepTpi5hgSpFSnBKkC16lOmHMMVKkCU5UqQLXq06YcwxUqRUpwSnqlepTpi5hoTinhOKeE4p4TgV6lOmHMMCc09Up4Wnha9SnTFzDQlPCU9Up4SvVp0w5hqpT1SnqlPVK9SnTFzDAnFPCcU8JxTwvFepTphzDQnNPVKeF5p6pzXq06YcwwJWD4g1/yN1rat+96PIP4fYe/8vr0dr+v+RutbVv3vR5B/D7D3/l9enLha/nPxF8Rfq/PkmST9/apUX2e8Yv8Am/ml9nZe9dx9nB4W9qlReiGBKkVKcFqQJX8vU6Z7vMMVKXZUqpS7K9KNPQOY+OgtPCU9Up4Sv6GpUz/KTmGBOakVOacE5qRU5r1KdMXMMVKeqcU9Up6pxXqU6YcwwLUirTglSKnNerTpi5hipUgSnKlSBK9SnTDmGBKkVKcEp6pXqU6Ycw1V4p4TinqnFPCcV6tOmLmGBKeE5p4SpAnNepTphzDFSnhKeqU8JXqU6YuYaEp6rTwlPVK9WnTDmGKvFPCcU9U4p4TivUp0xcw0JTwnNPCU8JzXqU6YcwxUqQLTlSpAlerTphzDQtYHiDX/ALPutbVv3vR5R/D7D3/l9ejvEGv+RutbVv3vR5B/D7D3/l9enLhK/nPxF8Rfq/PkmST9/apUX2e8Yv8Am/ml9nZe9dx9nB4W9qlTbohipUgXinKlSBOK/l6nTPd5hm2nhOaeEp4TmvUpUw5hgTmnqlPCc09Ur1adMXMNCVIFpwSpAlepTphzDFWnheKeqU8JxXqU6YuYaEp4TmnhOlPCc16tOmHMMVOaeqU9U5p6pXqU6YuYaFp4WnhKeEr1KdMOYaq08JxT1SnhOK9WlTDmGBKkCc04J0qQJzXqU6YuYYqc09Up6pzT1SvUp0w5hgWpAtOCVIEr1adMXMMVKkVKcqU9Ur1KdMOYaEqRU5pwTpUgTmvUp0xcwxVp6pxT1SnqnFerTphzDAlYHiDX/s+61tW/e9HkH8PsPf37fXo/xBr3kBrW1b970eQH7vsPf+X16cuE6V/OfiJ4i/V+fJMkn7+1Sovs94xf8380vs7L3ruPs4PC3/eVPkhgTmnqtPCc09Ur+XqVM93mGqlPCU8JxTwlepTphzDVTmnqlPVKeqV6lOmHMMC8U8J0p4TinhOlerTpi5hoTmnqlPCc09Ur1KdMOYYqVIEpypUgSvUp0xcwxUqRVpwSpFSvUp0w5hgXinhKeE4p+yvVp0xcwwJzUipTgnNSKlepTphzDAlPC09Up4SvUp0w5hqpT1WnqlPVK9WnTFzDAnFSBORTgnFSBORXqU6YuYYE5p6pTwnNPVK9SnTDmGKtSBacqVIFr1adMOYaFp4WnqnNPVK9SnTFzDAnFYPiDX/I3Wtq373o8g/h9h7/AMvr0d4g1/yN1rat+96PIv8AB7D3/l9enLhK/nPxF8Rfq/PkmST9/apUX2e8Yv8Am/ml9nZe9dx9rB4W9qlT5IYE5p6pzTwnNPVOa/l6nTPd5hipUgTinKlSKnFerTpi5hgWpFSnBKkVK9SnTDmGBaeEp6pTwlepTphzDQnNPVKeE5p6pXqU6YuYYqcU8JxT1TinhOK9WnTDmGhKeFp4SnhOa9SnTFzDQtPCU9Up4SvVp0w5hoTmnqlPCc09Ur1KdMXMMVOKeE4p6pxTwnFepTphzDQlPC04JUgTmvVp0xcwxUqQJTlSpAlepTphzDAtSKlOCVIqV6lOmLmGBeKeF4p4TinhOK9WnTDmGBKkCc04JUgTmvUp0w5hipWB4g1/yN1rat+96SSD+H2Hv/L69H+INf8AI3Wtq373o8gP3fYe/wDL69OWVK/nPxF8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2cHhb2qVPkhoSnhKeEp4Tmv5ep0z3eYaqU8JxT1SnhOK9SnTDmGBakCc04J0qQJzXq06YuYYqU9Up6pzT1SvUp0w5hgSpAtOCVIEr1KdMOYYqVIF4pypUgTivVp0xcwwLTwnNPCdKeE5r1KdMXMMVOakVKcqc1IqV6lOmHMMCVIFpwSpAlepTpi5hirTwtPVKeqV6tOmHMNCU9U5p4SnqnNepTphzDFSnqnFPVKeqcV6lOmLmGhKeFp4SnhK9WnTDmGqtPVKeqU8JxXqUqYuYaEp6pzTgnSpAnNepTphzDFSsDX9f8gNa2rfvekkg/h9h7/y+vR+v695G+1tW/e9HkB+77D3/l9enLqlfzp4i+Iv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7WDwt7VKnyQwJxTwlPCcU8J0r+XqdM93mGBOakVacE5qRUr1KdMXMMC1IEpypUgSvUp0w5hipT1TinqlPVK9WnTFzDQnFP208JxT9lepSphzDAnNPVaeE5p6pXqU6YuYaqU8JTwnFPCV6lOmHMNVKeqcU9Up6pXq06YuYYF4qQLzTgnFSBOa9SnTDmGBOaeqU8JzT1SvVp0xcwxUqQJTlSpAlepTphzDFSpAtOCVIqV6lOmHMMC08JyKeE4p4TmvVpUxcw0JzT1SnBOakVK9SnTDmGBKeFp6pTwlepTpi5hqpWB4g1/wAjda2rfvekkg/h9h7/AMvr0f4g1/7PutbVv3vR5B/D7D3/AJfXpyypX86eIviL9X58kySfv7VKi+z3jF/zfzS+zsveu4+1g8Le1Sp8kNVaeFp4SnhK/l2nTPd5hoTmnqlPCc09Ur1adMXMMVOKeE4p6pxTwnFepTphzDQlPVKeEp4SvUp0xcwxVqQJTlSpAlerTphzDAnNSKlOCc1IqV6lOmHMMVOKeE4p6pxTwnFepTpi5hgSpFSnBKkCV6tOmHMMC08JT1SnhK9SnTFzDVSnqlPCc09Ur1KdMOYaE4p4XinhOKeE4r1adMXMMCU8LTwlPCc16lOmHMNC08JT1SnhK9SnTDmGhKeqU8JzT1SvUp0xcwwJxTwvFPCcU8JxXq06YuYaE5rA8Qa/5Ba1tW/e9HkH8HsPf+X16P8AEGveQWtbVv3vR5Afu+w9/wCX16csE5r+c/ETxF+r8+SZJP39qlRfZ7xi/wCb+aX2dl713H2sHhb2qVNuiGqlPCU9Up6pX8vU6Z7vMMCVIqU4JUgTmvUp0w5hipS7KlVKXZXpRp6C5j45VKkCU5UqQLX9DUqZ/lJzDAlSKnNOCVIqc16lOmHMMVKeE4p6pT1TivVp0xcwwJ0qQJzTglSKlepTphzDFSpAlOVaeFr1KdMOYaEp6pTwtPVK9WnTFzDVTinhOKeqU8JxXqU6YcwwJ0p4TmnhKeF5r1KdMXMNVKeFp6rTwterTphzDQlPVKeEp6pXqU6YuYYqU8JxT1SnhOK9SnTDmGhOlPCc08LTwvNerTpi5hipWD4g1/yN1rat+96PIP4fYe/8vr0dr+v+RutbVv3vSSQfwew9/wCX16cuq1/OfiL4i/V+fJMkn7+1Sovs94xf8380vs7L3ruPtYPC3tUqfJDAlSBKcFqQLX8vU6Z7vMMVKkCcU5Up4TivUp0xcw0JTwnNPCU8JzXq0qYcwwJzT1Snheaeq16lOmHMNC08JTwtPCV6lOmLmGqlPCcU9Up4TivVp0w5hoSnhOacEqQJzXqU6YuYYqc09Up6rzT1SvUp0w5hgSpAlOCVIEr1adMXMMVKkCcU5UqQLXqU6YcwwJUgTmnBKkCc16lOmHMMVOaeqU9U5p6pXq06YuYYE4qQJTgnFSBK9SnTDmGKlSKnFOC08LXqU6YuYaEp6pzTwtPVOa9WnTDmGqlYGv695G+1tW/e9HkB+77D3/l9ej/EGv8AkbrW1b970kkH8HsPf+X16csqV/OfiL4i/V+fJMkn7+1Sovs94xf8380vs7L3ruPs4PC3tUqfJDAnFPCU8JxTwnSv5ep0z3eYaE5p6pTwnNPVK9SlTDmGKnFSBKcq1IFr1adMXMNVKeqU9Vp6pXqU6YcwwJxTwnSnhOKeE6V6lOmHMNCc09Up4TmnqlerTpi5hipxUgWnBakC16dOmHMMVKkVKcq1IqV6tOmLmGBOKfsp4TinhK9SnTDmGBOaeqU8JzT1WvUp0xcw1Up4SnqlPC16tOmHMNVKeqU8JT1SvUp0w5hgTipAlOCcVIE6V6lOmLmGBOaeqU8LzT1WvVp0w5hgSpAlOVOKkCV6lOmLmGqlYHiDX/I3Wtq373o8g/h9h7/y+vR3iDX/ACN1rat+96SSL/D7D39+316cuq1/OfiL4i/V+fJMkn7+1Sovs94xf8380vs7L3ruPtYPC3tUqfJDFSpAlOVKkCV/L1Ome7zDAnNPVOaeEp6pzXq06YuYYqVIqcU5Vp6pxXqU6Ycw0JUipTglPCV6lOmLmGqlPCU9Up4SvVp0w5hoSnqlPC09Ur1KdMOYYqcU8JxT1TinhOK9SnTFzDQnSnhOaeEp4TmvVp0w5hipUgSnqlPC16lOmLmGBKkVKcFqRUr1KdMOYYqcU8JxT1SnhOK9WnTFzDAnSpAnNOCVIE5r1KdMOYYqVIEpyrTwtepTphzDQlSKlOC1IqV6tOmLmGBOKeE4p4TinhOK9SnTFzDNlYHiDXvs5a1tW/e9JJAfu+w9/wCX16P8Q6/5G61tW/e9HkH8PsPf+X16cuE5r+c/EXxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcfaweFv+8qbdEMVOaeqU8JzT1Sv5ep0z3eYaEp4SnBakC16lOmHMNVKeE4p6pTwnFerTpi5hgSpAnNOCVIE5r1KdMOYYqc09Up6pzT1WvUp0xcwwJUgSnBakC16tOmHMMVKkCcU5UqQJxXqU6YuYYEp4TmnhKeE5r1adMOYYqc1IqU5V5qRVr1KdMOYYFp4SnhKeEr1KdMXMNVKeqcU9Up4SvUp0xcw0JTwnNPC09U5r1KdMOYYqU9U4p6pT1TivVp0w5hoTinhKeE4FPCV6lOmLmGKlSKnFPVKeq16lKmHMMCVg+INe8gta2rfvekkgP3fYe/8vr0d4g1/yN1rat+96PIP4fYe/wDL69OXCV/OniL4i/V+fJMkn7+1Sovs94xf8380vs7L3ruPs4PC3tUqfJDAlSKlOVakVK/l2nTPd5hgTinhOlPCcU8J0r1adMOYYE5qRUpwTmpFSvUp0w5hipxUgSnBKeFr1adMXMNCU9Up6rT1SvUp0w5hoTin7KcE4qTZXqU6YuYYE5p6pTwnNPVK9WnTDmGqnFPCU5VqQLXqU6YuYaqU9Up6rT1SvUp0w5hgTipAnIpwTipAlerTphzDAnNPVKeE5p6rXqU6YuYYqcVIFpwWpAtepTpi5hipUipTlWpFSvVp0w5hgTinhORTwnFPCdK9SlTDmGBOakVKcE5qRVr1KdMXMMVKwPEGv+RutbVv3vR5B/D7D3/l9ej9f1/yN1rat+96PIP4fYe/8vr05ZV4r+dPEXxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcfaweFvapUXohoSnqlPCU9Vr+XadM93mGqlPCU9Up4SvVp0xcw0JzT1SnhKeqV6lOmHMMVOKeE4p6pxTwvFepTphzDQlPCc04JUgSvVpUxcwxUqQJTlSpAlepTpi5hgTmpFSnBakVK9SnTDmGKnFPCcU9U4p4TivVp0w5hgSpAnNOCVIE5r1KdMXMMVKeEp6pTwterTphzDQlPVKeFp6pXqU6YuYaE4p4TinhOKeE4r1KdMOYYEp4TmnhKeE5r1aVMXMMVKkCU9Up4WvTp0w5hoSnqlOC1IqV6tOmHMMCcVgeINe8gNa2rfvejyA/d9h7/y+vR/iDX/ACN1rat+96SSj+H2Hv8Ay+vTlwnFfzn4i+Iv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7ODwt/3lTbohgTpTwnNPCU8JzX8vU6Z7vMMVOakVKcqc1IqV6lOmHMMCVIEpwSnha9SnTFzDVSl2VKqUuyvSjT0DmPjpVp6rTlWpAlf0NTpn+UnMMC1Iq804J0qQJzXq06YuYYq/WnqvFPVPanqnHSvUp0w5hgTipAtOCcdKkC16lOmLmGKtSKtOVaeqV6tOmHMNC1Iq804JUipXqU6YuYYq08LxT1SnhOOlepTphzDAtSBeacE6cU8LzXq06Ycw1Vp4WnqlPVK9SlTFzDQlPC808JT1SvUp0w5hirUgXinKtSBOOlerTpi5hgXpWB4g1/yC1rat+96PIP4fYe/wDL69H+INe8gNa2rfvejyA/d9h7/wAvr05cJyOK/nPxE8Rfq/PkmST9/apUX2e8Yv8Am/ml9nZe9dx9rB4W/wC8qfJDAvNPVaeE56U9Vr+XqdM93mGKtSBacqVIEr1KdMOYYqVIq05UqRUr1aVMXMMC8U8LzTwvFPCcjivUpUxcwwLzUirTgnPSnqlepSphzDQtPCU9Up4SvVp0xcw0LzT1WnqlPVa9SnTDmGhaeF5p4WnhOelepTphzDFXnvT1WnqnPSnqntXq06Ycw1U4p4SnhOKeE6V6lOmLmGheaeq04JUirXqUqYuYYFqQLzTglSBOelerTphzDFXnvT1WnqnPSnqntXqU6YuYYqcVIEpypx0qQJ0r1KdMOYYq81Iq04JT1SvUp0w5hoSsDxBr/kbrW1b970eQfw+w9/5fXo/xBr/kbrW1b970eQH7vsPf+X16csFr+dPETxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcfZweFvapUXohqrT1WnhOaeqV/L1Ome7zDQvFPC8U4JxUgTjpXqU6YcwwJTwvNPCU8JzXq0qYuYaq08LTlWpAlepTphzDQtPVaeE5p6pXqU6YuYYF4p4XinhOKeE46V6tOmHMNC808LzTwnPSnhea9SnTFzDFWpAlOVKkCV6lOmHMMCVIqU4JzUipXqU6YcwwLxT9tPC8U8LXqU6YuYYF5qQLzTgnPSpAvNerTphzDFWnhKeqU8JxXqU6YuYaEp6rTwlPVK9SnTDmGheKeFp4XinhOlerTpi5hgXnvT1XmnhOelPVOelepSphzDVWsDxBr/kBrW1b970kkX+H2Hv/L69H6/r/kb7W1b970eQH7vsPf8Al9enLKnHSv5z8RfEX6vz5Jkk/f2qVF9nvGL/AJv5pfZ2XvXcfaweFvapUWnRDAlSBKcEqQJzX8vU6Z7nMMVKkVacqVIE4r1KdMOYYFqRV5pwWpFTnpXq06YcwxV+tPVeKeqe1PVOOlepTpi5hgSpAlOCcU8JXq0qYcw1Vp6rT1SnhK9SnTFzDQtPVeaeEp6pXqU6Ycw1Vp4XjvT1SnhOOlerTpi5hgTpTwvNPCdOKeE5r1KdMOYaq09Vp6rTwlepTphzDAtSKvNOCVIE5r1adMXMMVaeF4p6pTwnHSvUp0xcwwLUgXmnBOnFSBea9SnTDmGKtSKtOVaeqV6lOmHMNC1IqU4JUipXq06YuYYq1geINf8AIDWtq373o8i/wew9/wCX16P8Qa/5G61tW/e9HkB+77D3/l9enLKlfzn4i+Iv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7WDwt7VKi06IaF4p4XmnhOKeE56V/L1Ome7zDAvNPVaeE56U9Vr1KdMXMNVaeFp4SnhK9WnTDmGqlPCU8JzT1SvUp0w5hgWpAvNOCVIE56V6tOmLmGKvPenqtPVOelPVPavUp0w5hgXipAtOVOKkCV6lOmLmGKlSKtOVKkVK9SnTDmGBakC804LUgTnpXq06YuYYq896eq09U56U9U9q9SnTDmGBeKeEp6pxTwlerTphzDQvNPVaeqU9Vr06dMXMNC08LzTwtPCc16tOmHMNVaeq8d6eqU9U46V6lOmLmGBOKeEp4TjpTwnSvUpUw5hoXmsDxBr/kbrW1b970eQfw+w9/5fXo7xBr/ANn3Wtq373pJID932Hv/AC+vTlwnNfzp4ieIv1fnyTJJ+/tUqL7PeMX/ADfzS+zsveu4+zg8Le1SotOiGKtSBacqVIFr+XaVM93mGBakVacE5qRUr1adMOYYF4p4XinhOKeE46V6lOmLmGhOaeF5pwTnpUipzXqU6YcwxVp4WnqtPC16tOmHMNVaeqU8JzT1SvUp0xcw0LxTwtPCcU/ZXq0qYcwwJzTwvNPCc9KeF5r1KdMXMNVaeFp6rTwlepTphzDQtPVKeE5p6pXq06YuYYF4qQL0pwTipAtepTphzDAvPenqvNPCc9Keqc9K9SnTDmGKtSBKcqVIEr1adMXMMCVIqU4JzUipXqU6YuYYF4p4XpTwvFPC16lKmHMNC896wNf1/wAgta2rfvejyD+H2Hv/AC+vR/iDX/ILWtq373o8gP3fYe/8vr05ZU56V/OfiL4i/V+fJMkn7+1Sovs94xf8380vs7L3ruPtYPC3tUqbdEMVfrT1XinqntT1TjpX8vU6Z7vMNC08LTwlPCc16tOmLmGqlPVaeqU8JxXqU6Ycw0LT1WnhaeqV6lOmLmGKtPC8d6eqe1PCcdK9WnTDmGhKeE5p4TpTwnNepTphzDFSpFWnKlSKterTpi5hgWpFWnBakVK9SnTFzDFWnheO9PVPanhOOlepTphzDAnSpAnNOCe1SBOa9SnTDmGKtPVaeqU8JXqU6YuYaFp6pTwlPVK9WnTDmGqvFPC8U9Up4TivUp0w5hmynheafs9qeE5r1KVMXMNVaeq09Vp4SvVp0xcwwLWD4g1/7OWtbVv3vR5B/B7D3/l9ejvEGv8AkbrW1b970eUfw+w9/wCX16cuFr+c/EXxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcfaweFvapU26Iaq08JTlSpAnFfy9Tpnu8wwLUgXmnBKkCc9K9SnTDmGKvNPVaeqc9Keqe1epTpi5hgXipAtOCcU8JXq06Ycw1Up2361IqU7Z7V6UaeguY+OFWpFXinKtSKtf0NTpn+UnMMCVIqc04LUgXmvUp0w5hirT1XjtT1WnqvFepTpi5hgXipAtOC8VIFr1adMOYYq08LxTwtPVa9SnTDmGhKeFp4WnqtepTpi5hqrTwvFPVaeF4r1adMXMMC8U8LzTwvAp4WvUp0w5hqrT1SnhaeFr1adMOYaEp4WnBakVa9OnTFzDFWsHxBr/kBrW1b970kkH8PsPf+X16O8Qa/5G61tW/e9JJR/B7D3/l9enLqtfzp4ieIv1fnyTJJ+/tUqL7PeMX/ADfzS+zsveu4+1g8Le1SovRDAvFSBeRTgvFSBa/l6nTPd5hgXmnqtPC809Vr1KdMXMMC8VIEpyrUgWvVp0w5hgWnqtPVaeq16lOmHMNC8U8LyKeF4p4XpXqUqYuYYF5qRVpwXmnqterTphzDVXinhKeFp4WvUp0xcw0LT1WnqtPVa9SnTFzDQtPCc04LUgWvVp0w5hirzT1X6U9V5p6rXqU6YcwxV4qQLTlXipAtepTphzDFWpFWnKtSKtepTpi5hgWpAlOC1IFr1aVMXMMVeaeq/SnqvNPVa9SnTDmGKvFSBacq8VIFr1KdMXMMVawPEGv+RutbVv3vR5B/B7D3/l9ej/EGv+RutbVv3vR5F/h9h7+/b69OWC81/OniJ4i/V+fJMkn7+1Sovs94xf8AN/NL7Oy967j7WDwt7VKnyQ1Vp4WnqtPCV/L1Ome7zDQlPVKeEp6rXqU6YuYYF4qQLxTgvFSBeK9WlTDmGBaeF5p4Wnhea9SlTDmGKtSBacq1IEr1KVMXMMCVIqU4LUirXq06YcwwLxTwvFPC8U8LxXqU6YuYaF5p4XmnheaeF5r1KdMOYYq08JT1Wnha9SnTFzDQlSKtOC1Iq16tOmHMMC8U8LTwvFPC16lKmHMMC81IF5pwXmpAvNepTpi5hirTwlPVaeq16lOmHMNCU9Vp4WnqterTpi5hgXipAtPC8U8LXqU6YcwwJzWBr+v+QWtbVv3vR5B/D7D3/l9ej/EGv+QWtbV/3vR5B/D7D3/l9enLqvNfzn4i+Iv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7WDwt7VKnyQxVp6rxT1WnqvFfy9Tpnu8wwLwKkCU4LxUgWvVp0xcwxVqQLTlWpAtepTpi5hgWpAnNOCU9V5r1KdMOYaq09V4p6rT1XivVp0w5hgXgU8LTwvFPC16lOmLmGqtPVeKeq08LXqUqYcw0JT1SnhKeFr1adMXMNVKeF4pyrUgXivUp0w5hgXpTwvNPC9KeF5r1KdMXMMVakVeKeq09Vr1adMOYYEqRUpwWpFWvUp0w5hirTwvFPVaeF4r1KdMXMMC9KkC804L0qQLzXqU6YcwxVp4XinqtPVa9WlTFzDQlYHiDX/ACN1rat+96PIv8PsPf8Al9ej/EGv/Z91rav+96PIP4fYe/8AL69OWCV/OfiL4i/V+fJMkn7+1Sovs94xf8380vs7L3ruPtYPC3tUqfJDVSnqlPC09Vr+XqdM93mGheKeF5FPC8U8LXqU6YuYYF5p6rTwvNPVa9WnTDmGqvFPCU5VqQLXqU6YuYaqU9VpyrUirXq0qYcwwLUgXmnBakC816lOmHMMVeaeq09V5p6rXqU6YuYYF4qQJTlXipAtepTphzDAtSKtOVakVa9SnTFzDAtSBeacFp4WvVp0w5hqrzT1WnqvNPVa9SnTFzDFXinhKeF4p4WvVp0w5hoWnqtPVaeq16lOmHMNC08JTwlPC16lOmLmGqlPVacq1Iq16tOmLmGBeO1YHiDX/s+61tW/e9HkH8PsPf8Al9ej/EGv+QGtbV/3vR5B/D7D3/l9enLBeK/nPxF8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2sHhb2qVF6IaF5p4XmnhaeF5r+XqdM93mGKtSBacq1IFr1KdMOYYq1IqU4JUirXqU6YuYYE4p4XinheKeF4r1adMOYYF5qQLzTgvNSBea9SnTFzDFWnhaeq08JXqU6Ycw0JT1SnhKeq16tOmHMNC8U8LTwvFPC16lOmLmGBeaeF5p4Xmnhea9SlTDmGKtSBacq1IEr1adMXMMCVIqU4LUirXqU6YcwwLxUgWnBeKkC16lOmLmGBee1PVeaeF5p6rzXq06YcwxVp4SnqtPC16lOmHMNCVIq04LUirXqUqYuYYF4rA8Qa/5G61tW/e9HkH8PsPf+X16P8AEGv+RutbVv3vSSUfw+w9/wCX16csq1/OfiJ4i/V+fJMkn7+1Sovs94xf8380vs7L3ruPs4PC3/eVF6IaFp6rzTwtPC81/L1Kme9zDFX6U9V4p6rT1XivVp0xcw0LTwlPC08LXqU6Ycw1Up4WnqtPVa9SnTFzDQtPVacFqRVr1adMOYYqU8LxT1WnheK9SnTFzDAvSpAnNOC1IF5r1aVMOYYq1Iq8U5VqQLXqU6YcwwLUgSnBKkVa9SnTFzDFSnheKeq08LxXqU6YuYYF6VIF5pwXpUgXmvUp0w5hirT1XinqtPC16tOmHMNCU9Up4Snha9SnTFzDVSnheKeq08LxXqU6YcwzbTwvNP208LzXq0qYuYYq1g+INf8AI3Wtq373pJIP4fYe/wDL69HeINf8gta2rfvejyD+D2Hv/L69OXVa/nPxF8Rfq/PkmST9/apUX2e8Yv8Am/ml9nZe9dx9rB4W9qlReiGBakC04LUgSv5ep0z3eYYEqRUpyrUirXq06YuYYEqQLzTgtSBea9SnTDmGKvPanqtPVeaeq16lOmHMMC8U8JTwvFPCV6lOmLmGqlO2/SpAtO216UaeguY+OFSpAlOCc1IqV/Q1Omf5S8wwLUgXmnBakCc16tOmLmGKtPVeO9PVPanqnHSvUp0w5hgXinhKeE46U8JXqU6YuYaqU9Vp4TmnqlerTphzDQtPC08LTwnNenTpi5hqrTwvFPVKeE4r1adMOYYF4p4SnhOOlPCV6lOmHMNC809Vp4TmnqtepSpi5hgWsHxBr/kbrW1b970eQfw+w9/5fXo7xBr/AJG61tW/e9HkB+77D3/l9enLha/nTxF8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2cHhb2qVPkhgWpFWnBOakVK/l6nTPe5hgXipAvSnBOKeE6V6lOmLmGheaeqU8Jz0p6pz0r1adMOYYq08LT1Snha9SnTFzDQtPVKeE5p6pXqUqYcw0JxTwvSnhOKeE6V6tKmLmGBeaeq808Jz0p6pz0r1KVMOYaq08LT1Wnha9SnTDmGhaeqU8JzT1SvUp0xcwwJUgXpTgnFSBK9WnTDmGKvNPVfrT1TnpT1T2r1KdMXMMVeKkC05U46VIEr1KdMOYYFqRUpwTmpFSvVpUxcwxVqQL0pwTipAtepTphzDFXmnqv1p6pz0p6p7V6lOmHMMVeKwPEGv+QGtbVv3vR5F/h9h7/y+vR+v6/5Aa1tW/e9HkB+77D3/AJfXpy4TjpX86eIviL9X58kySfv7VKi+z3jF/wA380vs7L3ruPs4PC3tUqfJDAtPC808JTwnNfy9Tpnu8w1Up4SnqlPCcV6lOmHMNC09Vp4WnqterTpi5hgXipAvFOVOKkCcdK9OnTDmGBaeE5p+ynhOa9WlTFzDFSpFWnKlSBOK9SnTDmGBakVacFqRUr1adMXMMVeKeF4p6pxTwnFepTphzDQvNPCc08Jz0p4TnpXqU6YcwxUp6rT1SnqterTpi5hoWpFWnBaeqV6lOmHMNCU8LxTwnFPCcV6lOmLmGBeakCc04Jz0p4TnpXq06Ycw1Vp6rT1SnhK9SnTFzDQtPVKcEqRUr1KdMOYYErB8Qa/5G61tW/e9HkX+D2Hv79vr0d4g1/yN1rat+96PID932Hv/AC+vTlwnFfzn4i+Iv1fnyTJJ+/tUqL7PeMX/ADfzS+zsveu4+zg8Le1SovRDAlSBeacEqRU5r+XqVM93mGKtPVeKeqe1PVOOlerTphzDAvFSBacE46VIEr1KdMOYYq09Up6pTwnFepTpi5hoSnheaeEp4TmvVp0w5hqrT1XjvT1T2p6px0r1KdMXMMC8U8LTwnHSnhK9SlTDmGqlPVKeqU9Ur1KdMXMNCU9V5p4WnqterTphzDFWpAvFOVKkCcdK9SnTDmGBelPCU8Jx0p4TmvUp0xcwxUqQJTgnNSKlerTpi5hgWpAtOC1IE5r1KdMOYYq08LxT1SnhOOlepTphzDAvFSBOacE46VIE56V6tOmLmGKlYGv6/wCRutbVv3vR5B/D7D3/AJfXo/xBr/kFrW1b970kkB+77D3/AJfXpy6pX85+IviL9X58kySfv7VKi+z3jF/zfzS+zsveu4+1g8Le1SotOiGKlPCU9Up4Wv5ep0z3eYaq809Vp6rT1SvVp0xcw0LxTwvSnBOKkCe1epTphzDAvNPVKeE56U9U56V6lOmHMMCVIFpypUgWvVp0xcwwLUirTgnNSKlenTphzDAlSBeRTgnFSBK9WnTFzDFXmnqtPVOelPVPavUp0w5hirxUgWnKnHSpAterTpi5hgWnqlPCc09Ur1KdMOYaEp4WnhOKeEr1KdMOYaq809V+tPVOelPVPavVp0xcwxV4p4WnqnHSnhK9SnTFzDQtPVKeE5p6pXqU6YcwwJUgWnBOKkC16tOmHMMVawdf1/yN1rat+96PIP4fYe/8vr0d4g1/yC1rat+96PID932Hv/L69OXVa/nPxF8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2cHhb2qVF6IYF4p4XinheKeE46V/L1Ome7zDQtPC808LTwnNepTphzDFSpAlOVKeE4r1KdMXMNC1Iq04JUirXq06YcwwLxTwvFPVOKeE46V6lOmLmGBeakC804Jz0qQJzXqU6YcwxUp4SnqlPCcV6tOmHMNC09Vp4WnqtepTpi5hoXinheKcE4qQJXqUqYcwwLzTwnNPCc9KeE5r1KdMXMMVKkVacqVIE4r1adMOYYFqRVpwWpFSvUp0xcwwJUgSnBOKeEr1KdMOYaF5p6rzTwnPSnqnPSvVp0xcwxVp4XinqntTwvFepTphzDQtYHiDX/I3Wtq373o8g/h9h7/y+vR/iDX/I3Wtq373o8oP3fYe/8vr05YLX85+IviL9X58kySfv7VKi+z3jF/zfzS+zsveu4+zg8Le1Spt0Q1Vp4WnqtPVK/l+lTPe5hoSnqvNPCU9U5r1KdMXMMVaeq8U9U9qeqcdK9SnTFzDQvFPC08Jx0p4WvVp0w5hqrT1SnKlSBOK9SnTDmGBKkC804JUipXqU6YcwxVp4XinqtPCcdK9WnTFzDAvSpAvNOCdOKkCc16dOmLmGKtPVKeqU8JxXq06Ycw0JUirzTglPCV6lOmLmGqtPC8U9Vp4TjpXq06YcwwL0qQLzTgnHSpAnNepTphzDFSnhKeqU9Ur1KdMXMMC1Iq808LT1WvVp0w5hqrTwvFOVKkCcV6lOmLmGbawPEGv+QWtbVj5vR5B/D7D3/l9ej/EOv+RutbVv3vR5Afu+w9/5fXpy4TkcV/OfiJ4i/V+fJMkn7+1Sovs94xf8380vs7L3ruPtYPC3tUqfJDAvNPVaeE56U9Ur+XqdM93mGKlSBKcE4qQJXq06YuYYq81Iq04JUirXqU6YcwwLTwvIp4SnhOa9SnTFzDVXnvT1WnqnPSnqntXqU6YcwxU4p4SnqnHSnha9WnTDmGqvNO2/WpFWnbPavSjT0FzHxwEp6rTwnNSKlf0NTpn+UnMMC1IF5pwWpAlepTphzDFSnqvFPVKeqV6lOmLmGBeKeEp4TipAlerSphzDAvNPVaeE5p6rXqU6YuYaFp4SnhaeEr1KdMOYaqU8JxT1SnqnFerTphzDAvFPC08JxT9tenTpi5hoXmsDX9f8jda2rfvekkg/g9h7/wAvr0f4g1/yC1rat+96PIP4fYe/8vr05YJzX86eIviL9X58kySfv7VKi+z3jF/zfzS+zsveu4+1g8Le1SovRDFWpAtOVKkC1/L1Ome5zDFWpFSnBKkVK9SnTDmGBOKeEp4SpAlerTphzDAvPanqvNPC809U5r1KdMOYYq08LT1SnhK9SnTFzDQlPVKeEp6pXqU6YuYaE4p4WnhKeEr1aVMOYYF57U9V5qQLzT1TmvUp0xcwxVp4WnqlPCcV6lOmHMNCU9Up4SnqlerTphzDFWpAtOVakC16lOmHMMVeaeq08JzUipXqU6YuYjVeKkC09U4p4TivVp0xcwwJUirTglSKlepTphzDAtSBacq1IEr1KVMXMMVeawNf1/yN9rat+96PIP4fYe/8vr0f4g1/yN1rat+96PIP4PYe/wDL69OXVa/nTxF8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2sHhb2qVF6IYq08LxT1SnhOK/l6nTPd5hgXpTwvNPCdKkCc16lOmLmGKlPVaeqU9Vr1KdMOYaFp6rTwtPCV6tOmHMMVKkCcU9Up4TivUpUxcwzbTwvNP2U8JzXqUqYcwxUqQLTlSpFWvVpUxcwwLUirTglSKlepTphzDFSnhOKeqU8JxXqU6YuYaF5FPC808L0p4TmvVp0w5hirT1XinqlPCV6lOmHMNC08JTwlPVK9SnTFzDVSnheKeqU8JxXq0qYcwwLyKeF5p4XpUgTmvUp0xcwxVp6rxT1SnhK9SnTDmGBKwfEGv+RutbVv3vR5F/h9h7+/b69HeINe8gNa2rfvekki/w+w9/wCX16cuEr+dPEXxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcfZweFvapUWnRDFWpFSnKlSKlfy7Tpnu8wwLUgXmnBakC16tOmHMMVaeq8dqeq09Ur1KdMXMMC8VIFpwTipAlepTphzDAlPVKeE5p6pXq06Ycw0LTwvNPC08LXqU6YuYaq09V47U9Up6pXqU6YcwwLxTwtPCcU8JXqU6YuYaEp6pTwnNPVK9WlTDmGBakVaeFp4SvUp0xcwxVqQJxT1SnhOK9SnTDmGBeKeF5p4Tin7K9WnTDmGBKkVacE5qRUr1KdMXMMC1Iq04LUgSvUp0w5hipTwnFPVKeqcV6tOmLmGBeKwfEGv+QWtbVv3vR5B/D7D3/l9ej/ABBr/kBrW1b970kkX+H2Hv8Ay+vTlglfzn4ieIv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7WDwt7VKm3RDAvPanqtSBOaeqc1/L1Kme7zDFXinhaeqU8LXq06YuYaq09Vp4SnqlepTphzDAnFSBOlPCcU8JXqU6YuYYF57U9Vp4XmnqnNepTphzDFWpAtPVKeFr1adMOYYq1IqU4JUipXqUqYuYYEqQJTlWpAlepTphzDFXmnqv0p4XmnqlerTpi5hirxTwvSnqnFSBOK9SnTDmGBKeqU8JT1SvUp0xcw0LTwtPVaeEr1adMOYaq809V+lPVeaeqV6lOmHMMVeKeF6U9U4p4TivUp0xcw0JT1SnhKeqV6tOmLmGKtYPiDX/I3Wtq373o8g/h9h7/y+vR3iDX/ACN1rat+96PIP4fYe/8AL69OXVa/nPxF8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2sHhb2qVNuiGBKkVacFqQLX8vU6Z7vMMC8U8LxT1SnhOK9SnTDmGhaeF5p+ynhOa9SnTFzDFSnhaeqU9Vr1adMOYaFp6rTwtSKtepTpi5hgXinhOKeqU8JxXqU6YcwwLzTwvNSBOlPCc16tOmHMMVaeq09Up6rXqU6YuYaFp6rTwtPCV6lOmHMMVKkCU9Up4TivUp0xcwwLzTwvNPCdKeE5r1aVMOYYq1IFp6pT1WvUp0xcwwLUirTglSKlepTphzDFSnhKeqVIEr1adMOYYF5p6rz2p4XmnqvNepTpi5hirWB4g1/yA1rat+96PIP4fYe/8vr0fr+v+RvtbVv3vR5B/D7D3/l9enLqvFfzn4i+Iv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7ODwt7VKi06IYF4p4WnhOKkCV/L9Kme9zDFWnheKeE5p6pXqUqYuYaEp4XmnhaeEr1KVMOYYq09V47VIq09V4r1adMXMRheKkC08JxTwlepTpi5hirUipTwnNPVK9SnTDmGBakVacFqQLXqU6YcwxVp4XinqtPCcV6tOmHMMC8VIF5p4TinhK9SlTFzDAlPVKeE5p6pXqU6YuYaFp6rTwtSBa9WnTDmGKtPC8U9Up4TivUp0xcwwLxTwvNPCcVIE5r1KdMOYYq809Up4TmnqlerTphzDAtSKtPC08JXqU6YuYYq1g+INf8jda2rfvekkg/h9h7/y+vR3iDX/ALPutbVv3vR5R/B7D3/l9enLqtfzn4ieIv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7WDwt7VKi06IYF4qQLTgnFSBK/l+nTPd5hgXmnqtPCc09U5r06dMXMMVeKkC05UqQLXq06YcwxVp6rTwtSKlepTphzDAtPCU9Up4SvUp0xcw1V5p6r9Keqc09Vr1adMXMMVeKeFp6pxTwlepTphzDVWnbfpUgSl2V6Uaegcx8chOakVKcE5qRUr+hqdM/wAo+YYqVIEpwTipAlepTphzDFSnqlPCU9Ur1adMOYYE4qQJ0pwTinhK9SnTFzDQnNPVKeE5p6pXqU6Ycw1Up4SnqnFPCV6tOmLmGqlPVKeEp6pXqU6YcwwJxWB4h17yN1rat+96PID932Hv/L69H+INf8jda2rfvekkgP3fYe/8vr05cJX85+IviL9X58kySfv7VKi+z3jF/wA380vs7L3ruPs4PC3/AHlT5IYE5p4TmnhOaeE5r+XqdM97mGKlSKlOVKkCcV6lOmLmGBKkVKcEqQJXqU6YuYYE4p4SnhKeEr1adMOYaE5p6pzTwnNPVOa9SnTDmGKlPCcU9Up4TivUp0xcw0JT1SnhKeEr1adMOYaEp4SnqlPCV6lOmLmGhOaeqc08JzT1TmvUp0w5hipTwnFPVKeE4r1adMXMMCVIEpwSpFSvUp0w5hgSpAlOVKkCV6lOmHMMCc1IqU4JzUipXq06YuYYqcU8JxT1TinhOK9SnTDmGBKkCU4JUgTmvUp0xcwxUrA8Qa/5G61tW/e9JJB/D7D3/l9ej/EGv+RutbVv3vR5Afuew9/5fXpyypX86eIviL9X58kySfv7VKi+z3jF/wA380vs7L3ruPtYPC3tUqfJDQlPVOaeEp4Tmv5dp0z3eYaqU8JxT1SnhOK9WnTDmGBOKkCc04JxUgTmvUp0xcwxUp4SnqlPVK9WnTDmGBKkVOacEqRUr1KdMXMMVKkCcU5UqQJxXqU6YcwzZTwnNP2U8JzXq0qYuYYqVIqU5U5qRUr1KdMOYYEqQJzTglSKlepTpi5hipTwnFPVKeE4r1adMOYaE6U8JzTwnSnhOa9SnTFzDFSnqlPVOaeqV6lOmHMNCU8JzTwlPCV6tOmHMNVKeE4p6pTwnFepTpi5hgTpUgTmnBKkCc16lOmHMMVOawNf17yN9rat+96SSA/d9h7/AMvr0fr+veQWtbVv3vR5Afu+w9/5fXpyypX86eIviL9X58kySfv7VKi+z3jF/wA380vs7L3ruPs4PC3tUqfJDFTipAlOVOKkCdK/l2nTPd5hgTmpFSnKlSKlerTphzDAlSBKcEqQJXqU6YuYYqU9U4p6pT1SvUp0w5hgTipAlOCcVIE6V6tOmLmGBOaeqU8JzT1SvUp0w5hoSnhKeE4p4SvUp0w5hqpT1SnqlPVK9SnTFzDAnFPCdKeE4p4TpXq06Ycw0JzT1SnhOaeqV6lOmLmGBKkCU4JxUgSvUp0w5hipUipxTlSpFSvVp0xcwwJxT9lPCcU/ZXqU6YcwwJzUipTgnNSKlepTpi5hipUgSnBOKkCV6tOmHMMVKwPEGv8AkbrW1b970eQfw+w9/wCX16P8Qa/5G61tW/e9JJF/h9h7/wAvr05ZUr+c/EXxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcfZweFvapU26IaE4p4TpTwnFPCV/L1Ome7zDQnNPVOaeE5p6pzXqU6YcwxUp4SnqlPCcV6lOmHMNCU9Up4SnqlerTpi5hgTipAlOCVIEr1KdMOYYE5p6pzTwnNPVOa9WnTFzDVSnhOKcqVIE4r1KdMOYYEqRUpwSpAlepTpi5hipUgWnBKkCV6tOmHMMCc09Up6pzT1SvUp0w5hipxUgTinKnFPCcV6lOmLmGhKeqU8JTwlerTphzDVSnhKeqU8JXqU6YuYaE5p6pTwnNPVK9SnTDmGKnFPCcU9U4p4TivVp0xcw0JWB4g1/7PutbVv3vR5Afu+w9/5fXo/wAQa/8AZ91rat+96PIP4fYe/wDL69OWCc1/OfiJ4i/V+fJMkn7+1Sovs94xf8380vs7L3ruPtYPC3/eVNuiGKlSKlOVKkCV/L1Ome7zDAtSKnNOCVIqV6lOmLmGKlPCcU9Up4TivUp0w5huynhOafsp4TmvVp0w5hipT1SnqlPVK9SnTFzDQlSKnNOCU8JzXqU6Ycw1Up4TinqlPCcV6tOmLmGhKeE5pwTpUgTmvUp0w5hipTwlPVKeqV6lOmLmGBKkVOacEqRUr1adMOYYqVIE4pypUgTivUp0xcwwJ0p4TmnhOlPCc16lOmHMNVKeqU5U5qRUr1KdMXMMCVIE5pwSpFSvVp0w5hipTwlPVKeE4r1KdMOYaErA8Qa99nLWtq373o8gP3fYe/8AL69H+INf8jda2rfvejyA/d9h7/y+vTlglfzn4i+Iv1fnyTJJ+/tUqL7PeMX/ADfzS+zsveu4+zg8Le1Spt0Q1Up6pxT1SnqnFfy9Tpnu8wwJxTwlPCcU8J0r1KdMOYaE5p6pTwnNPVK9WlTFzDQlPC04JUgSvUp0w5hipUipxT1SnqlepTphzDAnFPCU8JxTwnSvVp0xcwwJzUipTgnNSKlepTphzDAlSBKcE4qQJXq06YuYYqU8JxT1SnhOK9SnTDmGhOKfsp4TinhK9SnTFzDAnNPVKeE5p6pXq06Ycw0JTwlPCcU8JXqU6Ycw1Up6pxT1SnhOK9SnTFzDAnFSBOacE4qQJzXq06YuYYE5p6pTwnNPVK9SnTDmGBKwfEGv+RutbVv3vR5B/D7D3/l9ejvEGv8AkbrW1b970eQH7vsPf+X16cuEr+c/EXxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcfaweFvapU+SGBKkVKcEqRUr+XqdM93mGBOKkCdKcE4qQJXqUqYuYYE5p6pzTwnNPVOa9WnTDmGKlPCU9Up4TivUp0xcw0JUipTglPVK9SnTDmGqlPCU9U4p4SvVp0w5hqpzT1SnqnNPVK9SnTFzDFTinhOKeqcU8JxXqU6YuYaEp2361IEpdlelGnoHMfHITmnqlPCc1IqV/Q1Omf5ScwxUp4SnqtPC16tOmLmGqtPVKeFp6pXqU6YcwwJxTwnSnhOKeEr1KdMOYaE5p6pTwnNPVK9WnTFzDQlPC05VqQLXqU6Ycw1VrA8Qa/5G61tW/e9JJB/B7D3/l9ejvEGv+RutbVv3vR5B/B7D3/l9enLha/nPxF8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2cHhb2qVNuiGKlSBKcFp4Tiv5ep0z3eYaE5p4TmnhORTwnNerTphzDFSpFSnKlPVa9SnTDmGhKkVacFqQLXqU6YuYYqU8JT1SnhK9SnTDmGhOaeqc08JzT1TmvUp0xcwxUp4TinqlPVOK9WnTDmGhaeq08LTwlepTpi5hqpTwlPVKeEr1KVMOYaE5p6pzTgnIqRU5r1adMOYYqU9V4p6pT1TivUp0xcwwJUirTgtSBK9SnTFzDFSpAlOVKkC16tOmHMMCVIqU4JUirXqU6YcwxU4p4XinqlPCcV6tOmLmGBKwPEGv/Z91rat+96PIv8AD7D3/l9ej/EGv+RutbVv3vR5B/D7D3/l9enLhK/nPxE8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2sHhb/vKm3RDAlPVKeFp6pX8vU6Z7vMNCU9Up4Snha9SnTFzDVSnhOKeqU8LxXqU6YcwwLxTwnNPCcVIE5r1adMOYYqc09Up4TmnqlepTpi5hgSpAtOC1IFr1KdMXMMVakCcU5VqQJxXq06YcwzZTwnNPCU8JzXqUqYcwxU5qRUpwTmpFSvUp0xcwwJUgWnBakC16tOmHMMVKeE4p6rTwnFepTpi5hoSnhOaeEp4TmvUp0w5hipzT1SnqnNPVK9WnTFzDQtPC08LTwtepTphzDVSnhOKeqU8JxXqU6YcwwJWD4g1/wAgta2rfvejyD+H2Hv/AC+vR3iDX/I3Wtq373pJIv8AB7D39+316cuEr+dPETxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcfZweFvapU+SGKnNPVKeqc09Ur+XadM93mGKnFSBacqcVIEr1adMOYYFqRUpwWpFWvUp0xcwwJUgSnKlPCV6tOmHMNVKeqU9U5p6pXqU6YcwwJxUgXpTgvFSBOlepTpi5hgTmnqlPC809Ur1aVMXMNCU8JT1SnhK9SnTDmGhKeqU9U5p6rXqU6YuYYE4p4XpTwvFPCdK9SnTDmGhOaeqU8JzT1SvUp0w5hipUgSnBKkC16tOmLmGKtSKlOC1Iq16lOmHMMCcU/ZTwnFP2V6lOmLmGBOakVKcE5qRUr1adMOYYqVgeINf+z7rW1b970eQfw+w9/5fXo/xBr/AJG61tW/e9JJB/D7D3/l9enLKlfzn4i+Iv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7WDwt7VKnyQ0JTwtPCU9Ur+XqdM9zmGhaeEp4Wnha9SnTDmGhOaeqc08JzT1TmvVp0w5hipTwnFPVKeE4r1KdMXMMCVIq04LUgWvUp0w5hipUgSnBakCV6tOmLmGBOaeqc08JzT1TmvUp0w5hipUgTinKlSKnFepTpi5hgSpFWnBakC16tOmHMMVKkCU5Up4SvUp0w5hoTmnqlPCc09Ur1KdMXMMVOKeF4p6rxTwnFerTphzDQtPCU8JTwnNepTpi5hqpTwlPVKeEr1KdMOYaE5p6pTwlPVK9WnTFzDFTisDxBr/AJAa1tW/e9HkH8PsPf8Al9ej9f1/yN1rat+96PIP4fYe/wDL69OXCcV/OfiL4i/V+fJMkn7+1Sovs94xf8380vs7L3ruPtYPC3tUqfJDAnAp4XmnheKeE5r+XqdM93mGKnNSKlOVKkVK9SnTDmGBKkVKcEqQJXqU6YuYYq08JxT1SnheK9WnTFzDdtPC80/bTwnNepTphzDFTmnqlPVKeqV6tOmHMNCU9Up4Snha9SnTFzDVWnhOKeqU8LxXqU6YcwwJ0qQJzTglSBOa9WnTFzDFSnqlPVOaeqV6lOmHMMCVIFpwWpAtepTpi5hirUgTinKtSBOK9WnTDmGBKeE5p4SnhOa9SnTDmGKlSKlOVOakVK9SnTFzDAlSBacFqQLXqU6YuYYqVgeINf8AI3Wtq373o8o/h9h7/wAvr0f4g1/7PutbVv3vSSUfw+w9/wCX16csqV/OfiL4i/V+fJMkn7+1Sovs94xf8380vs7L3ruPtYPC3tUqfJDQtPC08LTwlfy9Tpnu8w1Up6pT1SnqlerTphzDAnFPCU8JxTwnSvUp0xcw0LzT1WnhOaeq16lKmHMMC1IEpwWpAlerTpi5hipUipTlTmpFSvUp0w5hgTinhaeE4p4TpXqU6YcwwLzUipTgnNSKterTpi5hgSpAlOVKeEr1KdMOYaqU9Up6pT1TivUp0xcw0JxT9tPC8U8JXq06YcwwJzT1SnhOaeqV6lOmLmGhKeEp4Snha9SnTDmGhaeqU9Up6rXq06YuYYE4qQJzTgvFSBORXqU6YcwwJzWBr+v+RvtbVv3vR5B/D7D39+316P8AEGv+QWtbVv3vR5B/D7D3/l9enLKnNfzn4i+Iv1fnyTJJ+/tUqL7PeMX/ADfzS+zsveu4+zg8Le1Sp8kMVKkCcU9Up4Tiv5ep0z3uYYEqRUpwSpFSvUp0xcwwLUgSnBKkC16tKmHMMCc09U5p4XmnqnNepTpi5hipTwnFPVKeE4r1KdMOYaEp4WnhKeqV6tOmLmGhaeFp6rTwlepTphzDQnNPVKeE5p6pXq06YcwxU4p4TinqnFPCcV6lOmLmGhaXZ7VKEpdv0r0o09Bcx8chOaeqU8JzTwlf0NTpn+UvMNVKeFp4SnhK9SnTFzDVTmnqlPCc09Ur1adMOYYE4p4TpTwnFPCcV6lOmLmGhOaeqU8JzT1SvUp0w5hipWD4g1/yN1rat+96SSD+H2Hv/L69Ha/r3kbrW1b970eQH7vsPf8Al9enLqlfzn4i+Iv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7ODwt7VKnyQwJUipzTglSKlfy9TpnvcwxUqQJxTlSnhOK9WnTFzDQnIp4TmnhKeE5r1KdMXMMVKeqU9Up4SvUp0w5hoWpFTmnBKeE5r1adMOYaqU8JT1SnhK9SnTFzDQnNPVOaeEp6pzXqU6YcwxUp6pxT1SnqnFepTpi5hoSnqnNPCdKeE5r1KdMOYYqVIEpypUgSvVp0xcwwJzUipzTglSKnNepTphzDFSnhOKeqU9U4r1adMOYYEqRU5pwSpFSvUp0xcwxUqQJTlSnhK9SnTDmGhaeqU8JUipXq06YuYYqcVgeINe8gNa2rfvekkgP3fYe/8vr0fr+veRutbVv3vR5Afuew9/wCX16csE4r+c/EXxF+r8+SZJP39qlRfZ7xi/wCb+aX2dl713H2sHhb2qVNuiGBOKkCU4JxUgSv5ep0z3eYYE5p6pTwnNPVK9SnTFzDQlPCU8LTwlepTphzDVSnhOKeqU8JxXq06YuYYE4p4TmnhOKeE5r1KdMOYaE5p6pTwnNPVK9SnTDmGBKkC04JUgSvVp0xcwxUqQJxTlSnhOK9SnTDmGhKeE5p4SnhOa9SlTFzDAnNPVKeE5p6pXq06Ycw0JTwlPCcU8JXqU6YuYaqU8JxT1SnhOK9SnTDmGhOlPCc08JTwnNerTphzDFTmnqlPVOaeqV6lOmLmGBKkCU4JxUgSvVp0w5hqpWB4g1/yN1rat+96PIv8PsPf+X16O8Qa/wDZ91rat+96PIv8PsPf+X16cuqV/OXiJ4i/V+fJMkn7+1Sovs94xf8AN/NL7Oy967j7ODwt7VKm3RDAnFSBOlOVOKkCV/L9Ome7zDFTmnqlPVOaeqV6lOmHMMVOKkCU5U4qQJxXqU6YuYYEqRUpwSnqlerTphzDQnFPCU9U4p4SvUp0xcw0JT1SnqlPVK9SnTDmGBOKeEp4TinhOlerTpi5hoTmnqlPCc09Ur1KVMOYYqVIEp6pxTwlepTphzDVSnqlPVKeqV6tOmLmGBOKeEp4TinhOK9SnTDmGhOaeqU8JzT1SvUp0xcwxUqQJTlSpAlepTphzDFTmpFSnKlPVK9SnTFzDQnFP2U8JxT9lerTphzDAnNYHiDXvILWtq373o8gP3fYe/8AL69H+INe+zlrW1b970eQH7vsPf8Al9enLhOa/nPxF8Rfq/PkmST9/apUX2e8Yv8Am/ml9nZe9dx9nB4W9qlTbohipT1SnqlPVOK/l6nTPd5hoSnqlPCU9Ur1KdMOYaqU8JT1SnhK9WnTDmGhOaeqc08JzT1TmvUp0xcwxUp6pxT1SnqnFepTphzDAlSKnNOCVIqV6tOmLmGKlSBKcqVIEr1KdMOYYE5p6pzTwnNPVOa9SnTFzDFSpFTinKlSBOK9WnTDmGBKkVOacE6U8JzXqU6YuYaqU8JT1SnhK9SnTDmGhOaeqU8JT1SvVp0w5hipxTwnFPVOKeE4r1KdMXMNCU8JzTwnSnhOa9SnTDmGKlSBKcqVIFr1adMXMNCVgeINf+zlrW1b970eQH7vsPf+X16O8Qa/5G61tW/e9HkH8PsPf+X16cuEr+c/EXxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcfaweFvapU+SGKlSBOKcqVIE4r+XqdM93mGBOKeE5p4TinhOa9SnTFzDAnNSKlOVOaeqV6tOmHMNCVIE5pwSpAlepTphzDFSnhOKeqU8JxXqU6YuYaEp4TmnBKkCc16tOmHMMCc09Up4TmnqlepTpi5hoSnhKeFp4SvUp0w5hqpTwnFPVKeE4r1adMXMMCdKkCc04JUgTmvUp0w5hipzT1SnqnNPVK9SnTFzDAlSBacEqQJXq06YcwxUqQJxTlSnhOK9SnTFzDQnSnhOaeEp4TmvUp0w5hipzUipTlTmpFSvUp0w5hgSsDxBr/kbrW1b970eQH7vsPf+X16P8Qa95Aa1tW/e9HkB+77D3/l9enLBK/nTxF8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2cHhb2qVNuiGhKeqU8JT1Sv5dp0z3eYaqU8JTwnFPCV6tOmHMNVKeqU8JT1SvUp0xcwwJxTwnSnhOKeEr1KdMOYaE5p6pTwnNPVK9WlTDmGBOKkCU5U4qQJXqU6YuYYqVIqU5UqRUr1KdMXMMCcU8J0p4TinhOlerTphzDAnNSKlOCc09Ur1KdMOYaE4p4SnqnFPC16lOmLmGhKeqU9Up6pXq06YcwwJxUmynhOKfsr1KdMXMMCc09Up4TmnqlepTphzDFSpAlPVOKeEr1adMXMNVKeqU9Up6pXqU6YcwwJxWD4g17yN1rat+96PID932Hv/AC+vR3iDX/I3Wtq373o8gP3fYe/8vr05cJX85+IviL9X58kySfv7VKi+z3jF/wA380vs7L3ruPtYPC3/AHlT5IYE5p6pzTwnNPVOa/l6nTPd5hipUgTinKlSBOK9SnTFzDAlSBKcEqRUr1adMOYYEp4SnqlPCV6lKmLmGhOaeqc08JzT1TmvVp0w5hipT1TinqlPCcV6lOmLmGhKeqU8JT1SvUp0w5hqpTwlPVKeEr1adMXMNCc09Up4SnqlepTphzDFTinhOKeqcU8JxXqU6Ycw0JS7akCU7b9a9KNPQXMfHIWnhKeFqQLzX9DU6Z/lJzDFSnhKeqU8JXqU6Ycw1Up6pTwtPVa9WnTFzDAnFPC8U8LxUgXivUp0w5hgTmsDxBr/AJBa1tW/e9HkH8PsPf8Al9ej/EOv+QWtbVv3vR5B/D7D3/l9enLhee9fzn4ieIv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7ODwt7VKnyRGq1IqcU9V5p6rX8vU6Z7vMMC1IEpwSpAterTphzDFSnheKeq1IF4r1KdMOYYE6U8LzTwtPC8969SnTFzDFSnqnFPVeakVK9WnTFzDAlPVKeEp4WvUp0w5hqrTwtPVaeq16lOmHMNCU9U5p4WnqvNepTpi5hipT1TinqtPVeK9WnTDmGhKeqU8JxTwtepTpi5hirUgWnqtPC16lKmHMMCVIqc04JUirzXq06YuYYqU9U4p6rT1XivUp0w5hgSpAtOC8VIFr1KdMXMMVKeFp6rT1SvUp0w5hoSsDxBr/kFrW1b970eQfw+w9/5fXo/xBr/AJG61tW/e9HkX+H2Hv79vr05YLX86eIviL9X58kySfv7VKi+z3jF/wA380vs7L3ruPtYPC3tUqfJDVSnhOKeqU9Vr+XqdM93mGBOKkCU4LxUm2vUp0xcwwJzT1Wnheaeq16lOmHMMC1IFp4WnhK9WnTFzDVSnhOKeqU9Vr1KdMOYYE4p4TmnheKkC8ivUp0xcwwLzT1Wnheaeq16tOmHMMC1IEpypUgSvUp0w5hipUgTinBeakVa9SnTFzDAlPC808LxTwvIr1adMOYYF5p6pTwvNSKtepTpi5hgSnhKeqU8JXqU6Ycw1Up4WnqvNPVa9WnTFzDQlPCc08LTwvIr1KdMOYYqc09Up6rz3p6rXqU6YcwwJxWD4g1/7PutbVv3vSSQfw+w9/5fXo/xBr/kBrW1b970eQfw+w9/5fXpywTiv5z8RfEX6vz5Jkk/f2qVF9nvGL/m/ml9nZe9dx9nB4W9qlTbohgSpFSnhKeF5r+X6dM93mGBKkC05VqQLXqU6YuYYqc09Up4XmpFWvUp0w5iNU4qQJxT1XjvTwnFerTphzDAlSKlOC1IF5r1KdMXMMVaeFp6rTwlepTphzDVWnqlPCU9Vr1adMXMMCcU8J0p4XipAvFepTphzDAnNPC08LTwvNepSpi5hgWpAtPVaeEr1KdMOYYEqRUp4SnqterTphzDAnFPCcCnheKeF4r1KdMXMNC809Vp4Xmnhea9SnTDmGKlSBacq1IEr1adMXMMCVIqU4LUirXqU6YcwwJxWB4h1/yN1rat+96PIP4fYe/8vr0f4g1/yA1rat+96PIv8PsPf+X16csF4r+c/EXxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcfZweFv+8qfJDQlPCc08L0p4XnvX8vU6Z7vMMVaeFp6rzT1WvUp0w5hoWnhKeEp4SvVp0xcw1Up4SnqtPVa9SnTDmGBKkVOaeFp6rzXqU6YcwxVp6pxT1X609V4r1adMXMMCVIEpwSpAtepTphzDFSnhaeq1Iq16lOmLmGBKeqc08LUirzXq06YcxGqU9U4qRV+tPVeK9SnTFzDAlPVKeEp4WvUp0w5hqrTwtPVaeq16tOmHMNC09Up4WnqvNepTpi5hipTwnFPVakC8V6lOmLmGBKeE5p4Wnhea9WnTDmGKtYPiDX/I3Wtq373o8o/h9h7/y+vR3iDX/I3Wtq373pJIP4fYe/8vr05dVr+c/EXxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcfaweFvapU+SGBakC05VqQLX8vU6Z7vMMVKeE4p6pUirxXqU6YuYYE4p4TmnheKeF5r1adMOYYE5p6rTwvNSKtepTpi5hgWnhaeq08LXqU6Ycw1Up4TinqlPVa9WnTDmGBKkCc08LxTwvNepTpi5hgTmnqtPC809Vr1KdMOYYFqQLTwtPCV6tOmLmGqlPCcU9Up6rXqU6YcwwJUgTmnBakC816lOmLmGKvNPVaeq896eq16lOmHMMCVIEpypxUgSvVp0w5hipUgTinBeakVa9SnTFzDAlPCc08LTwvNepTpi5hirzWDr+v8Akb7W1b970eQfw+w9/wCX16P8Qa/5Ba1tW/e9HkH8PsPf+X16csq1/OniL4i/V+fJMkn7+1Sovs94xf8AN/NL7Oy967j7WDwt7VKm3RDFXinhOBT1XjvTwvFfy9Tpnu8w0JT1SnhKeqV6lKmHMNCU8LT1Wnha9SnTFzDVWnqlPVaeq16lOmHMMCcU8J0p4XinheK9WnTFzDQnNPVKeEp4XmvUp0w5hgSpAtOVakC16lOmHMMVakVKcFqRVr1adMXMMCcU8J0p4XinheK9SnTFzDAnNSKlOC81IF5r1KdMOYYFp4WnqtPCV6tOmHMNVaeqU8JT1SvUp0xcwwJxUmynheKftr1KdMOYYE5p6rTwvNPC816tOmLmGBakC09Vp4SvUp0w5hgSsHxBr/kbrW1b970eQfwew9/5fXo7xBr/AJG61tW/e9HkH8PsPf8Al9enLha/nPxF8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2cHhb2qVNuiGKlSBKcqVIEr+XqdM97mGBOaeqc08L0qRV5r1adMXMRqlSKvFPVfrT1XivUp0w5hgSpFWnBKkCV6lOmLmGKlPCU9Up6rXq0qYcw0JzT1Tmnhaeq816lOmLmGKtPC8U9V+tPVeK9SnTDmGhKeEp4SnhK9WnTFzDVSnhKeq09Vr1KdMOYYFqRUp4WnqvNepTpi5hipxTwnFPVaeF4716tOmHMMCU7Z7VKE6UuyvRjT0DmPjnZTwnNPC08LzX9DU6Z/lJzDVSnhOKeqU8LXq06YuYaEp6rTwtPVa9SnTFzDFTisHxBr/kBrW1b970kkB+77D3/l9ejvEGv+RutbVv3vSSQfwew9/wCX16cuF4r+c/ETxF+r8+SZJP39qlRfZ7xi/wCb+aX2dl713H2sHhb2qVPkhgWpAnPSnBakC81/L1Ome7zDFTnpT1SnqvNPVa9SnTDmGBOKkCU4JUgSvVp0xcwxVqQLxTlWnheK9SnTDmGhOlPCc9KeFp4TmvUp0xcwxU56VIqU5V57U9Vr1adMOYaE4p4SnheKeFr1KdMXMNVaeqU9Vp4XivUp0w5hoTpTwnNPCU9U5r1adMOYYqe1PVOOlPVaeq8dq9SnTFzDQnHSnhaeF4p4WvUp0w5hipUipTlWpFSvVp0xcwwJUipzTglSBea9SnTDmGKntT1TjpT1WnqvHavUp0xcwwJx0qQLTgvFSBa9SnTDmGKlYHiDX/I3Wtq373o8gP3PYe/8vr0f4g1/yC1rat+96PIv8PsPf+X16csq1/OniL4i/V+fJMkn7+1Sovs94xf8380vs7L3ruPtYPC3tUqfJDVSnhKeF4p4Sv5ep0z3eYaE5p6pT1SnqtepTpi5hgXipNntTgvFSba9SlTDmGBeaeq08LzT1WvVp0xcwxUqQJTlSpAlepTphzDVSnqlOC1Iq16lOmLmGBeKkCcjinBeKkC16lOmHMMCc9KeqU8LzT1WvVp0w5hgTipAlOVeKkC16lOmLmGKlSKtOVaeq16lOmHMNCcU8JyOKeF4p4TpXq0qYuYYE56VIqU4LzT1WvUp0w5hoTinhKeq8U8LXqU6YuYaEp6rT1WnqterTphzDQlPCc08LTwlepTpi5hipz0rA1/X/I32tq373o8gP3fYe/8AL69H+INf8gta2rfvejyL/D7D3/l9enLqlfzp4i+Iv1fnyTJJ+/tUqL7PeMX/ADfzS+zsveu4+1g8Le1Sp8kMVOOlPCcdKeq8U8Lx2r+XqdM93mGBOlSBOacFqQLzXqU6YuYYq1IFpyrUgWvUp0w5hgTmpFSnBKkVK9SnTFzDFTjpTwnHSnqtPC8dq9WnTDmGBOlSBeacFp4XmvUp0w5hqrTwlPVaeFr1KdMXMNCc09Up4SnqterTphzDQnFPCcdKcF4qQLxXqU6YuYYFp4Xmn7aeF5r1KVMOYYqVIEpyrUgSvVp0xcw0JzT1SnBKkVa9SnTDmGBeKeE46U8LxTwvFepTphzDQnPSnhOaeF5p4XmvVp0xcwxUqQJxTlWnhK9SnTDmGhKwPEGv+RutbVv3vSSQH7vsPf8Al9ej/EGv/Z91rat+96PIP4fYe/8AL69OWCV/OfiJ4i/V+fJMkn7+1Sovs94xf8380vs7L3ruPs4PC3tUqfJDVSnhOKeq08LxX8vU6Z7vMNC08Jz0p4Wnhea9SnTDmGKnPSnqlPVeaeq16tOmLmGhKeE5pwSpAlepTphzDVSnqtPVaeq8V6lKmLmGBakVOelPC08JzXqU6YcwxU9qeqcdKeq09V47V6tOmHMMCcVIEpwXgVIFr1KdMXMMVakCU5VqRV4r1KdMOYYE6VIqc9KcEp6pzXq06YuYaqe1PVOOlPVaeq8dq9SnTDmGBOOlPCU8LxTwtepTpi5hqrT1SnqtPC8V6tOmHMNCU8JzTwlPVK9SnTFzDVSnhOOlOVakC8V6lOmHMMCdOKwPEOv/AGfda2rfvejyA/d9h7/y+vR/iDX/ACA1rat+96PIP4fYe/8AL69OW21/OniL4i/V+fJMkn7+1Sovs94xf8380vs7L3ruPtYPC3/eVNuiGhOaeq08LzT1Wv5ep0z3eYYEqQJTlXipAlepTpi5hipUipTlSpFWvVp0w5hgTinhORxTwvFPC8ivUp0xcwwJz0qRVpwXmpFWvUp0w5hipTwlPC8U8JXqU6YuYaE5p6pT1SnqterTphzDQvFPCcjinBeKkC8ivUp0xcwwJz0p6rTwvNPVa9SnTDmGKlSBKcq8VIEr1adMXMNVKeqU4LUirXqU6YcwwLUgTnpTgtSBOa9SnTDmGKnPSnqntT1XmnqterTpi5hgTipAnSnKvFSBa9SnTDmGKlSKtOVaeq16lOmLmGhKwPEGv+RutbVv3vR5Qfu+w9/5fXo/xBr/AJG61tW/e9HlH8PsPf8Al9enLBa/nTxF8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2sHhb2qVPkhoTmnqntTwvNPVK/l6nTPd5hipx0p4TjpT1XinheO1epTpi5hoSnhOaeEp4XmvUp0w5hqpTwtPVaeFr1adMOYaE5p6pTwlPVK9SnTFzDAnFPCcdKeE4p4XivUp0w5hoSnhOaeFp4XmvUpUxcwxVqQLTlWpAtepTphzDAnNSKlOCVIqV6tOmLmGBOKeE46U8LxTwvFepTphzDAnPSpAvNOC81IF5r1KdMOYYq08JT1Wnha9WnTFzDQnNPVKeEp6rXqU6Ycw0JxTwtPC8U8LXqU6YuYYE56U8LzTwvNPC816tOmHMMVKwfEGv8AkbrW1b970kkB+77D3/l9ej9f1/yN1rat+96PIP4fYe/8vr05ZVr+c/EXxF+r8+SZJP39qlRfZ7xi/wCb+aX2dl713H2cHhb2qVPkhgWpAnNOC1IEr+XqdM93mGKlSBOKcqVIq16lOmHMMCVIqc9KcFqRV5r1adMOYYqe1PVOOlPVaeq8V6lOmLmGBKkCc04LUgSvUp0w5hipTwnFPVaeFr1aVMXMNC09U56U8LTwnNepTphzDFT2p6px0p6rT1XivUp0xcw0JTwnNPC8Cnha9WnTDmGqlPVaeq09V4r1KdMXMNC09Up4WnhK9SnTDmGKlPCcdKeqU8LxXq06YuYYE9qXb9KlC9Kdsr0Y09A5j45208LzT9lPC81/Q9Omf5Scw1Vp6rT1WnqtepTpiuNC1geINf8AILWtq373o8g/g9h7/wAvr0d4g1/yN1rat+96PIv8PsPf+X16cuFr+c/EXxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcfaweFvapU+SGKtSBeKcqVIEr+XqdM93mGBakC804LUgXmvUp0w5hirzT1WnqvPenqterTpiuMC8VIFpwXipAtepTphzDFWnhaeqU8JXqU6YuYaFp4XmnhaeF5r1adMOYYq809Vp6rz3p6rXqU6YuYaF4p4WnheKeFr1KdMOYaFp6rT1SnqterTphzDQtPC804LUgXmvUp0xXGKtPVeKeq09V4716tOmHMNC8U8LTgvFSBK9SnTFzDAtSBacqVIq16lOmHMMC1IF5pwWpAvNerTpi5hirT1XinqtPVeO9epTphzDAvFYHiHX/I3Wtq/73o8g/h9h7/y+vR/iDX/IDWtq373o8g/h9h7/AMvr05cL0r+c/EXxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcfZweFvapU+SGBeakVacE5p6pX8vU6Z73MNVaeFp6rTwtepTpi5hqrT1Wnhaeq16lOmHMMC8VIFpwXipNtepTpi5hgXmnqtPCc09Ur1adMOYYFqQLTlWpAtepTpi5hirUirTlWpFSvUp0w5hgXinhelPC8U8L0r1adMOYaF5p6rTwvNPVea9SnTFzDAtPC09Vp4WvVp0xcw1VqRVpwWnqlepTphzDQvFPC08JxTwvSvUpUw5hgXmpFWnBee9PVea9WnTFzDVWnhaeq08JXqU6Ycw1Vp6rTwlPVK9SnTFzDAtYPiDX/ACN1rat+96PIv8PsPf37fXo7xBr/AJAa1tW/e9HkX+H2Hv8Ay+vTlwlfzp4i+Iv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7WDwt7VKi9EMC1Iq04LUirX8u06Z7vMMVaeF4p6rTwvHevVp0xcwwLUgXmnBakCc16lOmHMMVakCU5Up4SvUp0w5hoWnqtPC09Vr1adMXMNVaeF4p6rTwvHevUp0w5hgWpAvNOCU8JzXqU6YuYaq08JT1SnqterTphzDQtPVaeFp6rXqU6YuYYF4qQLxTlXipAvFepTphzDAtPC80/ZTwnNerSpiuMVakC05VqRVr1KdMOYYFqRVpwWpFSvVp0w5hgXinheKeq8U8LxXqU6YuYaF5p4XmnheaeF5r1KdMOYYq1geINf8gNa2rfvejyD+H2Hv/L69H6/r/kb7W1b970eQfw+w9/5fXpy6pX86eIviL9X58kySfv7VKi+z3jF/wA380vs7L3ruPs4PC3tUqL0QwLTwtPC8U8LX8u06Z7vMNVaeF4p6rTwlerSphzDQtPC808JTwvNepTpi5hirzT1WnqvNPVa9SnTDmGBakC04LxUgWvUp0xcw1Vp4WnKlSKlepTphzDAlSKvNOCVIF5r1adMOYYq09V4p6rT1XjvXqU6YuYYF4qQLTgvFSBa9SnTDmGKtPVaeqU8JXq06YuYaEp4XmnhaeF5r1KdMOYaq09V4p6rT1XjvXq06YrjAvFPC08LxTwlepTphzDQtPVaeqU9Vr1KdMXMNC09VpwWpAterTphzDFWsHxBr/kBrW1f970eQfw+w9/5fXo7xBr/AJG61tW/e9JJB/D7D3/l9enLqtfzn4i+Iv1fnyTJZ+/tUqL7PeMX/N/NL7Oy967j7WDwt7VKnyQwLxT9tPC8U/bX8vU6Z7vMNC809Vp4XmnqlepTpi5hirUgSnBKeFr1KdMOYaFqRVpyrzUirXq06YuYYF4p4WnheKeF6V6lOmHMMC81Iq04LzUipXqU6YuYYq08LT1Wnha9WnTC41Vp6rTwtPVa9SnTFzDQvFPC9KcE4qQL0r1KdMOYYF5p6rTwvNPVK9WnTFzDAtSBacq1IFr1KdMOYYq1Iq05VqRUr1KdMOYYFqQLTglSBelerTpi5hirzT1WnqvNPVfrXqU6YcwwLxUgWnKvFSBa9SnTFzDFWsDxBr/kbrW1b970klH8PsPf+X16P8Qa/wCRutbVv3vR5B/D7D3/AJfXpy4Xmv508RfEX6vz5Jks/f2qVF9nvGL/AJv5pfZ2XvXcfaweFv8AvKnyQxVp4WnqtPCV/L1Ome7zDQtPVaeFp6rXqU6YrjFWnheKeq8U8Lx3r1KdMOYaFp4XmnhaeF5r1aVMOYaq08LTlSpAlepTpi5hoSnqtOC1Iq16lOmHMMC8U8LxTwvFPC8V6tOmLmGhaeF5p4WnhOa9SnTDmGKtSBKcqU8JXqU6YuYaFqRVpwWpFWvUp0w5hgXinheKeF4p4XivUp0xcwwLzUgXmnBeakCc16tOmHMMVaeFp6pT1WvUp0wuNC09Vp4WnqtepTpi5hoXinhacEqQLxXq06YcwwLzWB4g1/yC1rav+96PIP4fYe/8vr0f4g1/yN1rat+96PIP4fYe/wDL69OXC896/nPxE8Rfq/PkmST9/apUX2e8Yv8Am/ml9nZe9dx9nB4W9qlT5IYq809Vp6rzT1Sv5ep0z3eYYFqQLTglSBa9SnTC4xVqRVpyrUgWvVp0xcwwLUgXmnBKeF5r1KdMOYaq09V4p6rT1XivUp0xcwwLTwtPC8U8LXq06Ycw1Vp6rT1WnqlepSphzDQtPVeaeEp4XmvUp0xcwxVp6rxT1WnqvHevVp0w5hoXinhaeF4p4WvUp0xcw1Vp4WnKlSKlepTphzDAlSBacEqRV5r1adMXMMVaeF4p6rTwvFepTphzDAvSl2/WpQvSl2e1elGnoLmPjrZ7U8LzT9tPC81/Q1Omf5Scw1VrA8Qa/wCRutbVv3vSSQH7nsPf+X16O8Qa/wCQWtbVv3vR5B/D7D3/AJfXpy6rX85+IviL9X58kySfv7VKi+z3jF/zfzS+zsveu4+1g8Le1Spt0QxVqQLTlXipAtfy9Tpnu8wxUqRUpwSpFSvUp0w5hgSpAnPSnBakC816tOmLmGKnPSnqntT1XntT1WvUp0w5hgTinhKeF4p4SvUp0xcw0JzT1SnqlPVa9WnTDmGhKeE56U8LTwvNepTpi5hipz0p6p7U9V57U9Vr1adMOYaqcU8JTwvFPCV6lOmLmGhOaeqU9Up6rXqU6YcwwLUgTmnBakC816tOmHMMVPanqnHSnqlPVeK9SnTFzDAnHSpAlOC8dqkCV6lOmHMMCc1Iq04LzT1WvVp0xcw0LUgTmnBakCV6lOmHMMVPasDX9f8AI32tq373o8gP3fYe/wDL69H+INf8gta2rfvejyL/AA+w9/5fXpyyrX85+IviL9X58kySfv7VKi+z3jF/zfzS+zsveu4+zg8Le1Spt0Q0Jx0p4TjpTwnFPC8V/L1Ome7zDAnNPVOaeF5p6rzXqU6Ycw1Up4WnqtPC16lOmHMNCc09Up6rT1SvVp0xcwwJxUmynBOKeFr1KVMOYaE56U9U5p4Xmnhea9SnTFzDFSpAtOVakC16lOmHMMCc1IqU4JUipXq06YuYYE4p4SnhOKeFr1KdMOYaE56U9U56U8Lz2p6rzXq06YuYYq08JT1Wnha9SnTDmGhOaeqU8JT1SvUp0w5hoTinhaeF4p4WvVpUxcwwJz0p6pz0p4XntT1XmvUp0w5hqrTwlPVaeFr1KdMXMNCc1geINf8AI3Wtq373o8gP3fYe/wDL69HeINf+z7rW1b970kkH8PsPf+X16cuEr+dPEXxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcfaweFv+8qbdEMVKkCcU5UqQLX8u06Z7vMMC1Iq04LUirXq06YuYYqe1PCcdKeq08LxXqU6YcwwJ0qQJzTgvSpAnNepTpi5hipTwnFPVKeq16tOmHMNC09Up4WnqtepTphzDVT2p4TjpT1SnheK9SnTFzDAnSnhOaeF6U8LzXq06Ycw1Up4TinqtPC16lOmLmGhaeqU8LTwlepTphzDFTipAnFOVKkCcV6tOmLmGbPanhOaftp4XmvUpUw5hipUirTlWpFXivVp0xcwwLUipTgtSBK9SnTDmGKlPCcU9Up4XivUp0xcw0Jz0rA8Qa/5Ba1tW/e9HkB+77D3/l9ej/EGv+RutbVv3vR5B/D7D3/l9enLBea/nPxF8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2sHhb2qVNuiGKnPSnqntT1XntT1Wv5ep0z3eYaE4p4WnheKeFr1adMOYaqU8JxTwlPVK9SnTFzDAlSBOelOCVIF5r1KdMOYYqc9Keqe1PVee1PVa9WnTFzDAvFSBacF4qQLXqU6YcwxUqRUpwSpFSvUp0xcwwJUgTmnBakC816lOmHMMVPanqnHSnqtPVeK9SnTDmGBOOlSBKcF4qQLXq06YuYYE5p6pTwlPVa9SnTDmGhaeF5p4Wnhea9WnTFzDVT2p6px0p6rT1XivUp0w5hgTjpTwlPC8U8JXqU6YuYaE5p6pTwlPVa9WnTDmGBawfEGv+RutbVv3vR5B/D7D3/l9ejvEGv+QGtbVv3vR5B/D7D3/l9enLha/nPxF8Rfq/PkmST9/apUX2e8Yv8Am/ml9nZe9dx9rB4W9qlT5IYEqRUpyrUirX8vU6Z7vMMCcU/Z7U8JxT9lepTpi5hoTmnqlOC81Iq816lOmHMMVKkC05Vp4WvVp0xcw1Vp6pT1WnqtepTphzDQnFPCdKeE4p4SvUp0xcwwJz0p6pz0p4XntT1WvVp0w5hqpTwtPVaeFr1KdMXMNCc09Up6rT1SvUp0w5hgTipAnSnBOKkC16tOmLmGBOelPVOelPC89qeq816lOmHMMVKkC05VqQLXqU6YcwwJzUipTglSKlerTpi5hgTipAlOC1IFr1KdMOYYqc9Keqe1PVeaeq/SvUp0xcwxU46VgeINe8gNa2rfvejyA/d9h7/y+vR+v6/5Aa1tW/e9HkH8PsPf+X16cuF47V/OniL4i/V+fJMkn7+1Sovs94xf8380vs7L3ruPtYPC3tUqfJDAtPCc08L0p4Xmv5ep0z3eYaqU8JxT1Snha9SnTFzDQlPVaeFp6rXqU6YcwxU9qeE46U9Vp4XjtXq06YuYaEp4TmnhelPC816lOmHMMVKkCcU5UqQLXqU6YcwwLUirTgtSKterTpi5hipxTwnHSnheKeE4r1KdMOYZsqQJzTttSBea9SnTFzDFSnhOKeqU9Vr1adMOYaFp6pTwtPVa9SnTFzDVTinhOOlPVKeE4r1KdMOYYE56U8Jz0p4Xmnhea9SnTDmGqlPCcU9Vp4WvVp0xcw0LT1SnhaeEr1KdMOYYE4rB8Qa/5G61tW/e9HkB+77D3/l9ejvEGv8AkbrW1b970eQfwew9/wCX16cuF4r+c/ETxF+r8+SZJP39qlRfZ7xi/wCb+aX2dl713H2cHhb2qVPkhgTpUgTnpTglSBea/l6nTPd5hipz0p6p7U9V57U9Vr1KdMOYYE4qQLTgvFSBa9WnTFzDFSnqlPVaeqV6lOmHMNCU9U5p4Snhea9SnTFzDVT2p6px0p6rT1XjtXq06YcwwJx0p4SnheKeFr1KdMOYaqU8JxTwlPVK9SlTFzDQlPCc08LTwvNerTphzDFT2p6px0p6rT1XjtXqU6YuYaE46U8JTgvFSBa9SnTDmGKlSKlOCVIqV6tOmLmGBKkCU4LUirXqU6YcwxUp4TjpT1WnhOK9SnTDmGBOOlLsqULxS7K9KNPQXMfHW2sDxBr/AJBa1tW/e9HkH8PsPf8Al9ej/EGv+RutbVv3vR5B/D7D3/l9enLhOleL4i+Iv1fnyTJJ+/tUqL7PeMX/ADfzS+zsveu4/wCX2Dwt7VKm3RDAnNPVKeE5p6pzX8vU6Z7vMMCVIEpypUgSvUp0xcwxUqRUpwTmpFSvVp0w5hgSpAtOCVIE6V6lOmHMMVOaeqU9U5p6pXqU6YuYYqcVIEpypxTwlerTphzDQlPVKeE5p6pXqU6YuYaFp4WnqlPCdK9SnTDmGqnNPVKeqc09Ur1adMXMMVOKeEp6pxTwlepTphzDQtPVaeEp6pXqU6YuYYFqQJTlSpAlerTphzDFSpFSnKlSKlepTphzDAnFPCdKeE4p4TpXqU6YuYYE5qRVpwTmpFSvVp0w5hipWB4g1/yN1rat+96PIv8AD7D39+316P8AEGv+RutbVv3vR5F/h9h7/wAvr05ZUr+c/EXxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcfZweFvapU26IaEqRUpwSnqlfy9Tpnu8w0JxTwnFPVOKeE4r1KdMOYYE5qQJzTgnNSBOa9WnTFzDFSnhaeqU9Ur1KdMOYaEp6pTwlPVK9SnTFzDAlSBOKcE4qQJXqU6YcwwLzTwnNPCc08JzXq06YcwxUqRUpypUgTivUp0xcwwJUipTglSKlepTphzDAlSBacEp4SvUp0xcw0LzT1TmnhOaeqc16tOmHMMVKeE4p6pTwnFepTpi5hoSnqlPCU8JXqU6Ycw0JTwtPCU8JXq0qYcw0JzT1TmnhOaeqc16lOmLmGKlYHiDX/ACA1rat+96SSD+H2Hv8Ay+vR+v695G+1tW/e9HkB+77D3/l9enLKnFfzn4i+Iv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7ODwt7VKm3RDQnFPCU4JxUgSv5ep0z3uYYqVIq05UqRUr1adMXMMC1IEpwSpFTmvUp0w5hipTwnFPVKeE4r1KdMXMMCdKkCU4JxUgTmvVp0w5hipT1WnhKeEr1KdMXMNCU9Up4SnhOa9SnTDmGqlPCcU9Up4TivVp0xcwwJxUgTmnBOKkCc16lOmHMMVKeq09Up6pXqU6Ycw0JT1SnBKkCc16tOmLmGKlSBOKcqVIE4r1KdMOYZsp4Tmn7KeE5r1KVMXMMVKkC04JzUipXq06YcwwJUgSnBKkCc16lOmLmGKlYHiDX/IDWtq373o8g/h9h7/AMvr0f4g1/yN1rat+96SSA/d9h7/AMvr05ZUr+c/EXxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcfaweFvapU+SGhKeE5FPCU8JX8vU6Z7vMNVeaeqU9U5p6pXq06YcwxU4p4SnqnFPCV6lOmLmGqlPVKeE5p6pXqUqYcw0JTwvNOCVIEr1adMXMMVOaeqU9U5p6pXqU6Ycw0JxTwlOVOKkCV6lOmLmGBKkVKcE5qRUr1KdMOYYFqQLTglSBK9WnTDmGKlPVKeqU9Ur1KdMXMMCcVIEpwTipAnSvUp0xcwwJzT1SnhOaeqV6tOmHMNC08JT1SnhK9SnTFzDVSnqlPVKeqV6lOmHMMCcU8JTwnFPCdK9SnTDmGhOawPEGv+RutbVv3vSSQfw+w9/wCX16P8Qa99nLWtq373o8gP3PYe/wDL69OWCc1/OniJ4i/V+fJMkn7+1Sovs94xf8380vs7L3ruPs4PC3tUqfJDFSpAtOVKkCV/L1Ome7zDQtPVKcEqRUr1KdMOYYE4p4TinhOKeEr1KdMXMNCc08JzTwnNPCc16tOmHMMVKkC05Up6pXqU6Ycw0JUipTglPVK9SnTFzDQlPCU8JxTwlerTpi5hoXmnqnNPCc09U5r1KdMOYYqU8JT1SnhOK9SnTDmGhKeqU8JT1SvVp0xcwwJUgSnBOKkCV6lOmHMMC809U5p4TmnqnNepTpi5hqpTwnFOVKkCcV6tOmHMMCVIqU4JUipXqU6YuYYq1IFpwSnhK9SnTDmGhOawNf1/yN9rat+96PIP4fYe/wDL69H+INf8jda2rfvejyD+D2Hv/L69OXVOa/nPxF8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2sHhb2qVPkhirTwnFPVKeE4r+X6dM93mGBKkCc04J0p4TmvUp0xcw1Up6rT1SnqlepTphzDQtPVaeEp6pzXq06YuYYqVIE4pypUgTivUp0w5hgTpTwnNPCcU8JzXqU6YcwxUqRVpypUipXq06YuYYFqQJTglSKnNepTpi5hipTwnFPVKeE4r1KdMOYbsp4Tmn7KeE5r1KdMOYYqU9Vp6pTwlerTpi5hoSnqlPCU8JzXqU6Ycw1Up4TinqlPCcV6lOmLmGhelPCc04J0qQJzXq06YcwxUp6rT1SnqlepTpi5hoSsDxBr/kbrW1b970eQfwew9/5fXo7xBr3kbrW1b970eQH7vsPf8Al9enLhK/nPxE8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2sHhb2qVPkhgSpFSnqnNPVK/l6nTPd5hgSpAnIpwSpAnNepTpi5hirzT1SnqnNPVK9WnTDmGKnFSBKcE4qQJXqU6YcwxUqRUpwTmnqlepTpi5hoWpAlOCU8LXq06Ycw1Vp6pT1SnqnFepTpi5hgTinhKeE4p4SvUp0w5hoTmnqlPCc09Ur1aVMXMNC08LTwlPCV6lOmHMMVKkVKcqVIqV6lOmHMMCcU8JTwnFPCV6tOmLmGBOakVKcE5qRUr1KdMOYYFqQLTglSBK9SnTFzDFSnhOKeqU9U4r1adMOYaE4o2Vh+INe8gNa2rfvekkgP3fYe/wDL69Od/tG9/wCfu4/7+n/GvyHPvFXKMjxssBSpyrOGknFqyfWN3u11tonpunb0qWDqVY8zdj4wCcVIE6U4JxUgSvx+nTP8yeYYE5p6pzTwnNPVOa9WnTFzDFSpAlOVKkC16lOmHMMCVIqU4LUipXqU6YcwwJxUgSnKlSBK9SnTFzDFTmnqlPCc09Ur1KdMXMMVOKeEp6rxTwterTphzDQlPVKeEp6pXqU6Ycw0JxTwlPVKeEr1adMXMNVOaeqU5U5qRUr1KdMOYYqcU8JT1XinhOBXqU6YuYYEqRUp4SnqlerTphzDFTipAlOCVIFr1KdMXMMCVIqU5VqRUr1KdMOYYE4p4SnhOKeE6V6tOmHMMCc1geINf+z7rW1b970eQfw+w9/5fXo/xDr/AJG61tW/e9HkX+H2Hv8Ay+vTlwnNfzn4i+Iv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7ODwt/3lReiGKlPCcU9Up6pX8vU6Z7vMNCU9Up4SnqtepTphzDVSnhOKeqU8JxXqU6YuYYE5p4TmnhORTwnNerTphzDVSnqnFPVKeEr1KdMOYaEp4SnBakVa9SnTFzDAlSBOKcqVIE4r1adMXMMCc08JzTwnIp4TmvUp0w5hipUipxTlSpAlepTphzDAlSKlOC1Iq16lOmLmGKlPCU9Up4SvVp0w5hoTmnqnNPCc09U5r1KdMXMMVKeE4p6pTwvFepTphzDQtPVKeEp6rXq06YuYaqU8JT1SnhK9SlTDmGhOawPEGveQWtbVv3vR5Afu+w9/5fXo7xBr/kbrW1b970eRf4fYe/v2+vTlwnNfzn4ieIv1fnyTJJ+/tUqL7PeMX/ADfzS+zsveu4+zg8Le1SovRDFSnqnFPVKeqcV/L1Ome7zDAnFSBKcF4qQJXq06YcwwJUipTglSKlepTphzDAlSKlOCVIFr1adMXMMVKeE4p6pTwnFepTphzDAnFSBKcE4qQJzXqU6YuYYE5p6pTwlPVK9SnTDmGhKeqU8JTwtepTpi5hqpTwnFPVKeE4r1adMOYYE4p4TmnhOKeE5r1KdMOYaqc09Up4TmnqlerTpi5hgSpAlOCVIFr1KdMOYYqVIE4pypUgTivUp0xcwzZTwnNPCU8JzXq0qYcwxU5p6pTwnNSKlepTpi5hgSsDxBr/ANn3Wtq373pJIP4fYe/8vr0f4g1/yN1rat+96PKP4fYe/wDL69OWCV/OfiL4i/V+fJMkn7+1Sovs94xf8380vs7L3ruPtYPC3tUqLTohqpT1SnhaeqV/L1Ome7zDQlPCU8LTwlerTpi5hqpzT1SnqnNPVK9SnTDmGKnFPCdKeqcU8LXqU6Ycw0JT1SnhKeqV6lOmLmGBOKkCU4JUgSvVp0w5hipzT1SnqnNPVK9SnTFzDFTipAnSnKnFSBa9SnTFzDAlSKlOCVIqV6tOmHMMCcVIEpypUgSvUp0w5hipT1SnhKeqV6lOmHMMCcVIE6U4JxUgXpXq06YuYYE5p6pTwnNPVK9SnTFzDQnFPCU9Up4SvUp0w5hqpT1SnqtPVK9SnTDmGBOKwPEGveRutbVv3vR5Afu+w9/5fXo/xBr/AJAa1tW/e9HkH8PsPf8Al9enLhOK/nTxE8Rfq/PkmST9/apUX2e8Yv8Am/ml9nZe9dx9nB4W9qlTbohgTmnhOaeF5p4Tmv5ep0z3eYYqVIE4pypUipXqU6YcwwJUipTglSBa9SnTFzDAlPCU9Up4SvVp0w5hoTmnhOaeE5p4TmvUp0w5hipTwnFPVKeqV6tOmLmGhKeqU8JT1WvUp0w5hoSnhKeqU8JXqU6YuYaE5p6pzTwnNPVOa9SnTDmGKlPCcU9Up4TivUp0xcw0JTwlOC1Iq16tOmHMMCVIEpypUgSvUp0xcwwJzT1TmnhOaeqc16tOmHMMVKkCcU5UqQJxXqU6YuYYEqRUpwSpFWvUp0w5hipWB4g1/wAjda2rfvejyj+H2Hv/AC+vR/iDX/I3Wtq373pJIP4PYe/8vr05ZUr+dPETxF+r8+SZJP39qlRfZ7xi/wCb+aX2dl713H2sHhb2qVPkhoSpFSnBKeqV/L1Ome7zDVSnhOKeqU8JxXqU6YuYYE4p4TmnheKeFr1KdMOYaEp4SnhKeqV6tOmLmGhKeE5p4SnqlepTphzDFSpAnFOVKkCcV6lOmLmGBOKeE5p4XinhOa9SnTDmGKlSKlOVOakVK9WnTDmGBKkVKcEqQLXqU6YuYYqU8JxT1WnhOK9SnTDmG7KeE5p+ynhOa9WnTFzDFTmnqlPVOaeqV6lOmHMNCU9Up4Snha9SnTFzDVSnhOKeqU8JxXq06YcwwJ0qQJzTglSBOa9SnTFzDFTmsDX9e8jfa2rfvejyA/d9h7/y+vR+v6/5Ba1tW/e9JJB/D7D3/l9enLKlfzn4i+Iv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7WDwt7VKm3RDFTipAlOVOKkCV/L1Ome7zDFSpFSnBakVa9WnTDmGBKkCU4LUgSvUp0xcwxU5p6pT1TmnqlepTphzDFTipAlOVOKkCV6lOmLmGKlPVKeFp6pXq06Ycw0JTwlPC08JXqU6Ycw1Up6pT1SnqlepTpi5hgTinhOlPCcU8LXqU6Ycw0JzT1SnhOaeqV6tKmLmGBOKkCU4JUgSvUp0xcwxUqRUpwSpFSvUp0w5hgTinhOlPCcU8L0r1adMOYYE5qRUpwTmpFSvUp0w5hgTipAlOVKkCV6tOmLmGKlYHiDX/I3Wtq373o8gP3PYe/8vr0f4g1/wAjda2rfvejyD+H2Hv/AC+vTl1Sv5z8RPEX6vz5Jkk/f2qVF9nvGL/m/ml9nZe9dx9nB4W9qlT5IYE4pdlShaXZX8txp6Hu8x8chOKkCU4JxUgTpX9DU6Z/lJzDAnNPVOaeE5p6pzXq06YcwxUqQLTlSnhK9SnTFzDQtSKlOCVIqV6lOmHMMCU8JT1SnhK9WnTDmGqnNPVaeqc09Ur1KdMXMMVOKeEp6pxTwnFepTphzDQlPVKeEp6pXq06YuYYq1IEpypUgWvUp0w5hoXmnqtOCc1IqV6lOmLmGKnFPCcU9U4p4TivVp0w5hgSpFSnBKkVK9SnTDmGKtSBacqVIEr1KdMXMMVaeqU9U5p6pXq06YuYaE4rA8Qa/wCQGtbVv3vR5B/D7D3/AJfXo/xBr3kBrW1b970eQH7vsPf+X16csE4r+c/EXxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcfaweFvapU+SGBKkCc07ZUgTmv5ep0z3eYYqU9Vp6pT1SvUp0w5hoWnhaeFp6pzXq06YuYaq08JxT1SnhOK9SnTDmGBORTwnNPCcinhOa9SnTFzDVSnqtPVKeqV6lOmHMMC1Iq04JUipzXq06YcwxUqQJxTlSnhOK9SnTFzDQnSnhOaeEp4TmvVp0w5hipT1WnqlPCV6lOmLmGhaeEp4SpFTmvUp0xcwxUp4SnqlPCV6lOmHMNCcinqvNPCU9U5r1KdMOYYqU9U4p6pTwnFerTphzDQlPVKeEp4TmvUp0xcw1UrA8Qa/5Aa1tW/e9HkH8PsPf+X16O8Qa/5G61tW/e9HkH8PsPf+X16cuqV/OfiJ4i/V+fJMkn7+1Sovs94xf8380vs7L3ruPs4PC3tUqbdEMCVIEpwSpAlfy9Tpnu8wxUp6rxT1SnqnFerTphzDAnFSBKcE4qQJXqU6YcwwJzUipTgnNPVK9SnTFzDQlSBacEqQJXq06YcwxVp4XinqlPCcV6lOmLmGBOKkCU4JxUgSvUp0w5hgTmnqlPCc09Ur1adMOYaFp4WnhKeEr1KdMXMNVaeE4p6pTwnFepTpi5hgTinhOaeE4p4TmvVp0w5hoTmnqlPCc09Ur1KdMOYYFqQLTglSBK9SnTFzDFSpAnFOVKeE4r1adMOYaEp4TmnhKeE5r1KVMXMMCc1ga/r/AJG61tW/e9JJB/D7D3/l9ej/ABBr3kFrW1b970eQH7nsPf8Al9enLqnNfzn4ieIv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7WDwt7VKnyQxUp4WnqlPCV/L1Ome7zDQtPVaeEp6pXq06YuYaqU8JTwnFPCdK9SnTDmGqnNPVKeqc09Ur1KdMOYYqcU8JT1TinhK9WnTFzDQtPVKcEqRUr1KVMXMMVKkCU5UqQJ0r1KdMOYYqc09Vp4TmnqlepTphzDFTipAlOVOKkCcV6tOmLmGBakVKcEp6pXqU6Ycw0JTwtPVKeEr1adMXMNVOaeq09Up6pXqU6YcwwJxUgTpTgnFPCdK9SnTFzDQnNPVKeE5p6pXq0qYcwxVqQLTlSpAtepTphzDQtYGv6/wCRutbVv3vR5B/D7D3/AJfXo7xBr/2fda2rfvejyD+D2Hv/AC+vTlwlfzn4i+Iv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7ODwt7VKm3RDFWpAvFOVKeE4r+XqdM93mGhORTwnNPCc08JzXqU6YcwxUqQJTlSnqlepTpi5hoWpFSnBKkVK9WnTDmGBaeE4p6pTwnFepTpi5hoTkU8JzTwnIp4TmvUp0w5hipT1WnqlPVK9WnTFzDQtPC08LT1TmvUp0w5hoWnhKeqU8JXqU6YcwwJzUipzTwnNPVOa9WnTFzDFSnqnFPVKeqcV6lOmHMMC1Iq04JUipzXqU6YuYYqVIEpypUgSvVp0w5hgTkU9U5p4TmnqnNepTpi5hipUipxTlSpAnFepTphzDAtYHiDX/I3Wtq373o8g/h9h7/AMvr0f4g17yA1rat+96PID932Hv/AC+vTlwlfzp4ieIv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7ODwt/3lT5IYFp4WnhOaeqV/L1Ome9zDQlPCU8JTwnNepTpi5hqpTwnFPVKeE4r1KdMOYYF4p4SnhOKeEr1KdMXMNC09Up4TmnqlerTphzDAlSBacEqQJXqU6YuYYqVIF4pypTwnFerTphzDQvFPCc08JxTwnNepTpi5hgTmpFSnBOaeqV6lOmHMNCVIFpwSpAlepTphzDFWnheKeqU8JxXq06YuYYEqQJzTtlSBOa9SnTDmGBOaeqU8JzT1SvVp0xcw0LTwtPCU8JXqU6Ycw1Vp4TinqlPCcV6lOmLmGBKwfEGv8AkFrW1b970eQfw+w9/wCX16O8Qa/5G61tW/e9HkB+77D3/l9enLhOlfzp4ieIv1fnyTJJ+/tUqL7PeMX/ADfzS+zsveu4+1g8Le1Srt0QxU5p6pT1Tmnqlfy7Tpnu8wxU4qQJTlTipAlerTpi5hgWpFWnBKkVK9SnTDmGBakCU5UqQJXqU6YcwxU5p6pT1TmnqlerTpi5hipxTwlPVOKeEr1KdMOYaFp6rTwlPVK9SnTFzDVSnhKeE4p4SvUp0w5hqpzT1SnqlPVK9WnTFzDAvFPCdKeE4p4TpXqU6Ycw0LzT1SnhOaeqV6lKmHMMVKkCU5UqQJXq06YuYYqc1Iq04JT1SvUp0xcw0LxTwnSnhOKeEr1KdMOYYE5qRUpwTmnqlerTphzDQlYHiDX/ACN1rat+96SSL/B7D39+316P8Qa/5G61tW/e9HkB+77D3/l9enLBOK/nPxF8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2cHhb2qVPkhoSnqlPCU9Ur+XqdM93mGhKXZUoSl2V6Uaegcx8chOKkCU4LUgSv6Gp0z/ACk5hgTmnqnNPCc09U5r1KdMXMMVKeE4p6pTwnFepTphzDQlPVKeEp4WvVp0xcw1Up4SnqlPC16lOmHMNVOaeqU8JzT1SvUp0w5hipxTwnFPVOKeE4r1adMXMNCU9Up4Wnha9SnTDmGBKkCU5UqQJXqU6YuYYqc1IqU4JzUipXq06YcwxU4p4TinqnFPC8V6lOmLmGBKkCU4LUgSvUp0w5hipUgSnKlPCV6tOmHMNCc1geINf8jda2rfvejyA/d9h7/y+vR/iDX/ACN1rat+96SSL/D7D39+316csEr+c/EXxF+r8+SZJP39qlRfZ7xi/wCb+aX2dl713H2cHhb2qVF6IaqU8JxT1SnhOK/l6nTPd5hmypAnNOCVIF5r1KdMOYYqU8JT1WnqlerTpi5hoSnqlPCU9Ur1KdMOYYqVIE4p6pTwnFepTpi5hgTpTwnNPCdKeF5r1adMOYaqU8JTlSpFTivUp0xcwwJUgTmnBKkVK9SnTDmGKlPCcU9Vp4XivVp0w5hoTpTwnNPCdKeE5r1KdMXMMVKeqU9Up6pxXqU6Ycw0JT1SnhKeFr1adMXMNVKeEp6rTwtepTphzDQlPVOaeEp6pzXqU6YuYYqU9U4p6pT1TivUp0w5hoSsDxBr/wBn3Wtq373pJIP4fYe/8vr0d4g1/wAgNa2rfvejyD+H2Hv/AC+vTlwlfzn4ieIv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7ODwt/3lTbohgTmpFSnhOaeq1/L9Kme7zDAlSBKcFqQLXqU6YcwxUp6pxT1SnqlepTphzDAnFSBOlOCcVIEr1KdMXMMCc09Up4XmnqterTphzDQtPCU8LTwlepTpi5hqpTwnFPVKeE4r1KdMOYYE4qTZTgnFP216tOmLmGhOaeqU8LzT1SvUp0w5hgSpAlOC1IEr1KdMOYYqVIE4p6pT1SvVp0xcwwJxTwnNPCcU8LzXqU6Ycw0JzT1SnBOakVK9SnTFzDAnFSBKcEqQJXq06YcwxUp4TinhaeFr1KdMXMNCVgeINe8jda2rfvejyA/d9h7/y+vR/iDX/IDWtq373o8g/h9h7/AMvr05YJX85+IniL9X58kySfv7VKi+z3jF/zfzS+zsveu4+1g8Le1Sp8kNCc09U5p4TmnqvNfy9Tpnu8wxUp4SnqlPCV6lOmLmGhKeqU8JT1SvVp0w5hqpxTwlOVakC16lOmHMMVOakVKcqc1IqV6tOmLmGKnFPCcU9U4p4TivUp0w5hgSpFSnBKkC16lOmLmGKnFSBKcFqQLXq06YcwxU5p6pT1TmnqlepTpi5hipxUgTinKnFSBOK9SnTDmGBKeqU8JTwterTpi5hqpTwlPVKeFr1KdMOYaqU9Up4SnqlepTpi5hgTinhOKeE4p4TgV6tOmHMNCc09Up4Wnha9SlTDmGBKwfEGv+RutbVv3vR5B/D7D3/l9ejvEGv+RutbVv3vSSUfw+w9/wCX16cuFr+c/ETxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcfZweFvapU+SGBakVKcFqRVr+XqdM93mGKlPCcU9Up4TivUp0w5hoTkU8JzTwnSnhOa9WnTFzDFSnqlPVaeqcV6lOmHMNCVIqU4LTwlepTphzDVSnhOKeqU8LxXqU6YuYaEp4TmnBOlSBea9WnTDmGKlPCU9Vp6pxXqU6YuYaEp6pTwlPVK9SnTFzDFSpAlPVKeFr1adMOYYEqRU5pwSpFTmvUp0w5hipTwnFPVKeqcV6lOmHMMCdKkCc04JUipXq06YuYYqVIEpyrTwtepTpi5hoSnqnNPCU9U5r1KdMOYYqVg6/r3kBrW1b970eQH7vsPf8Al9ejtf1/yN9rat+96SSD+H2Hv/L69OXVOK/nTxF8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2cHhb2qVPkhgTinhOlPCcU8JX8u06Z73MNCc09Up4TmnqlerTpi5hoSnhKcFqQLXqU6Ycw1Up4TinqlPCcV6lOmLmGBOKeEp4TinhK9WnTDmGBOakVKeE5p6rXqU6YuYYEqQJTgtSBa9WnTDmGKlSBOKcqU8JxXqU6YuYaE4p4TmnhOKeE5r1KdMOYYE5p6pTwvNPVa9WnTFzDQtPCU8LTwlepTphzDVSnhOKeqU8JxXqU6YcwwJUgTmnBKkC816tOmLmGBOaeqU8LzT1SvUp0w5hgSpAlOC1IEr1KdMXMMVKwfEGv8AkbrW1b970eQfwew9/wCX16O8Qa/5G61tW/e9HkH8PsPf+X16cuqV/OniJ4i/V+fJMkn7+1Sovs94xf8AN/NL7Oy967j7WDwt7VKnyQwJxUgSnKlSBK/l2nTPd5hgTmnqlPVOaeqV6tOmHMMVOKkCU5V4qQJwK9SnTFzDAlSKlOCVIqV6lOmLmGKnFSBKcEp4WvVp0w5hoTmnqlPVOaeqV6lOmHMMVOKeE4p6pxTwnAr1KdMXMNCU9Up4SnqlerTphzDVTinhKcq1IFr1KdMXMNVKeqU9Vp6pXqU6YcwwJxTwnSnhOKeE6V6lOmLmGhOaeqU8JzTwterSphzDFTipAtOC1IFr1KdMOYYqVIqU5Vp6pXqU6YuYaE4p4TpTwnFPCcCvVp0w5hgTmsDxBr3kFrW1b970eQH7vsPf+X16P8Qa/wCQWtbVv3vR5B/D7D3/AJfXpy4Tmv5z8RfEX6vz5Jkk/f2qVF9nvGL/AJv5pfZ2XvXcfZweFvapU+SGKlPVOKeqU9Vr+XqdM93mGhKeqU8LT1WvUp0w5hqpS7KlVKXZXpRp6C5j45VakC05UqQJX9DU6Z/lJzDAvIp6rz3p4TmnqnPSvUp0w5hirUgTinKntT1TjpXq06YuYaFqRV5pwWnqtepTphzDVWnhKeqU8JxXqUqYuYaEp6rTwlPVK9WnTDmGKvFPC8d6eqe1PCcdK9SnTDmGhaeF5p4WnhOa9SnTFzDFSpAlOVKkCcV6tOmHMMC1Iq04JUirXqU6YuYYq8U8Lx3p6p7U8Jx0r1KdMOYYFqQLzTglSBOa9WnTFzDFSsDxBr/kBrW1b970kkX+H2Hv/L69H+INf8jda2rfvejyA/d9h7/y+vTllSv5z8RPEX6vz5Jkk/f2qVF9nvGL/m/ml9nZe9dx9rB4W9qlTbohoSpAlOCcU8JX8vU6Z7vMNVaeF4p6pTwvFepTphzDAtSBeacEqQJz0r1KdMXMMC809Vp4TmnqlerTpi5hoSnhacE4qQJXqU6Ycw1Vp4XinqtPC8V6tKmHMMC1IF5704J0qQJz0r1KdMOYYq809Up6pz0p6pXqU6YuYYEqQLTgnFSBa9WnTFzDFWpAvFOVaeE4r1KdMOYaEp4XnvTwlPCc9K9SnTFzDFXmpFSnKnPSnqntXq06Ycw0JTwtPCcU8LXqU6Ycw1Vp4WnqlPVK9SnTFzDQlPC808JT1TmvUp0w5hirWBr+v+QGtbVv3vR5B/D7D3/l9ej/ABBr/kbrW1b970eQH7vsPf8Al9enLqlfzp4ieIv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7ODwt7VKm3RDAvFPC08Jx0p4TpxX8vU6Z7vMNC809Vp4XmnqtepTphzDFWpAtOVKkCV6lOmLmGKvNPVaeqVIqV6lOmHMMC8U8LTwnHSnhOnFerTpi5hgXmpFWnBeaeqV6lOmHMNC08JT1SnhK9SnTDmGheaeq09Up6rXq06YuYYF4qTbTgvFSbPavUp0w5hgXmnqtPCc09Ur1KVMXMMVKkCU4JxUgSvVp0w5hoXmnqtOCVIq16lOmLmGBeKkC8inBOKkCcjivUp0w5hgXmnqlPCc9KeqV6tOmHMMVKkCU5UqQJXqU6YuYYq81geINf8jda2rfvekkg/h9h7/wAvr0f4g1/7PutbVv3vR5Afu+w9/wCX16cuqV/OfiJ4i/V+fJMkn7+1Sovs94xf8380vs7L3ruPs4PC3tUqfJDFWnhaeq08LX8vUqZ73MNC809V5708Jz0p6pz0r1KVMXMMVaeqcU9U9qeE4r1adMOYaEp4XmnhOlPCV6lOmLmGqtPC09Vp4SvUp0w5hoXmnqtPCc09Ur1adMXMMVeKeE4p6px0p4TjpXqU6YcwwLUgXmnBOlSBea9WlTDmGKtSBKcqVIEr1KdMXMMCVIq04JzUipXqU6YcwxV4p4XinqntTwnHSvVp0xcwwLUgXmnBakC816lOmHMMVaeEp6pTwnFepTpi5hoSnqtPCU9Ur1adMOYYF4qQLxTgvFSBOOlepTphzDAtYHiDX/s5a1tW/e9HkH8HsPf+X16P8Q6/5G61tW/e9HkB+77D3/l9enLBOelfzn4ieIv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7ODwt/3lReiGheaeq08LzT1Sv5ep0z3eYYEqQJTglSBOa9SnTDmGKlSBeKcqVIF4r1adMXMMC9KeF5708LTwnPSvUp0w5hirzUirTlTnpUipXqU6YuYYEqQJTgnFPCV6tOmHMNVaeF4p6pTwvFepTpi5hoWnhee9PCdKeE56V6lOmHMMVeaeq09U56U9Ur1KdMOYaEp4WnBOKkCV6tOmLmGqtPVaeq08JXqU6YuYYFqRV5pwTpUgTmvUpUw5hir9aeq8U9U9qeqcdK9WnTDmGBOKkC04Jx0qQLXqU6YuYYq1IFpyrT1SvUp0w5hoSsDxBr/AJBa1tW/e9HkH8HsPf8Al9ej/EGv+RutbVv3vR5Qfu+w9/5fXpywSv508RfEX6vz5Jkk/f2qVF9nvGL/AJv5pfZ2XvXcfZweFvapUXohqrzT1WnqlPVK/l2nTPd5hgXjvUgTpTgnHSnhOnFerSphzDQvNPVaeE5p6rXqU6Ycw1Vp4WnhKeEr1KdMXMNVKeq8U8JzT1SvVp0w5hgXin7aeE4p+z2r1KdMXMNC809Vp4XmnqtepTpi5hirUgWnKlSBK9WnTDmGKlSKtOVKkVK9SnTDmGBeKeF5p4XinhORxXq06YcwwLzUirTgnPSpFSvUp0xcwwLTwlPVKeEr1KdMXMNC809Vp6pT1WvVp0w5hoXinheRTwvFPCcjivUp0w5hgXmnqtPCc9KeqV6lOmLmGKlYPiDX/I3Wtq373o8i/wAPsPf+X16P8Qa/5G61tW/e9JJAfuew9/5fXpyypxX86eIviL9X58kySfv7VKi+z3jF/wA380vs7L3ruPtYPC3tUqL0QwLUipTglSKlfy7TpnucwxVqQLTlSpAterTphzDAvNSKtOCc1Iqe1epTphzDFXjvTwvFPVOOlPCcdK9SnTDmGBKkC804JUgTmvVp0xcwxVp4WnqtPC16lOmLmGheaeq08JzT1SvUp0w5hirx3p4TinqnHSnhOOlerTpi5hoSnheaeE6U8LzXqU6Ycw1Vp4WnqtPCV6lOmHMNC09Vp4TmnqlepTpi5hgXinheKeE4p4TjpXq0qYcw0LTwvNPCU8LzXqUqYuYYq1IEpypUgSvUpUw5hgSpFWnBOakVK9WnTDmGBeKwPEGv+QGtbVv3vR5B/D7D3/l9ej/EGv8AkbrW1b970eQH7nsPf+X16csE4r+c/EXxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcfZweFvapUXohoXpTwvNPCU8Jz0r+XqdM93mGKvNPVaeqc9Keq16lOmHMNC08LTwlPCc16lOmLmGqlLt+tSqlLs9q9KNPQOY+OVWnhKeq08LX9DU6Z/lJzDQlPVeaeFp6rzXq06YuYYq/SnqvFPVaeq8V6lOmHMNC09Vp4Wnha9SnTDmGqtPCU9Vp6rXq06YuYaEp6rTwtPVa9SnTDmGKtPC8dqeq08LxXqU6YuYaF6U8LzTwtPC816tOmHMMVKkC05VqRVr1KdMXMMC1Iq04LUirXqU6YcwxVp4XinqtPC8V6tOmLmGBelYPiDX/ILWtq373o8g/h9h7/AMvr0d4g1/yA1rav+96PIP4fYe/8vr05cLzX85+IniL9X58kySfv7VKi+z3jF/zfzS+zsveu4+1g8Lf95UXohgXmnqtPC809Vr+XqdM93mGhKeEp6rTwtepTphzDVWnheKeq08LxXq06YuYYFqQLzTgtSBea9SnTFzDAvNPVaeF5p6rXqU6YcwwLUgWnKtSBa9WnTFzDFWpAvFPVaeFr1KdMOYYEqQJzTgtSBea9SlTDmGKvPanqtPVeaeq16tOmHMMC8VIFpwXipAtepTpi5hirTwvFPC08LXqU6YuYaEp4XmnhaeF5r1adMOYYq89qeq09V5p6rXqU6YuYaF4p4WnheKeFr1KdMOYaq09Up6rTwtepTphzDQtYHiDX/I3Wtq373o8i/wAPsPf+X16O8Qa/5Aa1tW/e9HkH8PsPf+X16cuFr+dPETxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcfZweFvapUXohqpT1WnKtSKtfy9Tpnu8wwLxTwvSnheKeF6V6lOmHMMC81Iq08LzTwtepTpi5hgXipAlOVakC16tOmHMMC09Vp6rT1WvUp0xcw0LxTwvFPC8U8LwK9SnTDmGBeaeq08LzT1WvUp0xcw1Up4SnhaeFr1adMOYaFp6rT1WnqtepTphzDAvFSbacF4qQLXqU6YuYYF5p6rzTwvNPVa9WnTDmGKlSBacq1IFr1KdMXMMVakVacq1Iq16lOmHMMC8U8J0p4Xinha9WnTFzDQvPanqtPC809V5r1KdMOYYq8VgeINf8jda2rfvejyD+H2Hv8Ay+vR+v6/5G+1tX/e9JJB/D7D3/l9enLheK/nPxE8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2sHhb2qVF6IYEp4Wnhaeq1/L1Ome5zDVWnhaeq08LXqUqYcw0JzT1Xmnhaeq816tOmHMMVfpT1XinqtPVeK9SnTFzDQtPVaeFp6rXq06YcwxVqQLTlWpAlepTpi5hgSpFSnBakVa9SnTDmGKtPC8dqeq08LxXq06YuYYFqQLzTgtSBea9SnTDmGKtPCU9Vp4WvUpUw5hoSnqtPC09Vr1adMXMNVaeF47U9Vp4XivUp0xcwwL0p4XmnhaeF5r1KdMOYaqU8JT1WnqterTphzDQlPVaeFp6rXqU6YuYYF4rB8Qa/5Aa1tW/e9HkH8PsPf+X16O8Qa/5G61tW/e9JJR/D7D3/l9enLheK/nPxE8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2sHhb2qVF6IYFp4XmnhaeF5r+XqVM93mGheaeq08LzT1WvUpUxcwwJUgSnBakC16tOmHMMVaeF4p6rUgXivUp0w5hgWnheaeFp4XmvUp0xcwxV5qRVpyrzUirXq06YcwwJTwlPC8U8LXqU6YuYaq08LxT1WnheK9WlTDmGhaeE5p4Wnhea9OnTFzDFXmnqtPVeaeq16tOmHMMC8VIFpwXipAtepTphzDFWpAvFPVaeq16lOmLmGBKkVOacFqQLzXq06YcwxVp6rx2p6rT1XivUp0xcwwLxUgWnBeKkC16lOmHMMVawPEGv8AkbrW1b970kkH8HsPf+X16P8AEGv+QWtbVv3vR5B/B7D3/l9enLqtfzp4i+Iv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7ODwt7VKm3RDFXinhKeFp4Sv5dp0z3eYaqU9Up4WnqterTphzDAvFPC9KeF4p4XpXqU6YuYaF5p6rTwvNPVa9SlTDmGqvFPCU5VqQLXq06Ycw1Up6rTlWpFWvUp0xcwwLxT9tPC8U/bXqU6Ycw0LzT1Wnheaeq16tOmLmGBeKkCU5VqQLXqU6YuYYFqRVpyrUirXq06YcwwLxTwtPC8U8L0r1KdMOYYF5qRVpwXmpFWvUpUw5hirxTwlPC08LXq06YuYaFp6rT1WnqtepTpi5hgXipAtOC8VIF6V6lOmHMMC81ga/r/kFrW1b970eQfw+w9/5fXo/xBr/kFrW1f970eQfw+w9/5fXpy6rzX85+IviL9X58kySfv7VKi+z3jF/zfzS+zsveu4+1g8Le1Spt0QxVp4XinqtPVeK/l6nTPd5hgSpAtOC1Iq16tKmLmGKtSBacq1IFr1KdMOYYF5qRUpwWnqtepTpi5hqrxTwvHanqtPC8V6tOmHMMCVIF5pwWpAvNepTphzDFWnhaeq08JXqU6YuYaEp6pTwtPVa9WnTDmGKtPC8dqeq08LxXqU6YuYaFp4XmnhaeF5r1adMOYYq1IFpyrUgSvTp0xcwwJUipTgtSKterTphzDAvFPC8U8LxTwvFepTphzDQtPC808LTwvNepTpi5hirTwlPVaeFr1adMXMNCVgeINf8AI3Wtq373o8i/w+w9/wCX16P8Qa/5G61tW/e9HkX+H2Hv79vr05cJX85+IviL9X58kySfv7VKi+z3jF/zfzS+zsveu4+1g8Le1Sp8kMVKeF4p6rTwvFfy9Tpnu8w0LTwvPanhaeF5r1KdMOYYq809Vp6rzT1WvUp0xcw0LTwlPC08LXq06Ycw1Updv0qVVpdtelGnoLmPjlUp6rT1Snqtf0NTpn+UnMNC09V5p4WnqnPSvUp0w5hir9aeq8U9U9qeqcdK9SnTFzDQlPCU8JxTwlerTphzDVWnqtPVKeEr1KVMOYaFp6rzTglSKlepTpi5hirTwvFPVKeE46V6tOmHMNCdKeF5pwTpxUgTmvUp0xcwxVqRVpyrT1SvUp0xcw0LUirzTglSBOa9SnTDmGKtYHiDX/IDWtq373o8g/g9h7/y+vR+v6/5G61tW/e9HkB+77D3/l9enLKnFfzp4ieIv1fnyTJJ+/tUqL7PeMX/ADfzS+zsveu4+1g8Le1Sp8kNC8U8LzTwnFPCc9K/l6nTPd5hgTmnqtPCc9KeqV6lKmLmGqtPC08JTwlerTphzDVSnhKeqU9Ur1KdMXMMC8VIF5pwTipAnI4r1KdMOYYF5p6rTwnPSnqterTphzDFWpAtOCVIEr1KdMXMMVKkCU4JzUipXqUqYcwwLUgXmnBKkCc9K9SnTFzDFXnvT1WnqnPSnqntXq06YcwwLxTwlPVOKeEr1KdMXMNVKeq09Up6pXqU6Ycw0LTwvNPC08Jz0r1adMOYYq896eq09U56U9U9q9SnTFzDQvFPCU9U4p4SvUp0xcw0LzWB4g1/yN1rat+96PIP4fYe/wDL69HeINf+z7rW1b970kkB+77D3/l9enLhOa/nTxE8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2sHhb2qVPkhgSpAtOVKkC1/L1Ome7zDAtSKtOCc1IqV6lOmHMMC8U8L0p4TjpTwnHSvVp0xcwwJUipTglSBOa9SnTDmGKtPC09Up4WvUp0xcw0LT1WnhOaeqV6tOmHMNC8U8LxTwnFPCcdK9OnTDmGBOaeF5p4TnpT1TmvVp0xcw1Vp4WnqtPC16lOmHMNC09Up4TmnqlepTpi5hgXipAtOCcVJsr1adMOYYF5p4XmnhOelPC816lKmLmGKtSBacq1IEr1KdMOYYFqRUpwTmpFSvVp0xcwwLxTwvSnhOKeFr1KdMOYaF571ga/r/AJBa1tW/e9HkH8PsPf8Al9ej/EGveQWtbVv3vR5Afu+w9/5fXpyypz0r+c/EXxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcfZweFvapUXohir9aeq8U9U9qeqcdK/l6nTPe5hoWnhaeEp4TmvVpUxcw1Up4SnqlPCcV6lKmHMNC9Keq808JT1TnpXqUqYuYYq/WnqvFPVPanqnHSvVp0w5hoWnhacEqQJzXqU6YuYYqVIq05UqQJxXqU6YcwwLUirTgtSKlerTphzDFWnheO9PVPanhOOlepTpi5hgSpAnNOCdKkCc16lKmLmGKtPVaeqU9Vr1KdMOYaFp6rTwtPVK9WnTFzDVWnheO9PVPanhOOlepTphzDAnSnhOaeE9qeE5r1KdMOYaq09Vp6pTwlerTpi5hoWsDxBr/kFrW1b970eQfwew9/5fXo7xBr/kbrW1b970eUfw+w9/5fXpy4Wv5z8RfEX6vz5Jkk/f2qVF9nvGL/m/ml9nZe9dx9rB4W9qlReiGqtPCU5UqQJxX8vU6Z7vMMC8U8LzTwnFPCc9K9WlTFzDQnNPVKcE56VIqV6lOmHMMVakC05VqQLXqU6YuYYq08JT1SnhOK9WnTDmGhaeF5p4SnhOelepTphzDFXmnqtPVOelPVPavUp0xcw0LxTwtPCcU8JXq06Ycw1Up4SnqlPVK9OnTFzDAtSBeacEqQJz0r1adMOYYq896eq09U56U9U9q9SnTFzDAvFSBacE4qQJXq06YcwxUqQJTgnNSKlepTphzDAtSBeacFqQJzXqUqYuYYq09V4709U9qeqcdK9SnTDmGBeKwPEGv+RutbVv3vR5B/D7D3/l9ej/ABBr/kBrW1b970eQH7vsPf8Al9enLhOOlfzn4i+Iv1fnyTJJ+/tUqL7PeMX/ADfzS+zsveu4+zg8Le1SovRDAvNPVKeE5p6pX8vU6Z7vMNVKeEp6pTwterTphzDVXmnqtPVaeqV6lOmHMMC8U8L0p4TjpTwnHSvVpUxcw0JzT1SnhOaeqc16lOmHMMCVIFpypUgWvUp0xcwwLUirTgnNSKlerTpi5hgXin7aeE4p+yvUp0w5hoTmnqlOCc9KkVOa9SnTDmGKtPC09Up4WvVp0xcw0LT1SnhOaeqV6lOmHMNC8U8L0p4TinhOlepTpi5hgXmnqvNPCc9Keqc9K9SnTDmGqtPC09Vp4WvVp0w5hoWnqlPCc09Ur1KdMXMMCcVg+INf8jda2rfvejyL/B7D3/l9ejvEGv8AkbrW1b970eQH7nsPf+X16cuE4r+c/EXxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcfaweFv+8qL0QwLyKkVeacEqRU56V/L1Ome5zDFWnqvFPVPanqnHSvVp0w5hgWpAtOC1IE5r1KdMOYYqVIEpypTwnFerTpi5hoWnqtPCU9Vr1KdMOYaq08Lx3p6p7U8Jx0r1KdMXMMC08JzTwlPCc16lOmHMNVKeEp6pTwnFerTpi5hoWnqtPC09Vr1KdMOYYq08Lx3p6p7U8Jx0r1adMOYaFp4TmnhOlPCc16dOmLmGKlSKtOVKkCcV6tOmHMMC1Iq04LUipXqU6YuYYq8U8LxT1TinhOK9WnTDmG7KeE5p2ypAnNepTpi5hirWB4g1/yA1rat+96PIv8PsPf+X16P8Qa/wCQWtbVv3vR5Afu+w9/5fXpyypX85+IviL9X58kySfv7VKi+z3jF/zfzS+zsveu4+1g8Le1Sp8kNCU8LTwnFPC1/L1Ome7zDVWnheKeq08JxXqU6YuYaEp4XnvTwlPCc9K9SnTDmGKvNPVKeqc9Keqe1erTphzDAvFSBacE4qQLXqU6YuYaq0u361IqU7Z7V6Uaegcx8cqtPVeKeqU8LX9DU6Z/lJzDQtPCc08JTwnNepTpi5hirT1XjtUipT1TivVp0w5hgXgU8LTwnFPCV6lOmLmGqtPVeKeFp4WvVp0w5hgSpFSnBKkCV6dOmLmGKlPC8U9UqQJxXq06YcxGF6VIF5p4XinhK9SnTDmGKtPC8U8LUipXqU6YuYYErA8Qa/5G61tW/e9HkX+H2Hv79vr0f4g1/wAjda2rfvekkg/h9h7/AMvr05YJX86eIniL9X58kySfv7VKi+z3jF/zfzS+zsveu4+1g8Le1SovRDQlPVKeqU9Ur+XqdM93mGhOKeF5FPCcU8L0r1KdMXMMC809Vp4TmpFSvVp0w5hirxTwlPCU8JXqU6YuYaqU9Up4SnqlepTphzDAvFSBeRTgnFSBa9WnTFzDAvNPVaeE5p6pXqU6YcwwLxUgSnKlSBK9SnTDmGKlSKtOC1IqV6lOmLmGBakC804LUgSvVpUw5hirzT1WnqnNPVK9SnTFzDAvFPCU9U4p4SvUp0w5hoWnqtPC09Vr1adMXMNC08JzTwtPCV6lOmHMMVeaeq1Iqc09Ur1KdMOYjVeKwfEGv+RutbVv3vR5B/D7D3/l9ej9f1/yA1rat+96SSD+H2Hv/L69OWCcV/OniJ4i/V+fJMkn7+1Sovs94xf8380vs7L3ruPs4PC3tUqL0Q0LTwlPCU8JzX8vU6Z7vMMVakC05UqQLXqUqYcwxVqRUpwSpFSvVp0xcwwJxTwvFPVOKeE4r1KdMOYYF5qQLzT9lPCc16lOmLmGKtPC09Vp4WvUp0w5hoSnqlPCU9Ur1adMXMNCcU8LxT1TinhOK9SlTDmGBeaeF5p4XmpAnNepTphzEarUgWnqlPVK9WnTFzDQlPVKeEp6pXqU6YcwwLxTwtPCVIFr1KdMXMMC808LzTwvNPCc16tOmHMMVakC05UqRUr06dMXMMCVIq04JUipXq06YcwwLxWB4g1/yN1rat+96PIP4fYe/wDL69H+INf8jda2rfvekkg/h9h7/wAvr05ZVr+c/EXxF+r8+SZJP39qlRfZ7xi/5v5pfZ2XvXcfZweFvapUWnRDQtPVeaeEp6rzX8vU6Z7vMMVfpT1XipFSnqnFerTphzDAvSnhKeE4p4SvUp0w5hqpT1WnqlPVa9SlTFzDQtPVeaeFp4TmvVp0w5hirT1XinqlPVOK9SnTFzDAtSBKeE4p4SvUp0w5hirUgWnKlSKterTpi5hgWpFWnBKkVK9SnTDmGKlPC8U9Up4TivUp0w5hgXpUgTmnBOKkCV6lOmLmGKtPVeKeqU8LXq0qYuYaFp4SnhKeqV6lOmHMNVKeF4p6pTwnFepTphzDAvSnheaeF4qQJzXq06YuYYq1geINf8jda2rfvekkg/h9h7/y+vR/iDX/ACC1rat+96PIP4PYe/8AL69OWVK/nPxF8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2sHhb2qVFp0QwLUgWnKtSBK/l6nTPd5hirUipTlSpFSvVpUxcwwJTwvIp4TipAvSvUpUw5iMLzUirTwnNPVK9SlTDmGKvFSBacEp4SvVp0xcw0JT1SnqlPVK9SnTDmGhaeF5p4Snha9SnTFzDFXntT1WpFTmnqlepTphzDAvFPCU8JxTwlerTpi5hqpT1SnhKeqV6lKmHMMC1IF5p4Snha9SnTDmGKvPanqtPVOaeqV6tOmLmGBeKkCU5U4qQJXqU6YuYYqVIq04LUipXqU6YcwwLUgXmnBakCV6tOmHMMVKwNf1/yN9rat+96PIP4fYe/8vr0f4g1/yN1rat+96PKP4PYe/wDL69OXVK/nPxF8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2cHhb2qVNuiGBeKeF4p4TinhOK/l6nTPd5hgXmnhKeEp4TmvUp0w5hqpTwtPVKeFr1KdMXMNVaeq08JT1SvVp0w5hgTinheKeE4qQJxXqU6YuYYF5p6rzTwnNPCc16lKmHMMVakC05UqQLXq06YuYYq1IqU4JUipXqU6YcwwJxT9lPCU8JxXqU6YcwwLzUgXmnhOaeE5r1adMXMMVaeFp6pTwtepTphzDQlPVKeEp6pXqU6YuYaE4p4WnhKeEr1KdMOYYF57U9V5qQLzT1TmvVpUxcwxVp4WnqlPCcV6lOmHMNCVgeINf8jda2rfvejyD+H2Hv8Ay+vR3iDX/I3Wtq373o8i/wAPsPf37fXpy4Sv5z8RfEX6vz5Jkk/f2qVF9nvGL/m/ml9nZe9dx9rB4W9qlT5IYqVIEp6pT1Wv5ep0z3eYYEqRV5pwSpAvNerTpi5hir9Keq8U9Up6pxXqU6YuYYF6VIEpwTipAlerSphzDFSnhaeqU9Vr1KdMOYaFp6rTwtSKtepTphzDFWnheKeqU8JxXqU6YuYYF6U8JzTwnSpAnNepTpi5hipT1WnqlPVa9WnTDmGhaeq08LTwlepTpi5hipTwvFPVKkCcV6tOmHMMC9KeF5p4TpTwnNepTphzDFWpAtOVKkVa9SnTFzDAtSKtOCVIqV6tOmHMMVKeE4p6pTwnFepTpi5hm2sHxBr/AJBa1tW/e9HkH8PsPf8Al9ej/EOv+RutbVv3vR5F/h9h7/y+vTlgnSv5z8RfEX6vz5Jkk/f2qVF9nvGL/m/ml9nZe9dx9rB4W9qlTbohgXmnqtPCc1IqV/L1Ome7zDFWnhaeq08LXq06YuYaq09Up4SnqlepTphzDQlPC808JTwnIr1KdMOYYq89qeq09V5p6pXqU6YuYYF4qQLT1TinhK9WnTDmGKtO2/SpFSnbK9GNPQXMfHISnqlPCc09Ur+h6VM/yk5hoSnhOaeEp4SvUp0w5hqpT1TinqlPVOK9SnTFzDAnFPCU8JxTwnSvVp0w5hoTmnqlPCc09Ur06dMXMMCVIE5pwSpAlerTphzDFSpAnFOVKkCcV6lOmLmGBOKeEp4TinhK9SnTDmGBOawPEGv+RutbVv3vR5Afu+w9/wCX16P8Qa99nLWtq373pJID932Hv/L69OXVOa/nTxF8Rfq/PkmST9/apUX2e8Yv+b+aX2dl713H2sHhb2qVPkhipTwlPVKeEr+XqdM9zmGhOaeqU8JT1SvUp0w5hoTinhOlPCcU8JXq06YcwwJzT1TmnhOaeqc16lOmLmGqlPCU9Up4SvUp0w5hoTmnqlPCU9Ur1KdMXMMCcVIE6U4JxUgSvVp0w5hgTmnqnNPCc09U5r1KdMXMMVKkCU5UqQJXqU6YcwwJUipTglSKlerTpi5hipUgSnBOKkCV6lOmHMMVOaeqU8JzT1SvUp0w5hipxTwlPVOKeE4r1adMXMNCU9Up4SnqlepTphzDVSnhKeqcU8JXqU6YuYaqc1ga/r3kb7W1b970eQH7vsPf+X16O8Qa95Ba1tW/e9JJAfu+w9/5fXpy6pX86eIviL9X58kySfv7VKi+z3jF/wA380vs7L3ruPtYPC3tUqfJDFSnhOKeqU8JxX8vU6Z7vMNCdKeE5p4TpTwnNepTpi5hipUipTlSpAnFepTphzDAlSKlOCVIEr1KdMOYYqcU8JxT1SnhOK9WnTFzDNlSBOadsqQJzXqU6YcwxUp6pT1SnqnFerTpi5hoSnqlPCU8JXqU6Ycw1Up4TinqlPCcV6lOmLmGBOaeE5p4TmnhOa9WnTDmGqlPCcU9Up6pxXqU6YcwwJUgSnBKkVK9SnTFzDAlSBOKcqVIE4r1adMOYYE5p4TmnhORTwnNepTpi5hipT1SnqlSKnFepTphzDAlYPiDX/s+61tW/e9HkB+77D3/AJfXo7xBr/kbrW1b970eQfw+w9/5fXpy4Sv5z8RfEX6vz5Jkk/f2qVF9nvGL/m/ml9nZe9dx9nB4W9qlT5IYqU9Up4Snqlfy9Tpnvcw0JTwnNPCU8JzXq06YuYaqU9U4p6pT1TivUp0xcwwJxTwlPCcU8JXqU6Ycw0JTwlPCc09Ur1adMXMMCVIE5pwSpAnNepTphzDFSnqnFPVKeqcV6lOmHMMCcVIEpwTipAlepTpi5hgSpFSnBOakVK9WnTDmGBKkCc04JUipXqU6YuYYqU8JxT1SnhOK9SnTDmGBOKkCU4JxUgSvVp0xcwwJT1SnhOaeqV6lOmHMNCU8JzTwlPCV6lOmHMNVKeE4p6pTwnFerTpi5hgTisHxBr3kFrW1b970eQH7vsPf+X16O8Qa95Aa1tW/e9HkB+77D3/l9enLhOlfzn4i+Iv1fnyTJJ+/tUqL7PeMX/N/NL7Oy967j7WDwt/3lT5IYE5p6pTwnNPVOa/l6nTPd5hipUgSnKlSBK9SnTFzDAnNSKlOVKkVK9SnTDmGBOKeE6U8JxTwnSvVpUxcw0JzT1SnhOaeqc16lOmHMMVKeEp6pTwlepTpi5hoTmnqlPCU9Ur1adMOYaEp4TpTwnFPCV6lOmHMNVOaeqU9U5p6pXq06YuYYqcU8JT1TinhK9SnTDmGhOaeqU8JT1SvUp0xcwwJUgTpTgnFSBK9WnTDmGKnNPVKeqc09Ur1KdMXMMVOKkCU5U4qQJXqU6YcwwJUipTglSKlerTpi5hipWB4g1/yN1rat+96PIP4PYe/8vr0f4g1/wAjda2rfvekkgP3PYe/8vr05YJxX85+IviL9X58kySfv7VKi+z3jF/zfzS+zsveu4+1g8Le1SovRDQlSKlOCU9Ur+XqdM93mGqnFPCcU8JxTwnFepTphzDNlPCc0/ZTwnNepTpi5hqpTwlPVKeE4r1adMOYaEp6pTwlPVK9SnTFzDFTipAnFOVKkCcV6lOmHMMCc08JzTwnNPCc16lOmLmGKlSKlOVKkCcV6lOmHMMCVIqU4JUgSvVp0w5hgTinhKeEp4TivUp0xcw0JzTwnNPCc08JzXq06YuYYqU9Up6pT1TivUp0w5hoSnqlPCU8JXqU6Ycw0JTwlPVKeEr1adMXMNCc09U5p4TmnqnNepTphzDFSsDxBr3kBrW1b970kkB+77D3/l9ej9f17yN9rat+96PID932Hv8Ay+vTllTiv5z8RfEX6vz5Jkk/f2qVF9nvGL/m/ml9nZe9dx9nB4W9qlRadENCcU8JTgnFSBK/l6nTPd5hipUipTglSBK9WnTDmGBakCc04JUipzXqU6YcwxUp6pxT1SnqnFepTpi5hgTipAlOCcVIEr1KdMXMMVKeqU8JT1SvVp0w5hoSpFTmnBKeE5r1KdMOYaqU8JxT1SnhOK9SnTFzDAnFPCc08JxTwlerTphzDQlPCU8JzT1SvUp0xcwwJUipzTglSKlerTphzDFSpAnFOVKkCcV6lOmLmGBOKeE5p4TinhOa9SnTDmGKlSKlOVOakVK9WnTDmGBKkCc04JUipXqU6YuYYqVgeINf8jda2rfvejyL/D7D3/l9ej/EGv8AkbrW1b970eQfw+w9/wCX16csqV/OfiL4i/V+fJMkn7+1Sovs94xf8380vs7L3ruPtYPC3tUqfJDQnFPCU8JxTwnSv5ep0z3eYYE5qRUpwTmpFSvUp0xcwwJTwlPVKeEr1adMOYaqc09Up6pT1SvUp0xcw0JTwlOCVIEr1KdMOYYqc09Up6pzT1SvVp0w5hipxUgSnKnFSBOlepTpi5hgTmnbKkVKdsr0Y09A5j44Uc09RTF609elf0HSR/lOSAdKeoGaYO1SL1r06aEOUU9RxTVp69K9WmIcBxUgFMHSnjrXq00gHqOakUUxetPXpXp0gHgdKkUDNMHanr1r1aaEPUU8Dimr0p46V6dMBwHFZviW9lsdN3Qtsd3CFh1AwTx78VpjpWL4x/5BkX/XYf8AoLV85xniKuF4bxtahJxkoOzTs100fQ6cMlKtFM5EDmnqOaaOtPXrX+e9NH1o9RTwOlMXpUg7V6dIB6gZp6imL1qRelerTQDwOKeAKYOlPHWvUpoB4HNPUc0wdaevWvUpCHqOKkA6UxelPHavVpoRIoGaeopi9aevSvUpiHgcVIAKjHSpB1r1KaAeBzT1HNMHWnr1r1aaAeo4qQDpUa9KkHavUpAPUDNPUU1etPWvVpIQ8DingDNMHSpB1r06aEPUc09RTF609a9WmA9RxTwOlMXpUg7V6tNAPA5p6imDrT1r06Qh4HFZviW9lsdNDQtsd3CFh1AwTx78VpjpWL4x/wCQZF/12H/oLV85xniKuF4bxtahJxkoOzTs100fQ6cMlKtFPuciBzUiimDrT1r/AD2po+tHqOKeBxTF6U8dK9SkA8DpUgHNMHanr1r1aaAeop4HFMWpB0r1KaAeBzUiimDrT1r1KYDwOKeBxTB0p46V6tNIkeBTwOaaOtPHWvTpAPUU8DimLTx0r1aaESAc09RTB1qRa9WmgHgcU8DimDpTx0r1KQDwOaeBzTB1p4616tJAPUVIBxTFp46V6dNCHgDNSKKYOtPWvVpiHqKeBxTF6VIOlerTSAeBzTwOaYOtPHWvTpCHqKzfEl5LY6aGhbY7uELdwME8e/FaS1jeL/8AkFxf9dh/6C1fOcZ4irheG8bWoScZKDs07NdNH0OrDJSrRT7nIgcU8DmmDpUg61/nrTPrR6ingcUxakHSvVpoQ8DpT1AzTB2qRetepTQDlFPUcU1aevSvUpAOA4qQDmmDpUg616tJAPUU9RTFp69K9SmhDwOlSKBmmDtT1616lIQ9RT1HFMWnr0r1aaEPA4qQDmox0qQda9SmA9RT1FNWnr0r1KaAeB0qRRzUY7VIvWvVpoB6ingcUxelPHSvUpCHgcVIBzUY6VIOterSQMeo5p6imL1p69K9OmhEgHSnqBmmDtUi9a9WmA9RWZ4kvJbHTQ0LbGdwhYdQME8e/Faa9KxfF/8AyC4v+uw/9BavnOM69XC8N42tQk4yUHZp2a6aPodOGSlWimciBxUgAzTB0p461/nrSPrh4HNPUUwdaeterTQh6jipAOlRr0qQdq9SmhD1HNSKKYvWnr0r1KQDwOKeAKYOlSDrXq0kA4DmnqOaaOtPXrXqU0A9RxTwOlMXpUg7V6lMQ9QM09RTF61IvSvVppCHgcU8AZpg6VIOtenSEOUc09RTV609a9WmgHKOKkA6UxelPHavVpoCRQM09RTF609elepSAeBxUgAzUY6VIOterSQh6jmnqKYvWnrXp00A9RxUgHSo16VIO1erTEPUDNZviS8lsdO3QtsZ3CFh1AIJ49+K0161i+L/APkGR/8AXYf+gtXznGderheG8bWoScZqDs07NdNH0OnDJSrRT7nIqKeBxTF6VIOlf560j64eBzT1FMHWpFr1aaEPA4p4HFMHSnjpXqU0A8Dmngc0wdakXrXqUhD1FPA4pi9KeOlepTQDwOakUUwdaetepSAeBxTwOKaOlPHSvVpIQ8DmnqOaYOtPXrXqU0A9RTwOKYtSDpXqUxDwOakUUwdaeterTQh4HFPxTB0qSvTpAOA5p4HNNHWnjrXq00A9RTwOKYtPHSvVpoCQDmnqKYOtSLXqUhDwOKeB0pg6U8dq9WmgY8AZrN8SXstjp26FtjO4QsOoGCePfitMdaxfF/8AyDYv+uw/9BavmuNMRVwnDeNrUJOMlB2a0a6aPodGGSlWin3ORUU9RxTFp69K/wA96Z9cPA4qQDmox0qQda9SmkA9RUgHFMWnjpXqUhDwKkUDNMHWnr1r1aaAeop6jimLT16V6lNCHgcVIBzUY6VIOtepSAeop4HFMWpB0r1aSAeB0p6jmmDtUi9a9OmhD1FPA4pi9KeOlerTAeBxTwOaYOlSDrXq00hMeop6imLT16V6dIQ8DpUijmmDtT1616tNAPUU8Dimr0p46V6tNAOA4qQDmmDpTx1r1KQD1FPUU1aevSvVpoQ8DpWZ4lvZbHTgYW2NI4QsOoGCePfitMdqxfGH/INi/wCuw/8AQWr5rjPEVcJw3ja1CTjJQdmtGumj6HThkpVopnJKOaeopi9akXpX+e9M+uHgcU8DmmDpTx1r1KaEPA5p6imDrUi16lIByjipAOlMXpTx2r1aaESKOaeopi9aevSvUpoQ8DpUgAzTB2p4616lIB6jmnqKYvWnrXq00A9RxUgHSo16VIO1enTAeo5p2KRetLXpR2Ez/9k=", + "grande.png": "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", + "haute.png": "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", + "image.BMP": "Qk0gcGFzIHZyYWltZW50IHVuZSBpbWFnZQ==", + "image.webp": "UklGRhAAAABXRUJQVlA4IGZhdXg=", + "petite.png": "iVBORw0KGgoAAAANSUhEUgAAAAoAAAAICAIAAABPmPnhAAAAJUlEQVR4nGJhYGCQZGCUYmDESrIwyDMyMOBELAwKQ1QaEAAA//9xYwI0YqlbiQAAAABJRU5ErkJggg==", + "photo.jpg": "/9j/2wCEAAMCAgMCAgMDAwMEAwMEBQgFBQQEBQoHBwYIDAoMDAsKCwsNDhIQDQ4RDgsLEBYQERMUFRUVDA8XGBYUGBIUFRQBAwQEBQQFCQUFCRQNCw0UFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFP/AABEIABQAKAMBIgACEQEDEQH/xAGiAAABBQEBAQEBAQAAAAAAAAAAAQIDBAUGBwgJCgsQAAIBAwMCBAMFBQQEAAABfQECAwAEEQUSITFBBhNRYQcicRQygZGhCCNCscEVUtHwJDNicoIJChYXGBkaJSYnKCkqNDU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6g4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2drh4uPk5ebn6Onq8fLz9PX29/j5+gEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoLEQACAQIEBAMEBwUEBAABAncAAQIDEQQFITEGEkFRB2FxEyIygQgUQpGhscEJIzNS8BVictEKFiQ04SXxFxgZGiYnKCkqNTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqCg4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2dri4+Tl5ufo6ery8/T19vf4+fr/2gAMAwEAAhEDEQA/APgLTfh10/dfpXWab8Oun7r9K93034ddP3X6V1em/Drp+6/SvyqrxF/ePkcj4x2948I034c9P3X6V1em/Dnp+6/Svd9N+HXT91+ldXpvw56fuv0rxqvEX94/oTI+MdvePCNN+HXT91+laf8Awrr/AKZfpX0fpvw56fuv0rT/AOFdf9Mv0rypcRa/EfueC4x/dL3jiNN0S04/d11em6Jacfu6w9N7V1em9q/P6tSfc/xoyOrU095m7puiWnH7uur03QrTj93WHpvaus03tXjVak+5/QmR1amnvM29N0K04/d1p/2Faf8APOmab2rSryp1J33P3LBVqnsV7zP/2Q==", + "pleine.jpg": "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", + "sous/tres.png": "iVBORw0KGgoAAAANSUhEUgAAAAMAAAADCAIAAADZSiLoAAAAH0lEQVR4nGJhYGAIZWAMZWBkYQhlZGAAIQQLEAAA//8aWAFpD3kcfgAAAABJRU5ErkJggg==", + "texte.txt": "cGFzIHVuZSBpbWFnZQ==", + "tournee.jpg": "/9j/4QAiRXhpZgAATU0AKgAAAAgAAQESAAMAAAABAAYAAAAAAAD/2wCEAAMCAgMCAgMDAwMEAwMEBQgFBQQEBQoHBwYIDAoMDAsKCwsNDhIQDQ4RDgsLEBYQERMUFRUVDA8XGBYUGBIUFRQBAwQEBQQFCQUFCRQNCw0UFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFP/AABEIABQAKAMBIgACEQEDEQH/xAGiAAABBQEBAQEBAQAAAAAAAAAAAQIDBAUGBwgJCgsQAAIBAwMCBAMFBQQEAAABfQECAwAEEQUSITFBBhNRYQcicRQygZGhCCNCscEVUtHwJDNicoIJChYXGBkaJSYnKCkqNDU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6g4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2drh4uPk5ebn6Onq8fLz9PX29/j5+gEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoLEQACAQIEBAMEBwUEBAABAncAAQIDEQQFITEGEkFRB2FxEyIygQgUQpGhscEJIzNS8BVictEKFiQ04SXxFxgZGiYnKCkqNTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqCg4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2dri4+Tl5ufo6ery8/T19vf4+fr/2gAMAwEAAhEDEQA/APgLTfh10/dfpXWab8Oun7r9K93034ddP3X6V1em/Drp+6/SvyqrxF/ePkcj4x2948I034c9P3X6V1em/Dnp+6/Svd9N+HXT91+ldXpvw56fuv0rxqvEX94/oTI+MdvePCNN+HXT91+laf8Awrr/AKZfpX0fpvw56fuv0rT/AOFdf9Mv0rypcRa/EfueC4x/dL3jiNN0S04/d11em6Jacfu6w9N7V1em9q/P6tSfc/xoyOrU095m7puiWnH7uur03QrTj93WHpvaus03tXjVak+5/QmR1amnvM29N0K04/d1p/2Faf8APOmab2rSryp1J33P3LBVqnsV7zP/2Q==", + "vide.png": "" + }, + "steps": [ + { + "name": "sans vision", + "tool": "see_image", + "args": { + "file": "petite.png" + }, + "label": "petite.png", + "result": "[erreur] la vision n'est pas active sur ce preset (aucun projecteur MMPROJ configuré) — impossible de voir une image", + "probes": 0 + }, + { + "name": "chemin manquant", + "vision": true, + "tool": "see_image", + "args": { + "file": " " + }, + "label": " ", + "result": "[erreur] format non reconnu comme image (attendu : png, jpg, gif, webp, bmp) : ", + "probes": 0 + }, + { + "name": "pas une image", + "vision": true, + "tool": "see_image", + "args": { + "file": "texte.txt" + }, + "label": "texte.txt", + "result": "[erreur] format non reconnu comme image (attendu : png, jpg, gif, webp, bmp) : texte.txt", + "probes": 0 + }, + { + "name": "introuvable", + "vision": true, + "tool": "see_image", + "args": { + "file": "absente.png" + }, + "label": "absente.png", + "result": "[erreur] fichier introuvable : absente.png", + "probes": 0 + }, + { + "name": "dossier", + "vision": true, + "tool": "see_image", + "args": { + "file": "dossier.png" + }, + "label": "dossier.png", + "result": "[erreur] c'est un dossier, pas une image : dossier.png", + "probes": 0 + }, + { + "name": "trop lourde", + "vision": true, + "tool": "see_image", + "args": { + "file": "lourd.png" + }, + "label": "lourd.png", + "result": "[erreur] image trop lourde (13 Mo, max 12 Mo) : lourd.png", + "probes": 0 + }, + { + "name": "le moteur ne voit pas", + "vision": true, + "tool": "see_image", + "args": { + "file": "petite.png" + }, + "label": "petite.png", + "result": "[erreur] le moteur en service ne traite pas les images (projecteur non chargé ?) — impossible de voir petite.png", + "probes": 1 + }, + { + "name": "vide", + "vision": true, + "sees": true, + "tool": "see_image", + "args": { + "file": "vide.png" + }, + "label": "vide.png", + "result": "[erreur] fichier vide : vide.png", + "probes": 1 + }, + { + "name": "voir petite.png", + "vision": true, + "sees": true, + "tool": "see_image", + "args": { + "file": "petite.png" + }, + "label": "petite.png", + "result": "[ok] image chargée : petite.png\n[relais] Image demandée (petite.png) :", + "part": { + "mime": "image/png", + "same_as": "petite.png" + }, + "probes": 1 + }, + { + "name": "voir grande.png", + "vision": true, + "sees": true, + "tool": "see_image", + "args": { + "file": "grande.png" + }, + "label": "grande.png", + "result": "[ok] image chargée : grande.png\n[relais] Image demandée (grande.png) :", + "part": { + "h": 784, + "mime": "image/png", + "px": { + "0,0": "0,0,0,255", + "1,1": "0,0,2,255", + "100,50": "16,16,190,255", + "1567,783": "254,254,181,255", + "784,261": "127,84,52,255" + }, + "w": 1568 + }, + "probes": 1 + }, + { + "name": "voir haute.png", + "vision": true, + "sees": true, + "tool": "see_image", + "args": { + "file": "haute.png" + }, + "label": "haute.png", + "result": "[ok] image chargée : haute.png\n[relais] Image demandée (haute.png) :", + "part": { + "h": 1568, + "mime": "image/png", + "px": { + "0,0": "0,0,0,255", + "1,1": "0,0,2,255", + "100,50": "91,8,162,255", + "138,522": "126,84,202,255", + "276,1567": "253,254,205,255" + }, + "w": 277 + }, + "probes": 1 + }, + { + "name": "voir photo.jpg", + "vision": true, + "sees": true, + "tool": "see_image", + "args": { + "file": "photo.jpg" + }, + "label": "photo.jpg", + "result": "[ok] image chargée : photo.jpg\n[relais] Image demandée (photo.jpg) :", + "part": { + "mime": "image/jpeg", + "same_as": "photo.jpg" + }, + "probes": 1 + }, + { + "name": "voir tournee.jpg", + "vision": true, + "sees": true, + "tool": "see_image", + "args": { + "file": "tournee.jpg" + }, + "label": "tournee.jpg", + "result": "[ok] image chargée : tournee.jpg\n[relais] Image demandée (tournee.jpg) :", + "part": { + "h": 40, + "mime": "image/jpeg", + "w": 20 + }, + "probes": 1 + }, + { + "name": "voir grande.jpeg", + "vision": true, + "sees": true, + "tool": "see_image", + "args": { + "file": "grande.jpeg" + }, + "label": "grande.jpeg", + "result": "[ok] image chargée : grande.jpeg\n[relais] Image demandée (grande.jpeg) :", + "part": { + "h": 784, + "mime": "image/jpeg", + "w": 1568 + }, + "probes": 1 + }, + { + "name": "voir anim.gif", + "vision": true, + "sees": true, + "tool": "see_image", + "args": { + "file": "anim.gif" + }, + "label": "anim.gif", + "result": "[ok] image chargée : anim.gif\n[relais] Image demandée (anim.gif) :", + "part": { + "mime": "image/gif", + "same_as": "anim.gif" + }, + "probes": 1 + }, + { + "name": "voir image.webp", + "vision": true, + "sees": true, + "tool": "see_image", + "args": { + "file": "image.webp" + }, + "label": "image.webp", + "result": "[ok] image chargée : image.webp\n[relais] Image demandée (image.webp) :", + "part": { + "mime": "image/webp", + "same_as": "image.webp" + }, + "probes": 1 + }, + { + "name": "voir image.BMP", + "vision": true, + "sees": true, + "tool": "see_image", + "args": { + "file": "image.BMP" + }, + "label": "image.BMP", + "result": "[ok] image chargée : image.BMP\n[relais] Image demandée (image.BMP) :", + "part": { + "mime": "image/bmp", + "same_as": "image.BMP" + }, + "probes": 1 + }, + { + "name": "voir cassee.png", + "vision": true, + "sees": true, + "tool": "see_image", + "args": { + "file": "cassee.png" + }, + "label": "cassee.png", + "result": "[ok] image chargée : cassee.png\n[relais] Image demandée (cassee.png) :", + "part": { + "mime": "image/png", + "same_as": "cassee.png" + }, + "probes": 1 + }, + { + "name": "voir sous/tres.png", + "vision": true, + "sees": true, + "tool": "see_image", + "args": { + "file": "sous/tres.png" + }, + "label": "sous/tres.png", + "result": "[ok] image chargée : tres.png\n[relais] Image demandée (sous/tres.png) :", + "part": { + "mime": "image/png", + "same_as": "sous/tres.png" + }, + "probes": 1 + }, + { + "name": "chemin absolu", + "vision": true, + "sees": true, + "tool": "see_image", + "args": { + "file": "{{FICHIERS}}/petite.png" + }, + "label": "{{FICHIERS}}/petite.png", + "result": "[ok] image chargée : petite.png\n[relais] Image demandée ({{FICHIERS}}/petite.png) :", + "part": { + "mime": "image/png", + "same_as": "petite.png" + }, + "probes": 1 + }, + { + "name": "capture sans url", + "tool": "web_screenshot", + "args": {}, + "label": "", + "result": "[erreur] url manquante", + "probes": 0 + }, + { + "name": "url invalide", + "tool": "web_screenshot", + "args": { + "url": "ftp://x" + }, + "label": "", + "result": "[erreur] url invalide : elle doit commencer par http:// ou https://", + "probes": 0 + }, + { + "name": "internet coupé", + "tool": "web_screenshot", + "args": { + "url": "https://exemple.test/" + }, + "label": "", + "result": "[refusé] L'accès internet est coupé : la capture ne marche que sur une adresse locale (localhost / 127.0.0.1), par exemple ton serveur de dev. Active l'accès internet pour le web.", + "probes": 0 + }, + { + "name": "capture locale sans vision", + "image": "capture.jpg", + "tool": "web_screenshot", + "args": { + "url": "http://localhost:3000/app?x=1" + }, + "label": "", + "result": "Capture enregistrée (captures/localhost-3000-{{T}}.jpg, 74 Ko).\nPour la montrer à l'utilisateur, recopie TELLE QUELLE cette ligne markdown dans ta réponse :\n![capture de localhost:3000](/api/chat/image?path=captures/localhost-3000-{{T}}.jpg)", + "shown": "captures/localhost-3000-{{T}}.jpg", + "pw_args": [ + "screenshot", + "--browser", + "chromium", + "--viewport-size", + "1280,800", + "--wait-for-timeout", + "3500", + "http://localhost:3000/app?x=1", + "{{CAPTURES}}/localhost-3000-{{T}}.jpg" + ], + "probes": 0, + "captures": [ + "localhost-3000-{{T}}.jpg" + ] + }, + { + "name": "capture vue par le modèle", + "vision": true, + "sees": true, + "image": "capture.jpg", + "internet": true, + "tool": "web_screenshot", + "args": { + "url": "https://www.exemple.test/page#ancre", + "width": 1600 + }, + "label": "", + "result": "Capture enregistrée (captures/www.exemple.test-{{T}}.jpg, 74 Ko).\nPour la montrer à l'utilisateur, recopie TELLE QUELLE cette ligne markdown dans ta réponse :\n![capture de www.exemple.test](/api/chat/image?path=captures/www.exemple.test-{{T}}.jpg)\n[relais] Voici la capture demandée.", + "part": { + "mime": "image/jpeg", + "same_as": "capture.jpg" + }, + "shown": "captures/www.exemple.test-{{T}}.jpg", + "pw_args": [ + "screenshot", + "--browser", + "chromium", + "--viewport-size", + "1600,800", + "--wait-for-timeout", + "3500", + "https://www.exemple.test/page#ancre", + "{{CAPTURES}}/www.exemple.test-{{T}}.jpg" + ], + "probes": 1, + "captures": [ + "localhost-3000-{{T}}.jpg", + "www.exemple.test-{{T}}.jpg" + ] + }, + { + "name": "page entière réduite", + "vision": true, + "sees": true, + "image": "pleine.jpg", + "internet": true, + "tool": "web_screenshot", + "args": { + "full_page": true, + "url": "https://pleine.test/", + "width": 100 + }, + "label": "", + "result": "Capture enregistrée (captures/pleine.test-{{T}}.jpg, 253 Ko).\nPour la montrer à l'utilisateur, recopie TELLE QUELLE cette ligne markdown dans ta réponse :\n![capture de pleine.test](/api/chat/image?path=captures/pleine.test-{{T}}.jpg)\n[relais] Voici la capture demandée.", + "part": { + "h": 1568, + "mime": "image/jpeg", + "w": 669 + }, + "shown": "captures/pleine.test-{{T}}.jpg", + "pw_args": [ + "screenshot", + "--browser", + "chromium", + "--viewport-size", + "1280,800", + "--wait-for-timeout", + "3500", + "--full-page", + "https://pleine.test/", + "{{CAPTURES}}/pleine.test-{{T}}.jpg" + ], + "probes": 1, + "captures": [ + "localhost-3000-{{T}}.jpg", + "pleine.test-{{T}}.jpg", + "www.exemple.test-{{T}}.jpg" + ] + }, + { + "name": "vision mais moteur aveugle", + "vision": true, + "image": "capture.png", + "internet": true, + "tool": "web_screenshot", + "args": { + "url": "https://aveugle.test/" + }, + "label": "", + "result": "Capture enregistrée (captures/aveugle.test-{{T}}.jpg, 0 Ko).\nPour la montrer à l'utilisateur, recopie TELLE QUELLE cette ligne markdown dans ta réponse :\n![capture de aveugle.test](/api/chat/image?path=captures/aveugle.test-{{T}}.jpg)", + "shown": "captures/aveugle.test-{{T}}.jpg", + "pw_args": [ + "screenshot", + "--browser", + "chromium", + "--viewport-size", + "1280,800", + "--wait-for-timeout", + "3500", + "https://aveugle.test/", + "{{CAPTURES}}/aveugle.test-{{T}}.jpg" + ], + "probes": 1, + "captures": [ + "aveugle.test-{{T}}.jpg", + "localhost-3000-{{T}}.jpg", + "pleine.test-{{T}}.jpg", + "www.exemple.test-{{T}}.jpg" + ] + }, + { + "name": "Playwright en échec", + "mode": "echec", + "internet": true, + "tool": "web_screenshot", + "args": { + "url": "https://x.test/" + }, + "label": "", + "result": "[erreur] capture impossible : page.goto: net::ERR_NAME_NOT_RESOLVED at https://x · Call log: · - navigating", + "pw_args": [ + "screenshot", + "--browser", + "chromium", + "--viewport-size", + "1280,800", + "--wait-for-timeout", + "3500", + "https://x.test/", + "{{CAPTURES}}/x.test-{{T}}.jpg" + ], + "probes": 0, + "captures": [ + "aveugle.test-{{T}}.jpg", + "localhost-3000-{{T}}.jpg", + "pleine.test-{{T}}.jpg", + "www.exemple.test-{{T}}.jpg" + ] + }, + { + "name": "image vide", + "mode": "vide", + "internet": true, + "tool": "web_screenshot", + "args": { + "url": "https://vide.test/" + }, + "label": "", + "result": "[erreur] Playwright n'a produit aucune image", + "pw_args": [ + "screenshot", + "--browser", + "chromium", + "--viewport-size", + "1280,800", + "--wait-for-timeout", + "3500", + "https://vide.test/", + "{{CAPTURES}}/vide.test-{{T}}.jpg" + ], + "probes": 0, + "captures": [ + "aveugle.test-{{T}}.jpg", + "localhost-3000-{{T}}.jpg", + "pleine.test-{{T}}.jpg", + "vide.test-{{T}}.jpg", + "www.exemple.test-{{T}}.jpg" + ] + }, + { + "name": "aucune image", + "mode": "rien", + "internet": true, + "tool": "web_screenshot", + "args": { + "url": "https://rien.test/" + }, + "label": "", + "result": "[erreur] Playwright n'a produit aucune image", + "pw_args": [ + "screenshot", + "--browser", + "chromium", + "--viewport-size", + "1280,800", + "--wait-for-timeout", + "3500", + "https://rien.test/", + "{{CAPTURES}}/rien.test-{{T}}.jpg" + ], + "probes": 0, + "captures": [ + "aveugle.test-{{T}}.jpg", + "localhost-3000-{{T}}.jpg", + "pleine.test-{{T}}.jpg", + "vide.test-{{T}}.jpg", + "www.exemple.test-{{T}}.jpg" + ] + }, + { + "name": "ménage des captures", + "image": "capture.png", + "internet": true, + "tool": "web_screenshot", + "args": { + "url": "http://127.0.0.1:8080/" + }, + "label": "", + "result": "Capture enregistrée (captures/127.0.0.1-8080-{{T}}.jpg, 0 Ko).\nPour la montrer à l'utilisateur, recopie TELLE QUELLE cette ligne markdown dans ta réponse :\n![capture de 127.0.0.1:8080](/api/chat/image?path=captures/127.0.0.1-8080-{{T}}.jpg)", + "shown": "captures/127.0.0.1-8080-{{T}}.jpg", + "pw_args": [ + "screenshot", + "--browser", + "chromium", + "--viewport-size", + "1280,800", + "--wait-for-timeout", + "3500", + "http://127.0.0.1:8080/", + "{{CAPTURES}}/127.0.0.1-8080-{{T}}.jpg" + ], + "probes": 0, + "captures": [ + "127.0.0.1-8080-{{T}}.jpg", + "aveugle.test-{{T}}.jpg", + "localhost-3000-{{T}}.jpg", + "pleine.test-{{T}}.jpg", + "vide.test-{{T}}.jpg", + "vieille-08.jpg", + "vieille-09.jpg", + "vieille-10.jpg", + "vieille-11.jpg", + "vieille-12.jpg", + "vieille-13.jpg", + "vieille-14.jpg", + "vieille-15.jpg", + "vieille-16.jpg", + "vieille-17.jpg", + "vieille-18.jpg", + "vieille-19.jpg", + "vieille-20.jpg", + "vieille-21.jpg", + "www.exemple.test-{{T}}.jpg" + ] + } + ] +}