diff --git a/Java/M1-code/gctx.ml.txt b/Java/M1-code/gctx.ml.txt new file mode 100644 index 0000000..f8a5764 --- /dev/null +++ b/Java/M1-code/gctx.ml.txt @@ -0,0 +1,303 @@ +(** The "Graphics Context" component of the GUI library. *) + +(** A graphics context represents a portion of the window to which + widgets will be drawn. + + The drawing primitives in this module are all relative to the + graphics context. This means that when a widget needs to draw on the + screen, it need not know its absolute position. The graphics context + is responsible for translating the relative positions passed into the + drawing routines into absolute positions on the screen. + + The graphics context also includes other information for basic + drawing (such as the current pen color.) + + Note that this module defines a persistent (immutable) data + structure. The operations here use a given graphics context to create + a new one with the specified characteristics. They do not modify + their arguments. *) + + +(****************) +(** {1 Colors } *) +(****************) + +(** A type for colors *) +type color = {r:int; g:int; b:int} + +let black : color = {r=0; g=0; b=0} +let white : color = {r=255;g=255;b=255} +let red : color = {r=255;g=0; b=0} +let green : color = {r=0; g=255;b=0} +let blue : color = {r=0; g=0; b=255} +let yellow : color = {r=255;g=255;b=0} +let cyan : color = {r=0; g=255;b=255} +let magenta : color = {r=255;g=0; b=255} + + +(*******************************) +(** Basic Gctx operations *) +(*******************************) + +(** The main type of graphics contexts. Note that none of the components + are mutable. *) +(* TODO: You will need to modify this type definition for Task 5. *) +type gctx = { + x: int; (** offset from (0,0) in local coordinates *) + y: int; + color: color; (** the current pen color *) +} + + +(* has the graphics window been opened already? *) +let graphics_opened = { contents = false; } +(** Open the graphics window, but only do it once *) +let open_graphics () = + if not graphics_opened.contents then + begin + graphics_opened.contents <- true; + Graphics.open_graph ""; (* open the window *) + Graphics.auto_synchronize false; (* don't draw immediately *) + Graphics.clear_graph (); + Graphics.synchronize () + end + +(** The top-level graphics context. *) +let top_level : gctx = + { x = 0; + y = 0; + color = black; + } + +(** Widgets can translate (move) a graphics context to obtain an +appropriate graphics context for their children. *) + +(** Shift the gctx by (dx,dy) *) +let translate (g: gctx) ((dx, dy): int * int) : gctx = + { g with x = g.x + dx; y = g.y + dy } + +(** Produce a new Gctx.t with a different pen color *) +let with_color (g: gctx) (c: color) : gctx = + { g with color = c } + + +(** Set the OCaml graphics library's internal state so that it +agrees with the Gctx settings. + +Initially, this just sets the current pen color. +*) +(* TODO: You will need to modify this definition for Task 5. *) +let set_graphics_state (gc: gctx) : unit = + let {r;g;b} = gc.color in + Graphics.set_color (Graphics.rgb r g b) + + +(************************************) +(* Coordinate Transformations *) +(************************************) + +(* The default width and height of the graphics window that OCaml opens. *) + +let graphics_size_x () = + if graphics_opened.contents then Graphics.size_x () else 600 +let graphics_size_y () = + if graphics_opened.contents then Graphics.size_y () else 450 + +(* A main purpose of the graphics context is to provide mapping between *) +(* widget-local coordinates and the ocaml coordinates of the graphics *) +(* library. Part of that translation comes from the offset stored in the *) +(* graphics context itself. The translation needs to know where the widget *) +(* is on the screen. The other part of the translation is the y axis flip. *) +(* The OCaml library puts (0,0) at the bottom left corner of the window. *) +(* We'd like our GUI library to put (0,0) at the top left corner and *) +(* increase the y-coordinate as we go *down* the screen. *) + +(** A widget-relative position *) +type position = int * int + +(* ALWAYS call these functions before passing widget-local points to the *) +(* OCaml native Graphics module or vice-versa. *) + +(** Convert widget-local coordinates (x,y) to OCaml graphics + coordinates, relative to the graphics context. *) +let ocaml_coords (g: gctx) ((x, y): position) : (int * int) = + (g.x + x, graphics_size_y () - 1 - (g.y + y)) + +(** Convert OCaml Graphics coordinates (x,y) to widget-local graphics + coordinates, relative to the graphics context *) +let local_coords (g: gctx) ((x, y): int * int) : position = + (x - g.x, (graphics_size_y () - 1 - y) - g.y) + + + +(*****************) +(** {1 Drawing } *) +(*****************) + +(** A width and height, paired together. *) +type dimension = int * int + +(* Each of these functions takes inputs in widget-local coordinates, *) +(* converts them to OCaml coordinates, and then draws the appropriate *) +(* shape. *) + +(** Draw a line between the two specified positions *) +let draw_line (g: gctx) (p1: position) (p2: position) : unit = + set_graphics_state g; + let (x1, y1) = ocaml_coords g p1 in + let (x2, y2) = ocaml_coords g p2 in + Graphics.moveto x1 y1; + Graphics.lineto x2 y2 + +(** Display text at the given position *) +let draw_string (g: gctx) (p: position) (s: string) : unit = + set_graphics_state g; + let (_, height) = Graphics.text_size s in + let (x, y) = ocaml_coords g p in + (* subtract: working with Ocaml coordinates *) + Graphics.moveto x (y - height); + Graphics.draw_string s + +(** Display a rectangle with lower-left corner at position + with the specified dimension. *) +(* TODO: you will need to make this function actually draw a + rectangle for Task 0. *) +let draw_rect (g: gctx) (p1: position) ((w, h): dimension) : unit = + failwith "Gctx.draw_rect: unimplemented" + +(** Display a filled rectangle with lower-left corner at positions + with the specified dimension. *) +let fill_rect (g: gctx) (p1: position) ((w, h): dimension) : unit = + set_graphics_state g; + let (x, y) = ocaml_coords g p1 in + Graphics.fill_rect x y w h + +(** Draw an ellipse at the given position with the given radii *) +(* TODO: you will need to make this function actually draw an + ellipse for Task 0. *) +let draw_ellipse (g: gctx) (p: position) (rx: int) (ry: int) : unit = + failwith "Gctx.draw_ellipse: unimplemented" + + +(** Calculates the size of a text when rendered. *) +let text_size (text: string) : dimension = + (* Make sure that the graphics window has been opened. All of the other functions + require a graphics context, which is difficult to get without opening the graphics + window first. But this one does not, so is a source of subtle bugs. *) + open_graphics (); + Graphics.text_size text + +(* TODO: You will need to add several "wrapped" versions of ocaml graphics *) +(* functions here for Tasks 2, 4, and possibly 5 and 6 *) + + +(************************) +(** {1 Event Handling } *) +(************************) + +(* This part of the module adapts OCaml's native event handling to *) +(* something that more closely resembles that found in Java. *) + +(** Types of events that could occur *) +type event_type = + | KeyPress of char (* Key pressed on the keyboard. *) + | MouseDown (* Mouse button pressed. *) + | MouseUp (* Mouse button released. *) + | MouseMove (* Mouse moved with the button up. *) + | MouseDrag (* Mouse moved with the button down. *) + + +let string_of_event_type (et : event_type) : string = + begin match et with + | KeyPress k -> "KeyPress at " ^ (String.make 1 k) + | MouseDrag -> "MouseDrag" + | MouseMove -> "MouseMove" + | MouseUp -> "MouseUp" + | MouseDown -> "MouseDown" + end + + +(** An event records its type and the widget-local position of + the mouse when the event occurred. *) +type event = event_type * position + +(** Accessor for the type of an event. *) +let event_type (e: event) : event_type = + fst e + + +(** Accessor for the widget local position of an event. *) +let event_pos (e: event) (g : gctx) : position = + local_coords g (snd e) + +(** Convert an event to a string *) +let string_of_event ((ty, (x, y)): event) : string = + (string_of_event_type ty) ^ " at " ^ (string_of_int x) ^ "," + ^ (string_of_int y) + +(** Make a dummy event for testing. *) +let make_test_event (et : event_type) ((x, y) : position) = + (et, (x, graphics_size_y () - y)) + + +let string_of_status (s: Graphics.status) : string = + "(" ^ (string_of_int s.Graphics.mouse_x) ^ "," + ^ (string_of_int s.Graphics.mouse_y) ^ ") b:" + ^ (string_of_bool s.Graphics.button) + ^ (if s.Graphics.keypressed + then "k:" ^ (String.make 1 s.Graphics.key) + else "") + +(* The last function is used by the eventloop to get the next *) +(* event from the graphics library. The events reported by the *) +(* library are not as informative as we would like, so this *) +(* function also processes them into a more convenient form. *) +(* You don't need to understand how this processing works, but *) +(* you do need to understand the various forms of events that *) +(* this function generates. *) + +(** Wait for a mouse or key event. *) +let wait_for_event : unit -> event = + + let initial_status : Graphics.status = + { Graphics.mouse_x =0; + Graphics.mouse_y =0; + Graphics.key = ' '; + Graphics.button = false; + Graphics.keypressed = false } in + + let last_status = ref initial_status in + + let compute_rich_event + (s0 : Graphics.status) + (s1 : Graphics.status) : event_type option = + + if s1.Graphics.keypressed then Some (KeyPress s1.Graphics.key) + else if s0.Graphics.button <> s1.Graphics.button then + (* change in button state *) + begin + if s1.Graphics.button then Some MouseDown else Some MouseUp + end + else if (s0.Graphics.mouse_x <> s1.Graphics.mouse_x ) || + (s0.Graphics.mouse_y <> s1.Graphics.mouse_y ) then + (* mouse motion *) + begin + if s1.Graphics.button then Some MouseDrag else Some MouseMove + end + else None in + + fun () -> + let rec loop () = + let status = Graphics.wait_next_event + [Graphics.Mouse_motion; Graphics.Button_down; + Graphics.Button_up; Graphics.Key_pressed] in + let event_type = compute_rich_event !last_status status in + begin match event_type with + | None -> (last_status := status; loop ()) + | Some ty -> + (last_status := status; + let event = (ty, (status.Graphics.mouse_x, + status.Graphics.mouse_y)) in + event) + end in + loop () diff --git a/Java/M1-code/q.ml.txt b/Java/M1-code/q.ml.txt new file mode 100644 index 0000000..ad763a4 --- /dev/null +++ b/Java/M1-code/q.ml.txt @@ -0,0 +1,194 @@ +;; open Assert +;; stop_on_failure () + +module type QUEUE = sig + (* type of the data structure *) + type 'a queue + + (* Make a new, empty queue *) + val create : unit -> 'a queue + + (* Determine if the queue is empty *) + val is_empty : 'a queue -> bool + + (* Add a value to the end of the queue *) + val enq : 'a -> 'a queue -> unit + + (* Remove the first value (if any) and return it *) + val deq : 'a queue -> 'a + + (* Queue length *) + val length : 'a queue -> int +end + + +module Queue : QUEUE = struct + (* INVARIANT: q : 'a queue is a well-formed queue if + (1) q.head and q.tail are both None, or + (2) q.head is Some n1 and q.tail is Some n2 and + - n2 is reachable from n1 following 'next' references + - n2.next is None *) + type 'a qnode = { + v : 'a; + mutable next : 'a qnode option; + } + + type 'a queue = { + mutable head : 'a qnode option; + mutable tail : 'a qnode option; + } + + (* ----- a cyclic queue ----- *) + + + let cycle : int queue = + let qn = { v = 1; next = None } in + let q = { head = Some qn; tail = Some qn } in + qn.next <- q.head; + q + + let test () : bool = + cycle == cycle + ;; run_test "q == q" test + +(* + let test () : bool = + cycle = cycle + ;; run_test "cycle = cycle: infinite loop" test +*) + + (* ------ general queue operations ------- *) + + let create () = + { head = None; tail = None; } + + + let is_empty (q : 'a queue) : bool = + q.head = None (* && q.tail = None *) + + let enq (x : 'a) (q : 'a queue) : unit = + let qno = Some { v = x; next = None } in + begin match q.tail with + | None -> + q.head <- qno; + q.tail <- qno + | Some qn2 -> + q.tail <- qno; + qn2.next <- qno + end + + let deq (q : 'a queue) : 'a = + begin match q.head with + | None -> failwith "deq: queue empty" + | Some qn -> + q.head <- qn.next; + if qn.next = None then q.tail <- None; + qn.v + end + +;; run_test "d1" (fun () -> + let q = create () in + enq 1 q; + 1 = deq q) + +;; run_test "d2" (fun () -> + let q = create () in + enq 1 q; + enq 2 q; + ignore (deq q); + 2 = deq q) + +;; run_test "d3" (fun () -> + let q = create () in + enq 1 q; + ignore (deq q); + enq 2 q; + 2 = deq q) + + let rec length (q: 'a queue) : int = + let rec loop (qno : 'a qnode option) (acc:int) : int = + begin match qno with + | Some qn -> loop qn.next (1 + acc) + | None -> acc + end + in + + loop q.head 0 + +;; run_test "length empty" (fun () -> + let q = create () in + length q = 0) + +;; run_test "length" (fun () -> + let q = create () in + enq 1 q; + enq 2 q; + length q = 2) + +end + +;; open Queue + +let test () : bool = + is_empty (create ()) +;; run_test "create empty" test + +let test () : bool = + let q1 = create () in + let q2 = create () in + not (q1 == q2) +;; run_test "create distinct queues" test + +let test () : bool = + let q = create () in + enq 1 q; + not (is_empty q) +;; run_test "create; enq nonempty" test + + +let test () : bool = + let q : int queue = create () in + enq 1 q; + enq 2 q; + 1 = deq q +;; run_test "deq first" test + +let test () : bool = + let q : int queue = create () in + enq 1 q; + enq 2 q; + let _ = deq q in + 2 = deq q +;; run_test "deq second" test + +let test () : bool = + let q : int queue = create () in + enq 1 q; + enq 2 q; + let _ = deq q in + enq 3 q; + let _ = deq q in + 3 = deq q +;; run_test "enq enq deq enq deq deq" test + +let test () : bool = + let q : int queue = create () in + enq 1 q; + let _ = deq q in + enq 2 q; + 2 = deq q +;; run_test "enq after deq" test + +let test () : bool = + let q : int queue = create () in + let _ = deq q in + false +;; run_failing_test "deq of empty should fail" test + + +let test () : bool = + let q : int queue = create () in + enq 2 q; + let _ = deq q in + is_empty q +;; run_test "enq then deq leaves empty" test diff --git a/Java/M1-code/q2.ml.txt b/Java/M1-code/q2.ml.txt new file mode 100644 index 0000000..f874112 --- /dev/null +++ b/Java/M1-code/q2.ml.txt @@ -0,0 +1,238 @@ +;; open Assert +;; stop_on_failure () + +module type QUEUE = sig + (* type of the data structure *) + type 'a queue + + (* Make a new, empty queue *) + val create : unit -> 'a queue + + (* Determine if the queue is empty *) + val is_empty : 'a queue -> bool + + (* Add a value to the end of the queue *) + val enq : 'a -> 'a queue -> unit + + (* Remove the first value (if any) and return it *) + val deq : 'a queue -> 'a + + (* Queue length *) + val length : 'a queue -> int + + val to_list : 'a queue -> 'a list + val print : 'a queue -> ('a -> string) -> unit +end + + +module Queue : QUEUE = struct + (* Queue INVARIANT: + Either (1) q.head and q.tail are both None + or (2) q.head is Some n1 and q.tail is Some n2 + and n2 is reachable from n1 following .next + and n2.next is None + *) + type 'a qnode = { v : 'a + ; mutable next : 'a qnode option } + + type 'a queue = { mutable head : 'a qnode option + ; mutable tail : 'a qnode option } + + + + + + + + +(* ----- an ill-formed cyclic queue value ----- *) + + let cycle : int queue = + let qn = { v = 1; next = None } in + let q = { head = Some qn; tail = Some qn } in + qn.next <- q.head; + q + + let test () : bool = + cycle == cycle + ;; run_test "q == q" test + +(* + let test () : bool = + cycle = cycle + ;; run_test "cycle = cycle: infinite loop" test +*) + + (* ------ general queue operations ------- *) + + let create () = + { head = None; tail = None } + + let is_empty (q : 'a queue) : bool = + q.head = None + + let enq (x : 'a) (q : 'a queue) : unit = + let newnode = {v = x; next = None} in + begin match q.tail with + | None -> + q.head <- Some newnode; + q.tail <- Some newnode + | Some nt -> + nt.next <- Some newnode; + q.tail <- Some newnode + end + + let deq (q : 'a queue) : 'a = + begin match q.head with + | None -> failwith "empty queue" + | Some n -> + q.head <- n.next; + if q.head = None then begin q.tail <- None; q.tail <- None end; + n.v + end + + +;; run_test "d1" (fun () -> + let q = create () in + enq 1 q; + 1 = deq q) + +;; run_test "d2" (fun () -> + let q = create () in + enq 1 q; + enq 2 q; + ignore (deq q); + 2 = deq q) + +;; run_test "d3" (fun () -> + let q = create () in + enq 1 q; + ignore (deq q); + enq 2 q; + 2 = deq q) + + + + + let length (q: 'a queue) : int = + let rec loop (qn : 'a qnode option) : int = + begin match qn with + | None -> 0 + | Some n -> 1 + (loop n.next) + end + in + loop q.head + + + +;; run_test "length empty" (fun () -> + let q = create () in + length q = 0) + +;; run_test "length" (fun () -> + let q = create () in + enq 1 q; + enq 2 q; + length q = 2) + + + let to_list (q: 'a queue) : 'q list = + let rec loop (qn:'a qnode option) (l:'a list) : 'a list = + begin match qn with + | None -> List.rev l + | Some n -> loop n.next (n.v :: l) + end + in + loop q.head [] + + let print (q: 'a queue) (str_of_a: 'a -> string) : unit = + let rec loop (qn: 'a qnode option) : unit = + begin match qn with + | None -> () + | Some n -> print_endline (str_of_a n.v); loop n.next + end + in + print_endline "\n---- q contents ----"; + loop q.head; + print_endline "------- done -------" + +end + +(* ------- TEST CASES ------- *) + +;; open Queue + +let test () : bool = + is_empty (create ()) +;; run_test "create empty" test + +let test () : bool = + let q1 = create () in + let q2 = create () in + not (q1 == q2) +;; run_test "create distinct queues" test + +let test () : bool = + let q = create () in + enq 1 q; + not (is_empty q) +;; run_test "create; enq nonempty" test + + +let test () : bool = + let q : int queue = create () in + enq 1 q; + enq 2 q; + 1 = deq q +;; run_test "deq first" test + +let test () : bool = + let q : int queue = create () in + enq 1 q; + enq 2 q; + let _ = deq q in + 2 = deq q +;; run_test "deq second" test + +let test () : bool = + let q : int queue = create () in + enq 1 q; + enq 2 q; + let _ = deq q in + enq 3 q; + let _ = deq q in + 3 = deq q +;; run_test "enq enq deq enq deq deq" test + +let test () : bool = + let q : int queue = create () in + enq 1 q; + let _ = deq q in + enq 2 q; + 2 = deq q +;; run_test "enq after deq" test + +let test () : bool = + let q : int queue = create () in + let _ = deq q in + false +;; run_failing_test "deq of empty should fail" test + + +let test () : bool = + let q : int queue = create () in + enq 2 q; + let _ = deq q in + is_empty q +;; run_test "enq then deq leaves empty" test + + +let test () : bool = + let q : int queue = create () in + enq 1 q; + enq 2 q; + enq 3 q; + [1;2;3] = to_list q +;; run_test "to_list 1 2 3" test + + diff --git a/Java/M1-code/simpleWidget.ml.txt b/Java/M1-code/simpleWidget.ml.txt new file mode 100644 index 0000000..5825d89 --- /dev/null +++ b/Java/M1-code/simpleWidget.ml.txt @@ -0,0 +1,58 @@ +(* An interface for simple GUI widgets *) +type widget = { + repaint : Gctx.gctx -> unit; + size : unit -> (int * int) +} + +(* A simple widget that puts some text on the screen *) +let label (s:string) : widget = +{ + repaint = (fun (g:Gctx.gctx) -> Gctx.draw_string g (0,0) s); + size = (fun () -> Gctx.text_size s) +} + +let space ((x, y):int*int) : widget = +{ + repaint = (fun (g:Gctx.gctx) -> ()); + size = (fun () -> (x,y)) +} + +let canvas ((w,h):int*int) (repaint: Gctx.gctx -> unit) : widget = +{ + repaint = repaint; + size = (fun () -> (w,h)) +} + +let border (w:widget):widget = +{ +repaint = (fun (g:Gctx.gctx) -> + let (width,height) = w.size () in + let x = width + 3 in + let y = height + 3 in + Gctx.draw_line g (0,0) (x,0); + Gctx.draw_line g (0,0) (0,y); + Gctx.draw_line g (x,0) (x,y); + Gctx.draw_line g (0,y) (x,y); + let g = Gctx.translate g (2,2) in + w.repaint g); + +size = (fun () -> + let (width,height) = w.size () in + (width+4, height+4)) +} + +let hpair (w1:widget) (w2:widget) : widget = +{ + repaint = (fun (g:Gctx.gctx) -> + let (x1,_) = w1.size () in begin + w1.repaint g; + w2.repaint (Gctx.translate g (x1,0)) + (* Note translation of the Gctx *) + end); + +size = (fun () -> + let (x1,y1) = w1.size () in + let (x2,y2) = w2.size () in + (x1 + x2, max y1 y2)) +} + diff --git a/Java/M1-code/swdemo.ml.txt b/Java/M1-code/swdemo.ml.txt new file mode 100644 index 0000000..8fa88d3 --- /dev/null +++ b/Java/M1-code/swdemo.ml.txt @@ -0,0 +1,37 @@ +;; open Gctx +;; open SimpleWidget + +(* This paint function draws a fractal tree -- Google "L-systems" for *) +(* more explanation / inspiration *) +let paint_tree (g:Gctx.gctx) : unit = + let rec fractal ((x,y):int*int) (angle:int) (len:int) = + if len <= 1 then () + else + let lf = float_of_int len in + let af = ((float_of_int angle) *. 3.14159) /. 180.0 in + let nx = x + (int_of_float (lf *. (cos af))) in + let ny = y + (int_of_float (lf *. (sin af))) in + begin + Gctx.draw_line g (x,y) (nx, ny); + fractal (nx, ny) (angle + 20) (len - 2); + fractal (nx, ny) (angle - 10) (len - 1) + end + in + fractal (75,100) 270 15 + +let c = canvas (200, 200) + (fun g -> paint_tree (with_color g green)) + +let run (w:widget) : unit = + Gctx.open_graphics (); (* open graphics window *) + let top = Gctx.top_level in + w.repaint top; (* repaint the widget once *) + Graphics.synchronize (); (* force window update *) + ignore (Graphics.read_key ()) (* wait for a keypress *) + +let l1 = label "hello" +let l2 = label "world" +let w = hpair (hpair (border l1) (space (10,10)) ) + (border l2) + +;; run (hpair (border c) (border w)) diff --git a/Java/M2-code/ArrayExamples.java b/Java/M2-code/ArrayExamples.java new file mode 100644 index 0000000..fa49279 --- /dev/null +++ b/Java/M2-code/ArrayExamples.java @@ -0,0 +1,95 @@ +// Finger exercises for working with arrays + +// All of these methods are static methods that calculate with +// array data structures + + +public class ArrayExamples { + + // Determine whether two integer arrays contain the + // same elements + + // two null arrays are equal + // and two nonnull arrays are equal when all of their elements are equal + public static boolean eq(int [] arr1, int[] arr2) { + if (arr1 == null && arr2 == null) { + return true; + } + if (arr1 == null || arr2 == null) { + return false; + } + if (arr1.length != arr2.length) { + return false; + } + for (int i = 0; i < arr1.length ; i++) { + if (arr1[i] != arr2[i]) { + return false; + } + } + + return true; + } + + public static void example() { + int[][] products = new int[5][]; + for(int col = 0; col < 5; col++) { + products[col] = new int[col+1]; + for(int row = 0; row <= col; row++) { + products[col][row] = col * row; + } + } + + } + + + // copy the array between positions m to n + public static int[] sub(int[] a, int m, int n) { + return null; + } + + // determine whether an array is a palindrome + public static boolean palindrome(int [] arr) { + return false; + } + + // concatenate two arrays together, producing a new + // array that contains all of the elements of the first + // array followed by all of the elements of the second + // array. + public static int[] concat (int[] arr1, int[] arr2) { + return null; + } + + // interleave two arrays together + public static int[] interleave (int[] arr1, int[] arr2) { + return null; + } + + // compute the maximum element of an array + // that contains at least one element + public static int max(int[] arr) { + return -1; + } + + + // return an array that is the reverse of the given array + public static int[] reverse(int [] arr) { + return null; + } + + // compute the *index* of the maximum element of an array + // that contains at least one element + public static int maxIndex(int[] arr) { + return -1; + } + + // ensure a 2D array is rectangular + public static boolean rect (int [][] a) { + return true; + } + + // find the average value of a 2D array + public static int avg (int [][] a) { + return 0; + } +} \ No newline at end of file diff --git a/Java/M2-code/ArrayExamplesTest.java b/Java/M2-code/ArrayExamplesTest.java new file mode 100644 index 0000000..c714363 --- /dev/null +++ b/Java/M2-code/ArrayExamplesTest.java @@ -0,0 +1,206 @@ +import static org.junit.Assert.*; + +import org.junit.Test; + + +public class ArrayExamplesTest { + + @Test + public void testEq() { + int [] arr1 = { 1 , 2 , 3 }; + int [] arr2 = { 1 , 2 , 3 }; + assertTrue( ArrayExamples.eq(arr1,arr2) ); + } + @Test + public void testNEq() { + int [] arr1 = { 1 , 2 , 3 }; + int [] arr2 = { 1 , 2 , 4 }; + assertFalse( ArrayExamples.eq(arr1,arr2) ); + } + + @Test + public void testNEqOrder() { + int [] arr1 = { 1 , 2 , 3 }; + int [] arr2 = { 1 , 3 , 2 }; + assertFalse( ArrayExamples.eq(arr1,arr2) ); + } + + @Test + public void testEmpty() { + int [] arr1 = { }; + int [] arr2 = { }; + assertTrue( ArrayExamples.eq(arr1,arr2) ); + } + @Test + public void testNull() { + int [] arr1 = null; + int [] arr2 = null; + assertTrue( ArrayExamples.eq(arr1,arr2) ); + } + @Test + public void testLonger1() { + int [] arr1 = { 1 , 2 }; + int [] arr2 = { 1 }; + assertFalse( ArrayExamples.eq(arr1,arr2) ); + } + @Test + public void testLonger2() { + int [] arr1 = { 1 }; + int [] arr2 = { 1 , 2 }; + assertFalse( ArrayExamples.eq(arr1,arr2) ); + } + + @Test + public void testRect1() { + int [][] a = {}; + assertTrue( ArrayExamples.rect(a)); + } + @Test + public void testRect2() { + int [][] a = { {} }; + assertTrue( ArrayExamples.rect(a)); + } + @Test + public void testRect22() { + int [][] a = { { 2 , 2 }, { 2 , 2 }}; + assertTrue( ArrayExamples.rect(a)); + } + + @Test + public void testRect23ok() { + int [][] a = { { 2 , 2 , 3 }, { 2 , 2 , 4 }}; + assertTrue( ArrayExamples.rect(a)); + } + + @Test + public void testRect23() { + int [][] a = { { 2 , 2 }, { 2 , 2 , 3}}; + assertFalse( ArrayExamples.rect(a)); + } + + @Test + public void testRectNull() { + int [][] a = null; + assertFalse( ArrayExamples.rect(a)); + } + + @Test + public void testRectNull2() { + int [][] a = { null, { 2 ,3 } }; + assertFalse( ArrayExamples.rect(a)); + } + + @Test + public void testReverse() { + int[] arr = new int[]{ 1 , 2 , 3 }; + int[] arr2 = ArrayExamples.reverse(arr); + assertTrue(arr != arr2); + assertNotNull(arr2); + assertTrue(arr2.length == 3); + assertTrue(arr2[2] == 1); + assertTrue(arr2[1] == 2); + assertTrue(arr2[0] == 3); + } + + @Test + public void testNotPalindrome() { + int[] arr = new int[] { 1, 2, 3} ; + assertFalse(ArrayExamples.palindrome(arr)); + } + + @Test + public void testPalindromeEven() { + int[] arr = new int[] { 1, 2, 2, 1} ; + assertTrue(ArrayExamples.palindrome(arr)); + } + + @Test + public void testPalindromeEmpty() { + int[] arr = new int[] {} ; + assertTrue(ArrayExamples.palindrome(arr)); + } + + @Test + public void testPalindromeOdd() { + int[] arr = new int[] { 1, 2, 3, 2, 1} ; + assertTrue(ArrayExamples.palindrome(arr)); + } + + @Test + public void testConcat1() { + int[] arr1 = new int[] { 1, 2, 3 } ; + int[] arr2 = new int[] { 4 ,5, 6 } ; + int[] ans = new int[] { 1, 2, 3, 4, 5, 6} ; + assertTrue(ArrayExamples.eq(ans, ArrayExamples.concat(arr1,arr2))); + } + + @Test + public void testConcat2() { + int[] arr1 = new int[] { 1, 2, 3 } ; + int[] arr2 = new int[] {} ; + int[] ans = new int[] { 1, 2, 3} ; + assertTrue(ArrayExamples.eq(ans, ArrayExamples.concat(arr1,arr2))); + } + + @Test + public void testConcat3() { + int[] arr1 = new int[] {} ; + int[] arr2 = new int[] {1,2,3} ; + int[] ans = new int[] { 1, 2, 3} ; + assertTrue(ArrayExamples.eq(ans, ArrayExamples.concat(arr1,arr2))); + } + + @Test + public void testInterleave() { + int[] arr1 = { 1, 3, 5 }; + int[] arr2 = { 2 }; + int[] ans = { 1 , 2, 3, 5 }; + assertTrue (ArrayExamples.eq(ans, ArrayExamples.interleave(arr1, arr2))); + } + + @Test + public void testMax() { + int[] arr1 = { 1, 3, 4, 4}; + assertEquals(ArrayExamples.max(arr1), 4); + } + + @Test + public void testMaxIndex() { + int[] arr1 = { 1, 3, 4, 4}; + assertEquals(2, ArrayExamples.maxIndex(arr1)); + } + + + + @Test + public void testAvg1() { + int[][] arr = { { 1 } }; + assertEquals(ArrayExamples.avg(arr),1); + } + + @Test + public void testAvg2() { + int[][] arr = { { 1, 2 }, { 3 }}; + assertEquals(ArrayExamples.avg(arr),2); + } + + @Test + public void testSub() { + int[] arr = { 0, 1, 2, 3, 4 }; + int[] ans = ArrayExamples.sub(arr, 2, 3); + assertTrue(ArrayExamples.eq( new int[]{ 2 }, ans)); + } + + @Test + public void testSubHead() { + int[] arr = { 0, 1, 2, 3, 4 }; + int[] ans = ArrayExamples.sub(arr, 0, 2); + assertTrue(ArrayExamples.eq( new int[]{ 0,1 }, ans)); + } + @Test + public void testSubTail() { + int[] arr = { 0, 1, 2, 3, 4 }; + int[] ans = ArrayExamples.sub(arr, 2,5); + assertTrue(ArrayExamples.eq( new int[]{ 2,3,4 }, ans)); + } +} \ No newline at end of file diff --git a/Java/M2-code/ResArray.java b/Java/M2-code/ResArray.java new file mode 100644 index 0000000..931c9ea --- /dev/null +++ b/Java/M2-code/ResArray.java @@ -0,0 +1,69 @@ +public class ResArray { + + private int[] data; + private int extent = 0; + /* INVARIANT: extent = 1+index of last nonzero + * element, or 0 if all elements are 0. + */ + + /** Constructor, takes no arguments. */ + public ResArray() { + data = new int[3]; + } + + /** Access the array at position i. + * If i is negative, through IllegalArgumentException. + * If position i has not yet + * been initialized, return 0. + */ + public int get(int idx) { + if (idx < 0) { + throw new IllegalArgumentException(); + } else { + if (idx >= data.length) { + return 0; + } else { + return data[idx]; + } + } + } + + private void grow(int idx) { + if (idx >= data.length) { + int[] newdata = new int[Math.max(idx+1, data.length*2)]; + for (int i=0; i < data.length; i++) { + newdata[i] = data[i]; + } + data = newdata; + } + } + + /** Modify the array at position i to contain the value v. */ + public void set(int idx, int val) { + if (idx < 0) { + throw new IllegalArgumentException(); + } + grow(idx); + data[idx] = val; + if (val != 0 && idx+1 > extent) { + extent = idx+1; + } + if (val == 0 && idx+1 == extent) { + while (extent > 0 && data[extent-1] == 0) { + extent--; + } + } + } + + /** Return the extent of the array. i.e. one past the index + * of the last nonzero value in the array. */ + public int getExtent() { + return extent; + } + + // This implementation violates abstraction! + public int[] values() { + return data; + } + +} diff --git a/Java/M2-code/ResArrayTest.java b/Java/M2-code/ResArrayTest.java new file mode 100644 index 0000000..c98e287 --- /dev/null +++ b/Java/M2-code/ResArrayTest.java @@ -0,0 +1,121 @@ +///import static org.junit.Assert.*; + +import static org.junit.Assert.*; + +import org.junit.Test; + +/** Test cases for resizeable arrays */ + +public class ResArrayTest { + + //initialization and get + @Test public void testGet0 () { + ResArray a = new ResArray(); + assertEquals(0, a.get(17)); + } + + @Test public void testAtExtent() { + ResArray a = new ResArray(); + int e = a.getExtent(); + assertEquals(0, a.get(e)); + } + + // set then get + @Test + public void testSetGet1 () { + ResArray a = new ResArray(); + a.set(17, 120); + int result = a.get(17); + + assertEquals(120, result); + } + + // set then get + @Test + public void testSetGet2 () { + ResArray a = new ResArray(); + a.set(17, 120); + a.set(17, 110); + assertEquals(110, a.get(17)); + } + + // set then get + @Test + public void testSetGet3 () { + ResArray a = new ResArray(); + a.set(17, 120); + assertEquals(0, a.get(14)); + } + + // test that an expected exception is raised + @Test(expected = IllegalArgumentException.class) + public void testNegativeArg () { + ResArray a = new ResArray(); + a.set(-17, 23); + } + + + // determine the extent of the array + @Test + public void testExtent0 () { + ResArray a = new ResArray(); + assertEquals(0, a.getExtent()); + } + + // determine the extent of the array + @Test + public void testExtent1 () { + ResArray a = new ResArray(); + a.set(17, 120); + assertEquals(18, a.getExtent()); + } + + + // determine the extent of the array + @Test + public void testExtent2 () { + ResArray a = new ResArray(); + a.set(17, 120); + a.set(17, 0); + assertEquals(0, a.getExtent()); + } + + // determine the extent of the array + @Test + public void testExtent3 () { + ResArray a = new ResArray(); + a.set(17, 120); + a.set(15, 110); + a.set(17, 0); + assertEquals(16, a.getExtent()); + } + +/* + // Getting all of the values after set + @Test + public void testValues1() { + ResArray a = new ResArray(); + a.set(1,1); + a.set(2,4); + int [] b = a.values(); + assertEquals(b.length,3); + assertEquals(0,b[0]); + assertEquals(1,b[1]); + assertEquals(4,b[2]); + } + + // Getting all of the values after set + @Test + public void testValues2() { + ResArray a = new ResArray(); + a.set(1, 1); + a.set(2, 4); + a.set(2, 0); + int[] b = a.values(); + assertEquals(b.length, 2); + assertEquals(0,b[0]); + assertEquals(1,b[1]); + } + */ + +} \ No newline at end of file diff --git a/Java/M2-code/gctx.ml b/Java/M2-code/gctx.ml new file mode 100644 index 0000000..f8a5764 --- /dev/null +++ b/Java/M2-code/gctx.ml @@ -0,0 +1,303 @@ +(** The "Graphics Context" component of the GUI library. *) + +(** A graphics context represents a portion of the window to which + widgets will be drawn. + + The drawing primitives in this module are all relative to the + graphics context. This means that when a widget needs to draw on the + screen, it need not know its absolute position. The graphics context + is responsible for translating the relative positions passed into the + drawing routines into absolute positions on the screen. + + The graphics context also includes other information for basic + drawing (such as the current pen color.) + + Note that this module defines a persistent (immutable) data + structure. The operations here use a given graphics context to create + a new one with the specified characteristics. They do not modify + their arguments. *) + + +(****************) +(** {1 Colors } *) +(****************) + +(** A type for colors *) +type color = {r:int; g:int; b:int} + +let black : color = {r=0; g=0; b=0} +let white : color = {r=255;g=255;b=255} +let red : color = {r=255;g=0; b=0} +let green : color = {r=0; g=255;b=0} +let blue : color = {r=0; g=0; b=255} +let yellow : color = {r=255;g=255;b=0} +let cyan : color = {r=0; g=255;b=255} +let magenta : color = {r=255;g=0; b=255} + + +(*******************************) +(** Basic Gctx operations *) +(*******************************) + +(** The main type of graphics contexts. Note that none of the components + are mutable. *) +(* TODO: You will need to modify this type definition for Task 5. *) +type gctx = { + x: int; (** offset from (0,0) in local coordinates *) + y: int; + color: color; (** the current pen color *) +} + + +(* has the graphics window been opened already? *) +let graphics_opened = { contents = false; } +(** Open the graphics window, but only do it once *) +let open_graphics () = + if not graphics_opened.contents then + begin + graphics_opened.contents <- true; + Graphics.open_graph ""; (* open the window *) + Graphics.auto_synchronize false; (* don't draw immediately *) + Graphics.clear_graph (); + Graphics.synchronize () + end + +(** The top-level graphics context. *) +let top_level : gctx = + { x = 0; + y = 0; + color = black; + } + +(** Widgets can translate (move) a graphics context to obtain an +appropriate graphics context for their children. *) + +(** Shift the gctx by (dx,dy) *) +let translate (g: gctx) ((dx, dy): int * int) : gctx = + { g with x = g.x + dx; y = g.y + dy } + +(** Produce a new Gctx.t with a different pen color *) +let with_color (g: gctx) (c: color) : gctx = + { g with color = c } + + +(** Set the OCaml graphics library's internal state so that it +agrees with the Gctx settings. + +Initially, this just sets the current pen color. +*) +(* TODO: You will need to modify this definition for Task 5. *) +let set_graphics_state (gc: gctx) : unit = + let {r;g;b} = gc.color in + Graphics.set_color (Graphics.rgb r g b) + + +(************************************) +(* Coordinate Transformations *) +(************************************) + +(* The default width and height of the graphics window that OCaml opens. *) + +let graphics_size_x () = + if graphics_opened.contents then Graphics.size_x () else 600 +let graphics_size_y () = + if graphics_opened.contents then Graphics.size_y () else 450 + +(* A main purpose of the graphics context is to provide mapping between *) +(* widget-local coordinates and the ocaml coordinates of the graphics *) +(* library. Part of that translation comes from the offset stored in the *) +(* graphics context itself. The translation needs to know where the widget *) +(* is on the screen. The other part of the translation is the y axis flip. *) +(* The OCaml library puts (0,0) at the bottom left corner of the window. *) +(* We'd like our GUI library to put (0,0) at the top left corner and *) +(* increase the y-coordinate as we go *down* the screen. *) + +(** A widget-relative position *) +type position = int * int + +(* ALWAYS call these functions before passing widget-local points to the *) +(* OCaml native Graphics module or vice-versa. *) + +(** Convert widget-local coordinates (x,y) to OCaml graphics + coordinates, relative to the graphics context. *) +let ocaml_coords (g: gctx) ((x, y): position) : (int * int) = + (g.x + x, graphics_size_y () - 1 - (g.y + y)) + +(** Convert OCaml Graphics coordinates (x,y) to widget-local graphics + coordinates, relative to the graphics context *) +let local_coords (g: gctx) ((x, y): int * int) : position = + (x - g.x, (graphics_size_y () - 1 - y) - g.y) + + + +(*****************) +(** {1 Drawing } *) +(*****************) + +(** A width and height, paired together. *) +type dimension = int * int + +(* Each of these functions takes inputs in widget-local coordinates, *) +(* converts them to OCaml coordinates, and then draws the appropriate *) +(* shape. *) + +(** Draw a line between the two specified positions *) +let draw_line (g: gctx) (p1: position) (p2: position) : unit = + set_graphics_state g; + let (x1, y1) = ocaml_coords g p1 in + let (x2, y2) = ocaml_coords g p2 in + Graphics.moveto x1 y1; + Graphics.lineto x2 y2 + +(** Display text at the given position *) +let draw_string (g: gctx) (p: position) (s: string) : unit = + set_graphics_state g; + let (_, height) = Graphics.text_size s in + let (x, y) = ocaml_coords g p in + (* subtract: working with Ocaml coordinates *) + Graphics.moveto x (y - height); + Graphics.draw_string s + +(** Display a rectangle with lower-left corner at position + with the specified dimension. *) +(* TODO: you will need to make this function actually draw a + rectangle for Task 0. *) +let draw_rect (g: gctx) (p1: position) ((w, h): dimension) : unit = + failwith "Gctx.draw_rect: unimplemented" + +(** Display a filled rectangle with lower-left corner at positions + with the specified dimension. *) +let fill_rect (g: gctx) (p1: position) ((w, h): dimension) : unit = + set_graphics_state g; + let (x, y) = ocaml_coords g p1 in + Graphics.fill_rect x y w h + +(** Draw an ellipse at the given position with the given radii *) +(* TODO: you will need to make this function actually draw an + ellipse for Task 0. *) +let draw_ellipse (g: gctx) (p: position) (rx: int) (ry: int) : unit = + failwith "Gctx.draw_ellipse: unimplemented" + + +(** Calculates the size of a text when rendered. *) +let text_size (text: string) : dimension = + (* Make sure that the graphics window has been opened. All of the other functions + require a graphics context, which is difficult to get without opening the graphics + window first. But this one does not, so is a source of subtle bugs. *) + open_graphics (); + Graphics.text_size text + +(* TODO: You will need to add several "wrapped" versions of ocaml graphics *) +(* functions here for Tasks 2, 4, and possibly 5 and 6 *) + + +(************************) +(** {1 Event Handling } *) +(************************) + +(* This part of the module adapts OCaml's native event handling to *) +(* something that more closely resembles that found in Java. *) + +(** Types of events that could occur *) +type event_type = + | KeyPress of char (* Key pressed on the keyboard. *) + | MouseDown (* Mouse button pressed. *) + | MouseUp (* Mouse button released. *) + | MouseMove (* Mouse moved with the button up. *) + | MouseDrag (* Mouse moved with the button down. *) + + +let string_of_event_type (et : event_type) : string = + begin match et with + | KeyPress k -> "KeyPress at " ^ (String.make 1 k) + | MouseDrag -> "MouseDrag" + | MouseMove -> "MouseMove" + | MouseUp -> "MouseUp" + | MouseDown -> "MouseDown" + end + + +(** An event records its type and the widget-local position of + the mouse when the event occurred. *) +type event = event_type * position + +(** Accessor for the type of an event. *) +let event_type (e: event) : event_type = + fst e + + +(** Accessor for the widget local position of an event. *) +let event_pos (e: event) (g : gctx) : position = + local_coords g (snd e) + +(** Convert an event to a string *) +let string_of_event ((ty, (x, y)): event) : string = + (string_of_event_type ty) ^ " at " ^ (string_of_int x) ^ "," + ^ (string_of_int y) + +(** Make a dummy event for testing. *) +let make_test_event (et : event_type) ((x, y) : position) = + (et, (x, graphics_size_y () - y)) + + +let string_of_status (s: Graphics.status) : string = + "(" ^ (string_of_int s.Graphics.mouse_x) ^ "," + ^ (string_of_int s.Graphics.mouse_y) ^ ") b:" + ^ (string_of_bool s.Graphics.button) + ^ (if s.Graphics.keypressed + then "k:" ^ (String.make 1 s.Graphics.key) + else "") + +(* The last function is used by the eventloop to get the next *) +(* event from the graphics library. The events reported by the *) +(* library are not as informative as we would like, so this *) +(* function also processes them into a more convenient form. *) +(* You don't need to understand how this processing works, but *) +(* you do need to understand the various forms of events that *) +(* this function generates. *) + +(** Wait for a mouse or key event. *) +let wait_for_event : unit -> event = + + let initial_status : Graphics.status = + { Graphics.mouse_x =0; + Graphics.mouse_y =0; + Graphics.key = ' '; + Graphics.button = false; + Graphics.keypressed = false } in + + let last_status = ref initial_status in + + let compute_rich_event + (s0 : Graphics.status) + (s1 : Graphics.status) : event_type option = + + if s1.Graphics.keypressed then Some (KeyPress s1.Graphics.key) + else if s0.Graphics.button <> s1.Graphics.button then + (* change in button state *) + begin + if s1.Graphics.button then Some MouseDown else Some MouseUp + end + else if (s0.Graphics.mouse_x <> s1.Graphics.mouse_x ) || + (s0.Graphics.mouse_y <> s1.Graphics.mouse_y ) then + (* mouse motion *) + begin + if s1.Graphics.button then Some MouseDrag else Some MouseMove + end + else None in + + fun () -> + let rec loop () = + let status = Graphics.wait_next_event + [Graphics.Mouse_motion; Graphics.Button_down; + Graphics.Button_up; Graphics.Key_pressed] in + let event_type = compute_rich_event !last_status status in + begin match event_type with + | None -> (last_status := status; loop ()) + | Some ty -> + (last_status := status; + let event = (ty, (status.Graphics.mouse_x, + status.Graphics.mouse_y)) in + event) + end in + loop () diff --git a/Java/M2-code/mutable.ml b/Java/M2-code/mutable.ml new file mode 100644 index 0000000..f80a067 --- /dev/null +++ b/Java/M2-code/mutable.ml @@ -0,0 +1,112 @@ +;; open Assert + +(* Commands are useful because they *do* things. *) + +let x = 31 + 89 +;; print_endline (string_of_int x) + + +(* Can embed commands inside functions! *) + +let f (x : int) : unit = + print_string "f called with "; + print_endline (string_of_int x); + ignore (x + x); (* must mark values that are not used *) + print_string "end" (* no ; at end! *) + +;; let x = f 120 +;; x = () + + +(* What is the result type of print_string? *) + +(* print_string : string -> unit *) + +let g (x:int) : unit = + print_string "g called with "; + print_endline (string_of_int x) + + +(* a testing function, what is its type? *) +let test () : bool = 4 = 5 + +let h = test () + + +(* Can call test by providing () value *) + + +(* run_test : string -> (unit -> bool) -> unit *) +;; run_test "4 is 5" test + + + + +(* Functions can take unit as an argument. *) + +let f (x : unit) : int = 3 + + +(* unit: Just like any other value. *) + +let g (x:unit) : int = + begin match x with + | () -> 3 + end + + +(* if: then without an else *) + +;; if false then print_string "not a chance" (* else () *) + + + + +(* ------- (Immutable) records --------- *) + +(* a type for representing colors *) +type rgb = {r:int; g:int; b:int;} + +(* some example rgb values *) +let red : rgb = {r=255; g=0; b=0;} +let blue : rgb = {r=0; g=0; b=255;} +let green : rgb = {r=0; g=255; b=0;} +let black : rgb = {r=0; g=0; b=0;} +let white : rgb = {r=255; g=255; b=255;} + +(* using 'dot' notation to project out components *) +(* calculate the average of two colors *) +let average_rgb (c1:rgb) (c2:rgb) : rgb = + {r = (c1.r + c2.r) / 2; + g = (c1.g + c2.g) / 2; + b = (c1.b + c2.b) / 2;} + + + + + + + + + + + +(* MUTABLE RECORDS *) + +type point = {mutable x:int; mutable y:int} + +let string_of_point (p : point) : string = + "<" ^ (string_of_int p.x) ^ "," ^ (string_of_int p.y) ^ ">" + +let p0 = {x=0; y=0} +(* ;; print_endline (string_of_point p0) *) +(* set the x coord of p0 to 17 *) +;; p0.x <- 17 + + + +(* a command to shift a point by dx,dy *) +let shift (p:point) (dx:int) (dy:int) : unit = + p.x <- p.x + dx; + p.y <- p.y + dy; + print_endline ("p = " ^ string_of_point p) diff --git a/Java/M2-code/onoff.ml b/Java/M2-code/onoff.ml new file mode 100644 index 0000000..5b0f3a1 --- /dev/null +++ b/Java/M2-code/onoff.ml @@ -0,0 +1,30 @@ +;; open Gctx +;; open Widget + +type bulb_state = { mutable on : bool } + +let mk_bulb () : widget * widget = + let bulb = { on = false } in + let toggle () = bulb.on <- not (bulb.on) in + let paint_bulb (g: Gctx.gctx) = + let g_new = Gctx.with_color g (if bulb.on then yellow else black) in + Gctx.fill_rect g_new (0,99) (99,99) in + let (c, _) = canvas (100,100) paint_bulb in + let (button1, lc1, nc1) = button "ON " in + let button_action () = + toggle (); + if bulb.on then lc1.set_label "OFF" else lc1.set_label "ON " + in + nc1.add_event_listener (mouseclick_listener button_action); + (c, button1) + +let (b1,button1) = mk_bulb () +let (b2,button2) = mk_bulb () + +let (qb, _, nc) = button "QUIT" + +;; nc.add_event_listener (mouseclick_listener (fun () -> exit 0)) + +let w = hpair b2 (hpair b1 (hpair (border button2) (hpair (border button1) (border qb)))) + +;; Eventloop.run w diff --git a/Java/M2-code/q.ml b/Java/M2-code/q.ml new file mode 100644 index 0000000..ad763a4 --- /dev/null +++ b/Java/M2-code/q.ml @@ -0,0 +1,194 @@ +;; open Assert +;; stop_on_failure () + +module type QUEUE = sig + (* type of the data structure *) + type 'a queue + + (* Make a new, empty queue *) + val create : unit -> 'a queue + + (* Determine if the queue is empty *) + val is_empty : 'a queue -> bool + + (* Add a value to the end of the queue *) + val enq : 'a -> 'a queue -> unit + + (* Remove the first value (if any) and return it *) + val deq : 'a queue -> 'a + + (* Queue length *) + val length : 'a queue -> int +end + + +module Queue : QUEUE = struct + (* INVARIANT: q : 'a queue is a well-formed queue if + (1) q.head and q.tail are both None, or + (2) q.head is Some n1 and q.tail is Some n2 and + - n2 is reachable from n1 following 'next' references + - n2.next is None *) + type 'a qnode = { + v : 'a; + mutable next : 'a qnode option; + } + + type 'a queue = { + mutable head : 'a qnode option; + mutable tail : 'a qnode option; + } + + (* ----- a cyclic queue ----- *) + + + let cycle : int queue = + let qn = { v = 1; next = None } in + let q = { head = Some qn; tail = Some qn } in + qn.next <- q.head; + q + + let test () : bool = + cycle == cycle + ;; run_test "q == q" test + +(* + let test () : bool = + cycle = cycle + ;; run_test "cycle = cycle: infinite loop" test +*) + + (* ------ general queue operations ------- *) + + let create () = + { head = None; tail = None; } + + + let is_empty (q : 'a queue) : bool = + q.head = None (* && q.tail = None *) + + let enq (x : 'a) (q : 'a queue) : unit = + let qno = Some { v = x; next = None } in + begin match q.tail with + | None -> + q.head <- qno; + q.tail <- qno + | Some qn2 -> + q.tail <- qno; + qn2.next <- qno + end + + let deq (q : 'a queue) : 'a = + begin match q.head with + | None -> failwith "deq: queue empty" + | Some qn -> + q.head <- qn.next; + if qn.next = None then q.tail <- None; + qn.v + end + +;; run_test "d1" (fun () -> + let q = create () in + enq 1 q; + 1 = deq q) + +;; run_test "d2" (fun () -> + let q = create () in + enq 1 q; + enq 2 q; + ignore (deq q); + 2 = deq q) + +;; run_test "d3" (fun () -> + let q = create () in + enq 1 q; + ignore (deq q); + enq 2 q; + 2 = deq q) + + let rec length (q: 'a queue) : int = + let rec loop (qno : 'a qnode option) (acc:int) : int = + begin match qno with + | Some qn -> loop qn.next (1 + acc) + | None -> acc + end + in + + loop q.head 0 + +;; run_test "length empty" (fun () -> + let q = create () in + length q = 0) + +;; run_test "length" (fun () -> + let q = create () in + enq 1 q; + enq 2 q; + length q = 2) + +end + +;; open Queue + +let test () : bool = + is_empty (create ()) +;; run_test "create empty" test + +let test () : bool = + let q1 = create () in + let q2 = create () in + not (q1 == q2) +;; run_test "create distinct queues" test + +let test () : bool = + let q = create () in + enq 1 q; + not (is_empty q) +;; run_test "create; enq nonempty" test + + +let test () : bool = + let q : int queue = create () in + enq 1 q; + enq 2 q; + 1 = deq q +;; run_test "deq first" test + +let test () : bool = + let q : int queue = create () in + enq 1 q; + enq 2 q; + let _ = deq q in + 2 = deq q +;; run_test "deq second" test + +let test () : bool = + let q : int queue = create () in + enq 1 q; + enq 2 q; + let _ = deq q in + enq 3 q; + let _ = deq q in + 3 = deq q +;; run_test "enq enq deq enq deq deq" test + +let test () : bool = + let q : int queue = create () in + enq 1 q; + let _ = deq q in + enq 2 q; + 2 = deq q +;; run_test "enq after deq" test + +let test () : bool = + let q : int queue = create () in + let _ = deq q in + false +;; run_failing_test "deq of empty should fail" test + + +let test () : bool = + let q : int queue = create () in + enq 2 q; + let _ = deq q in + is_empty q +;; run_test "enq then deq leaves empty" test diff --git a/Java/M2-code/q2.ml b/Java/M2-code/q2.ml new file mode 100644 index 0000000..f874112 --- /dev/null +++ b/Java/M2-code/q2.ml @@ -0,0 +1,238 @@ +;; open Assert +;; stop_on_failure () + +module type QUEUE = sig + (* type of the data structure *) + type 'a queue + + (* Make a new, empty queue *) + val create : unit -> 'a queue + + (* Determine if the queue is empty *) + val is_empty : 'a queue -> bool + + (* Add a value to the end of the queue *) + val enq : 'a -> 'a queue -> unit + + (* Remove the first value (if any) and return it *) + val deq : 'a queue -> 'a + + (* Queue length *) + val length : 'a queue -> int + + val to_list : 'a queue -> 'a list + val print : 'a queue -> ('a -> string) -> unit +end + + +module Queue : QUEUE = struct + (* Queue INVARIANT: + Either (1) q.head and q.tail are both None + or (2) q.head is Some n1 and q.tail is Some n2 + and n2 is reachable from n1 following .next + and n2.next is None + *) + type 'a qnode = { v : 'a + ; mutable next : 'a qnode option } + + type 'a queue = { mutable head : 'a qnode option + ; mutable tail : 'a qnode option } + + + + + + + + +(* ----- an ill-formed cyclic queue value ----- *) + + let cycle : int queue = + let qn = { v = 1; next = None } in + let q = { head = Some qn; tail = Some qn } in + qn.next <- q.head; + q + + let test () : bool = + cycle == cycle + ;; run_test "q == q" test + +(* + let test () : bool = + cycle = cycle + ;; run_test "cycle = cycle: infinite loop" test +*) + + (* ------ general queue operations ------- *) + + let create () = + { head = None; tail = None } + + let is_empty (q : 'a queue) : bool = + q.head = None + + let enq (x : 'a) (q : 'a queue) : unit = + let newnode = {v = x; next = None} in + begin match q.tail with + | None -> + q.head <- Some newnode; + q.tail <- Some newnode + | Some nt -> + nt.next <- Some newnode; + q.tail <- Some newnode + end + + let deq (q : 'a queue) : 'a = + begin match q.head with + | None -> failwith "empty queue" + | Some n -> + q.head <- n.next; + if q.head = None then begin q.tail <- None; q.tail <- None end; + n.v + end + + +;; run_test "d1" (fun () -> + let q = create () in + enq 1 q; + 1 = deq q) + +;; run_test "d2" (fun () -> + let q = create () in + enq 1 q; + enq 2 q; + ignore (deq q); + 2 = deq q) + +;; run_test "d3" (fun () -> + let q = create () in + enq 1 q; + ignore (deq q); + enq 2 q; + 2 = deq q) + + + + + let length (q: 'a queue) : int = + let rec loop (qn : 'a qnode option) : int = + begin match qn with + | None -> 0 + | Some n -> 1 + (loop n.next) + end + in + loop q.head + + + +;; run_test "length empty" (fun () -> + let q = create () in + length q = 0) + +;; run_test "length" (fun () -> + let q = create () in + enq 1 q; + enq 2 q; + length q = 2) + + + let to_list (q: 'a queue) : 'q list = + let rec loop (qn:'a qnode option) (l:'a list) : 'a list = + begin match qn with + | None -> List.rev l + | Some n -> loop n.next (n.v :: l) + end + in + loop q.head [] + + let print (q: 'a queue) (str_of_a: 'a -> string) : unit = + let rec loop (qn: 'a qnode option) : unit = + begin match qn with + | None -> () + | Some n -> print_endline (str_of_a n.v); loop n.next + end + in + print_endline "\n---- q contents ----"; + loop q.head; + print_endline "------- done -------" + +end + +(* ------- TEST CASES ------- *) + +;; open Queue + +let test () : bool = + is_empty (create ()) +;; run_test "create empty" test + +let test () : bool = + let q1 = create () in + let q2 = create () in + not (q1 == q2) +;; run_test "create distinct queues" test + +let test () : bool = + let q = create () in + enq 1 q; + not (is_empty q) +;; run_test "create; enq nonempty" test + + +let test () : bool = + let q : int queue = create () in + enq 1 q; + enq 2 q; + 1 = deq q +;; run_test "deq first" test + +let test () : bool = + let q : int queue = create () in + enq 1 q; + enq 2 q; + let _ = deq q in + 2 = deq q +;; run_test "deq second" test + +let test () : bool = + let q : int queue = create () in + enq 1 q; + enq 2 q; + let _ = deq q in + enq 3 q; + let _ = deq q in + 3 = deq q +;; run_test "enq enq deq enq deq deq" test + +let test () : bool = + let q : int queue = create () in + enq 1 q; + let _ = deq q in + enq 2 q; + 2 = deq q +;; run_test "enq after deq" test + +let test () : bool = + let q : int queue = create () in + let _ = deq q in + false +;; run_failing_test "deq of empty should fail" test + + +let test () : bool = + let q : int queue = create () in + enq 2 q; + let _ = deq q in + is_empty q +;; run_test "enq then deq leaves empty" test + + +let test () : bool = + let q : int queue = create () in + enq 1 q; + enq 2 q; + enq 3 q; + [1;2;3] = to_list q +;; run_test "to_list 1 2 3" test + + diff --git a/Java/M2-code/simpleWidget.ml b/Java/M2-code/simpleWidget.ml new file mode 100644 index 0000000..5825d89 --- /dev/null +++ b/Java/M2-code/simpleWidget.ml @@ -0,0 +1,58 @@ +(* An interface for simple GUI widgets *) +type widget = { + repaint : Gctx.gctx -> unit; + size : unit -> (int * int) +} + +(* A simple widget that puts some text on the screen *) +let label (s:string) : widget = +{ + repaint = (fun (g:Gctx.gctx) -> Gctx.draw_string g (0,0) s); + size = (fun () -> Gctx.text_size s) +} + +let space ((x, y):int*int) : widget = +{ + repaint = (fun (g:Gctx.gctx) -> ()); + size = (fun () -> (x,y)) +} + +let canvas ((w,h):int*int) (repaint: Gctx.gctx -> unit) : widget = +{ + repaint = repaint; + size = (fun () -> (w,h)) +} + +let border (w:widget):widget = +{ +repaint = (fun (g:Gctx.gctx) -> + let (width,height) = w.size () in + let x = width + 3 in + let y = height + 3 in + Gctx.draw_line g (0,0) (x,0); + Gctx.draw_line g (0,0) (0,y); + Gctx.draw_line g (x,0) (x,y); + Gctx.draw_line g (0,y) (x,y); + let g = Gctx.translate g (2,2) in + w.repaint g); + +size = (fun () -> + let (width,height) = w.size () in + (width+4, height+4)) +} + +let hpair (w1:widget) (w2:widget) : widget = +{ + repaint = (fun (g:Gctx.gctx) -> + let (x1,_) = w1.size () in begin + w1.repaint g; + w2.repaint (Gctx.translate g (x1,0)) + (* Note translation of the Gctx *) + end); + +size = (fun () -> + let (x1,y1) = w1.size () in + let (x2,y2) = w2.size () in + (x1 + x2, max y1 y2)) +} + diff --git a/Java/M2-code/swdemo.ml b/Java/M2-code/swdemo.ml new file mode 100644 index 0000000..8fa88d3 --- /dev/null +++ b/Java/M2-code/swdemo.ml @@ -0,0 +1,37 @@ +;; open Gctx +;; open SimpleWidget + +(* This paint function draws a fractal tree -- Google "L-systems" for *) +(* more explanation / inspiration *) +let paint_tree (g:Gctx.gctx) : unit = + let rec fractal ((x,y):int*int) (angle:int) (len:int) = + if len <= 1 then () + else + let lf = float_of_int len in + let af = ((float_of_int angle) *. 3.14159) /. 180.0 in + let nx = x + (int_of_float (lf *. (cos af))) in + let ny = y + (int_of_float (lf *. (sin af))) in + begin + Gctx.draw_line g (x,y) (nx, ny); + fractal (nx, ny) (angle + 20) (len - 2); + fractal (nx, ny) (angle - 10) (len - 1) + end + in + fractal (75,100) 270 15 + +let c = canvas (200, 200) + (fun g -> paint_tree (with_color g green)) + +let run (w:widget) : unit = + Gctx.open_graphics (); (* open graphics window *) + let top = Gctx.top_level in + w.repaint top; (* repaint the widget once *) + Graphics.synchronize (); (* force window update *) + ignore (Graphics.read_key ()) (* wait for a keypress *) + +let l1 = label "hello" +let l2 = label "world" +let w = hpair (hpair (border l1) (space (10,10)) ) + (border l2) + +;; run (hpair (border c) (border w)) diff --git a/Java/M3-code/DrawingCanvas.java b/Java/M3-code/DrawingCanvas.java new file mode 100644 index 0000000..cca5379 --- /dev/null +++ b/Java/M3-code/DrawingCanvas.java @@ -0,0 +1,46 @@ +import java.awt.Color; +import java.awt.Dimension; +import java.awt.Graphics; +import javax.swing.JComponent; + +// By default JComponents are supposed to declare a +// serialVersionUID field (useful for larger projects), +// we suppress the warning since we don't need it. +@SuppressWarnings("serial") +public class DrawingCanvas extends JComponent { + + /* This paint function draws a fractal tree -- Google "L-systems" for + * more explanation / inspiration. + * It is the same as the fractal drawing from the OCaml lecture. */ + private static void fractal(Graphics gc, int x, int y, + double angle, double len) { + if (len > 1) { + double af = (angle * Math.PI) / 180.0; + int nx = x + (int)(len * Math.cos(af)); + int ny = y + (int)(len * Math.sin(af)); + gc.drawLine(x, y, nx, ny); + fractal(gc, nx, ny, angle + 20, len - 8); + fractal(gc, nx, ny, angle - 10, len - 8); + } + } + + @Override + public void paintComponent(Graphics gc) { + // we're overriding the method, but we want the + // old version to run first + super.paintComponent(gc); + + // set the pen color to green + gc.setColor(Color.GREEN); + + // draw a fractal tree + fractal (gc, 200, 450, 270, 80); + } + + // get the size of the drawing panel + @Override + public Dimension getPreferredSize() { + return new Dimension(500,500); + } + +} diff --git a/Java/M3-code/DrawingCanvasMain.java b/Java/M3-code/DrawingCanvasMain.java new file mode 100644 index 0000000..0af2dc7 --- /dev/null +++ b/Java/M3-code/DrawingCanvasMain.java @@ -0,0 +1,39 @@ +import java.awt.Color; + +import javax.swing.JFrame; +import javax.swing.SwingUtilities; + +public class DrawingCanvasMain implements Runnable { + + public static void main(String[] args) { + // The proper way to create a top-level window: + // - make a class that implements Runnable + // - the 'run' method creates the actual window + // - SwingUtilities.invokeLater calls the 'run' + // method after initializing the program state. + SwingUtilities.invokeLater(new DrawingCanvasMain()); + } + + @Override + public void run() { + // create the top-level window + JFrame frame = new JFrame("Tree"); + + DrawingCanvas tree = new DrawingCanvas(); + + // add the canvas to the frame's content pane + frame.getContentPane().add(tree); + + // pack sets the size of the frame automatically + // based on the sub-components' preferred sizes + frame.pack(); + + // tell the frame to display itself + frame.setVisible(true); + + // make sure to end the program when the window is + // closed + frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); + } + +} diff --git a/Java/M3-code/ExceptionExamples.java b/Java/M3-code/ExceptionExamples.java new file mode 100644 index 0000000..7c8c22c --- /dev/null +++ b/Java/M3-code/ExceptionExamples.java @@ -0,0 +1,48 @@ +import java.util.LinkedList; +import java.util.List; +import java.util.Iterator; + +public class ExceptionExamples { + + public static void iteratorExample() { + List l = new LinkedList(); + l.add(1); + l.add(2); + l.add(4); + + int sum = 0; + int cnt = 0; + for(int i: l) { + sum = sum + i; + cnt = cnt + 1; + } + System.out.println("sum = " + sum); + System.out.println("cnt = " + cnt); + } + + + public static void foo() { + bar(); + System.out.println("here in foo"); + } + + public static void bar() { + // try { + baz(); + // } catch (Exception e) { + // System.out.println("caught!"); + // } + System.out.println("here in bar"); + } + + public static void baz() { + throw new RuntimeException("baz threw this!"); + // System.out.println("here in baz"); + } + + public static void main(String[] args) { + // iteratorExample(); + foo(); + } + +} diff --git a/Java/M3-code/Exceptions.java b/Java/M3-code/Exceptions.java new file mode 100644 index 0000000..60ef521 --- /dev/null +++ b/Java/M3-code/Exceptions.java @@ -0,0 +1,46 @@ +import java.io.IOException; + +class ExceptionDemo { + public void methodA() throws IOException { + System.out.println("Entering A"); + methodB(); + System.out.println("Leaving A"); + } + + public void methodB() throws IOException { + System.out.println("Entering B"); + try { + methodC(true); + System.out.println("In B after C"); + return; + } + catch (RuntimeException e) { + + } finally { + System.out.println("In B's finally"); + } + System.out.println("Leaving B"); + } + + public void methodC(boolean raiseException) throws IOException { + System.out.println("Entering C"); + if (raiseException) throw new RuntimeException("HERE!"); + System.out.println("Leaving C"); + } + +} + + + +public class Exceptions { + + public static void main(String[] args) { + try { + (new ExceptionDemo()).methodA(); + } catch (IOException e) { + + + } + } + +} diff --git a/Java/M3-code/GCTest (1).java b/Java/M3-code/GCTest (1).java new file mode 100644 index 0000000..8d4cb53 --- /dev/null +++ b/Java/M3-code/GCTest (1).java @@ -0,0 +1,36 @@ +import java.util.LinkedList; + +class Big { + private int[] arr; + + public Big(int size) { + this.arr = new int[size]; + } + + public int access(int i) { + return arr[i]; + } + +} + + +public class GCTest { + + public static void main(String[] args) { + LinkedList l = new LinkedList(); + int size = 65536; + int iteration = 1; + while (true) { + System.out.println("Iteration: " + iteration); + for (int i=0; i<10000; i++) { + l.add(new Big(size)); + } + while (!l.isEmpty()) { + l.removeFirst(); + } + iteration++; + } + + } + +} diff --git a/Java/M3-code/GCTest.java b/Java/M3-code/GCTest.java new file mode 100644 index 0000000..8d4cb53 --- /dev/null +++ b/Java/M3-code/GCTest.java @@ -0,0 +1,36 @@ +import java.util.LinkedList; + +class Big { + private int[] arr; + + public Big(int size) { + this.arr = new int[size]; + } + + public int access(int i) { + return arr[i]; + } + +} + + +public class GCTest { + + public static void main(String[] args) { + LinkedList l = new LinkedList(); + int size = 65536; + int iteration = 1; + while (true) { + System.out.println("Iteration: " + iteration); + for (int i=0; i<10000; i++) { + l.add(new Big(size)); + } + while (!l.isEmpty()) { + l.removeFirst(); + } + iteration++; + } + + } + +} diff --git a/Java/M3-code/HashExample.java b/Java/M3-code/HashExample.java new file mode 100644 index 0000000..f80f1f2 --- /dev/null +++ b/Java/M3-code/HashExample.java @@ -0,0 +1,12 @@ +import java.util.HashMap; +import java.util.Map; + +public class HashExample { + + public static void main(String[] args) { + Map m = new HashMap(); + m.put(new Point(1,2), "House"); + System.out.println(m.containsKey(new Point(1,2))); + } + +} diff --git a/Java/M3-code/HashTest.java b/Java/M3-code/HashTest.java new file mode 100644 index 0000000..6ca64e4 --- /dev/null +++ b/Java/M3-code/HashTest.java @@ -0,0 +1,93 @@ +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashSet; +import java.util.LinkedList; +import java.util.Random; +import java.util.Set; +import java.util.TreeSet; + +public class HashTest { + + static class Point implements Comparable { + private int x; + private int y; + + public Point(int x, int y) { + this.x = x; + this.y = y; + } + + @Override + public int compareTo(Object obj) { + if (this == obj) + return 0; + Point other = (Point) obj; + if (x != other.x) + return (x - other.x); + if (y != other.y) + return (y - other.y); + return 0; + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + result = prime * result + x; + result = prime * result + y; + return result; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) + return true; + if (obj == null) + return false; + if (getClass() != obj.getClass()) + return false; + Point other = (Point) obj; + if (x != other.x) + return false; + if (y != other.y) + return false; + return true; + } + } + + public static void benchmark(Collection s, String name, int tests) { + System.out.format("%12s ", name); + Random r = new Random(12345); + int range = 100000; + long start = System.nanoTime(); + + for (int i = 0; i < tests; i++) { + s.add(new Point(r.nextInt(range), r.nextInt(range))); + } + + long stop1 = System.nanoTime(); + System.out.format("%4.3f ", (stop1 - start) / 1000000000.0); + + for (int i = 0; i < tests; i++) { + s.contains(new Point(r.nextInt(range), r.nextInt(range))); + } + + long stop2 = System.nanoTime(); + System.out.format("%4.3f%n", (stop2 - stop1) / 1000000000.0); + } + + public static void main(String[] args) { + Collection linkedList = new LinkedList(); + Collection arrayList = new ArrayList(); + Collection treeSet = new TreeSet(); + Collection hashSet = new HashSet(); + + int tests = 100000; + + System.out.format("Class Creation Lookup%n"); + benchmark(hashSet, "HashSet ", tests); + benchmark(treeSet, "TreeSet ", tests); + benchmark(arrayList, "ArrayList ", tests); + benchmark(linkedList, "LinkedList", tests); + } +} diff --git a/Java/M3-code/Histogram.java b/Java/M3-code/Histogram.java new file mode 100644 index 0000000..fc18154 --- /dev/null +++ b/Java/M3-code/Histogram.java @@ -0,0 +1,46 @@ +package histogram; +import java.io.FileNotFoundException; +import java.io.FileReader; +import java.io.Reader; +import java.util.Iterator; +import java.util.Map; +import java.util.TreeMap; + +public class Histogram { + + public static void main(String[] args) { + if (args.length != 1) { + System.out.println("Usage: java Histrogram "); + return; + } + + try { + Reader r = new FileReader(args[0]); + + Iterator ws = new WordScanner(r); + + Map histogram = + new TreeMap(); + // count words + while (ws.hasNext()) { + String word = ws.next(); + if (histogram.containsKey(word)) { + int count = histogram.get(word); + histogram.put(word, count + 1); + } else { + histogram.put(word, 1); + } + } + // print results + + for (Map.Entry entry : histogram.entrySet()) { + System.out.println(entry.getKey() + ": " + entry.getValue()); + } + + } catch (FileNotFoundException e) { + System.out.println("File Not Found: " + args[0]); + } + + } + +} diff --git a/Java/M3-code/Image.java b/Java/M3-code/Image.java new file mode 100644 index 0000000..ca8ef95 --- /dev/null +++ b/Java/M3-code/Image.java @@ -0,0 +1,83 @@ +package ioexamples; + +import java.io.*; + +import javax.swing.*; + +import java.awt.*; + +@SuppressWarnings("serial") +public class Image extends JComponent { + + // size of the image + private final static int WIDTH = 512; + private final static int HEIGHT = 512; + + // 2D array of b/w pixels values + private final int[][] data = new int[WIDTH][HEIGHT]; + + public void copy() throws IOException { + OutputStream out = + new FileOutputStream("mandrill-copy.pgm"); + PrintStream p = new PrintStream(out); + p.println("P5"); + p.println("512 512"); + p.println("255"); + for (int i=0; i shapes = new LinkedList(); + + /** an optional shape for preview mode */ + private Shape preview; + + /** + * A Canvas is a section of the screen that can be drawn on. + * + * Just like in the OCaml Paint assignment, we draw with a repainting + * function that uses some local state to determine what to draw. In Swing, + * the drawing method of a widget is called "paintComponent" + * + * The canvas is an *inner* class so that it can access the private + * 'actions' and 'preview' fields of the Paint. + */ + @SuppressWarnings("serial") + private class Canvas extends JPanel { + + /** + * Display the canvas on the screen using the Graphics Context. + * + * This method overrides the analogous method in its superclass. + * Therefore the first action it does is to call the superclass version + * of the method. Then it goes through each shape and invokes its draw + * method. + */ + @Override + public void paintComponent(Graphics gc) { + super.paintComponent(gc); + if (shapes != null) { + for (Shape s : shapes) { + s.draw(gc); + } + } + if (preview != null) { + preview.draw(gc); + } + } + + @Override + public Dimension getPreferredSize() { + return new Dimension(600, 400); + } + + public Canvas() { + super(); + setBackground(Color.WHITE); + } + + } + + private class Mouse extends MouseAdapter { + + /** + * Code to execute when the button is pressed while the mouse is in the + * canvas. + * + * This method is in the Paint class so that it can access and update + * the state of the paint application. + */ + @Override + public void mousePressed(MouseEvent arg0) { + + mode.mousePressed(arg0); + canvas.repaint(); + } + + /** + * Code to execute when the button is pressed while the mouse is moved + * with the button down in the canvas. + */ + public void mouseDragged(MouseEvent arg0) { + mode.mouseDragged(arg0); + canvas.repaint(); + } + + /** + * Code to execute when the button is released while the mouse is in the + * canvas. + */ + @Override + public void mouseReleased(MouseEvent arg0) { + mode.mouseReleased(arg0); + canvas.repaint(); + } + } + + // add an action listener that specifies the code to run when + // the button is selected + private JRadioButton makeShapeButton(ButtonGroup group, JPanel modeToolbar, String name, final Mode buttonMode) { + JRadioButton b = new JRadioButton(name); + group.add(b); + modeToolbar.add(b); + b.addActionListener(event -> { + mode = buttonMode; + preview = null; + }); + return b; + } + + private JPanel createModeToolbar() { + + JPanel modeToolbar = new JPanel(); + + // Create the group of buttons that select the mode + ButtonGroup group = new ButtonGroup(); + + // create buttons for points and lines, and add them to the list + JRadioButton point = makeShapeButton(group, modeToolbar, "Point", new PointMode()); + makeShapeButton(group, modeToolbar, "Line", new LineStartMode()); + // add more shapes here + + // start by selecting the buttons for points + point.doClick(); + + // the checkbox for thin/thick lines + JCheckBox thick = new JCheckBox("Thick Lines"); + modeToolbar.add(thick); + thick.addItemListener(e -> { + if (e.getStateChange() == ItemEvent.SELECTED) { + stroke = thickStroke; + } else { + stroke = thinStroke; + } + } + ); + // start with thick lines + thick.doClick(); + + // exiting the program + JButton quit = new JButton("Quit"); + modeToolbar.add(quit); + quit.addActionListener(e -> System.exit(0)); + return modeToolbar; + } + + public PaintF() { + + JFrame frame = new JFrame(); + frame.setLayout(new BorderLayout()); + + canvas = this.new Canvas(); + + Mouse mouseListener = new Mouse(); + canvas.addMouseMotionListener(mouseListener); // dragged events + canvas.addMouseListener(mouseListener); // press/release events + + frame.add(canvas, BorderLayout.CENTER); + frame.add(createModeToolbar(), BorderLayout.PAGE_END); + + frame.pack(); + frame.setVisible(true); + frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); + } + + public static void main(String[] args) { + SwingUtilities.invokeLater(() -> new PaintF()); + } + +} diff --git a/Java/M3-code/Point.java b/Java/M3-code/Point.java new file mode 100644 index 0000000..87f6bb8 --- /dev/null +++ b/Java/M3-code/Point.java @@ -0,0 +1,31 @@ +// NOTE: this version of point is immutable! +public class Point implements Comparable { + private final double x; + private final double y; + + public Point(double x, double y) { + this.x = x; + this.y = y; + } + + public double getX() { return x; } + public double getY() { return y; } + + @Override + public int compareTo(Point o) { + // TODO Auto-generated method stub + /* + if (this.getX() < o.getX()) { + return -1; + } else if (this.getX() > o.getX()) { + return 1; + } + if (this.getY() < o.getY()) { + return -1; + } else if (this.getY() > o.getY()) { + return 1; + } */ + return 0; + } + +} diff --git a/Java/M3-code/Quine.java b/Java/M3-code/Quine.java new file mode 100644 index 0000000..4974b3a --- /dev/null +++ b/Java/M3-code/Quine.java @@ -0,0 +1,20 @@ +public class Quine { + public static void main(String[] args) { + String[] str = { +"public class Quine {", +" public static void main(String[] args) {", +" String[] str = {", +" };", +" for (int i=0; i<3; i++) { System.out.println(str[i]); }", +" for (int i=0; i<10; i++) ", +" { System.out.println((char)34 + str[i] + (char)34 + (char)44); }", +" for (int i=3; i<10; i++) { System.out.println(str[i]); }", +" }", +"}", + }; + for (int i=0; i<3; i++) { System.out.println(str[i]); } + for (int i=0; i<10; i++) + { System.out.println((char)34 + str[i] + (char)34 + (char)44); } + for (int i=3; i<10; i++) { System.out.println(str[i]); } + } +} diff --git a/Java/M3-code/Streams.java b/Java/M3-code/Streams.java new file mode 100644 index 0000000..fbfa583 --- /dev/null +++ b/Java/M3-code/Streams.java @@ -0,0 +1,47 @@ +import java.util.ArrayList; +import java.util.List; +import java.util.Random; +import java.util.stream.Collectors; + +public class Streams { + + public static void benchmark(int tests) { + System.out.format("Sequential Stream - "); + Random r = new Random(12345); + List s = new ArrayList(tests); + + for (int i = 0; i < tests; i++) { + s.add(r.nextInt(tests)); + } + + long start = System.nanoTime(); + for (int i = 0; i < tests; i++) { + s.stream() + .map(x -> x * x) + .reduce(0, Integer::sum); + } + + long stop1 = System.nanoTime(); + System.out.format("%4.3f%n", (stop1 - start) / 1000000000.0); + + System.out.format("Parallel Stream - "); + for (int i = 0; i < tests; i++) { + s.parallelStream() + .map(x -> x * x) + .reduce(0, Integer::sum); + } + + long stop2 = System.nanoTime(); + System.out.format("%4.3f%n", (stop2 - stop1) / 1000000000.0); + + } + + public static void main(String[] args) { + + int tests = 100000; + + benchmark(tests); + + } + +} diff --git a/Java/M3-code/TreeSetExample.java b/Java/M3-code/TreeSetExample.java new file mode 100644 index 0000000..2dfbfd5 --- /dev/null +++ b/Java/M3-code/TreeSetExample.java @@ -0,0 +1,22 @@ +import java.util.Set; +import java.util.TreeSet; + +public class TreeSetExample { + + public static void main(String[] args) { + Set s = new TreeSet(); + + Point p1 = new Point(0,0); + Point p2 = new Point(1,1); + // s.add(p1); + // s.add(p2); + + if (s.contains(new Point(0,0))) { + System.out.println("s contains (0,0)"); + } else { + System.out.println("s does not contain (0,0)"); + } + + + } +} diff --git a/Java/M3-code/WordScanner.java b/Java/M3-code/WordScanner.java new file mode 100644 index 0000000..045aa80 --- /dev/null +++ b/Java/M3-code/WordScanner.java @@ -0,0 +1,58 @@ +package histogram; + +import java.io.IOException; +import java.io.Reader; +import java.util.Iterator; +import java.util.NoSuchElementException; + + +public class WordScanner implements Iterator { + private Reader r; + private int c = -1; + + public WordScanner(Reader r) { + this.r = r; + + skipNonLetters(); + } + + private void skipNonLetters() { + try { + c = r.read(); + while (!Character.isLetter(c) && c != -1) { + c = r.read(); + } + } catch (IOException e) { + c = -1; + } + } + + @Override + public boolean hasNext() { + return ( c != -1 ); + } + + @Override + public String next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + String answer = ""; + try { + while (Character.isLetter(c)) { + answer = answer + (char)c; + c = r.read(); + } + skipNonLetters(); + } catch (IOException e) { + throw new NoSuchElementException(); + } + return answer; + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + +} diff --git a/Java/M3-code/WordScannerTest.java b/Java/M3-code/WordScannerTest.java new file mode 100644 index 0000000..fdca03c --- /dev/null +++ b/Java/M3-code/WordScannerTest.java @@ -0,0 +1,73 @@ +package histogram; +import static org.junit.Assert.*; + +import java.io.Reader; +import java.io.StringReader; +import org.junit.Test; + + +public class WordScannerTest { + + @Test + public void testNull() { + try { + WordScanner ws = new WordScanner(null); + } catch (NullPointerException e) { + return; + } + fail(); + } + + @Test + public void testHasNext() { + + Reader r = new StringReader("one"); + WordScanner ws = new WordScanner(r); + assertTrue(ws.hasNext()); + + } + + @Test + public void testHasNextBlank() { + + Reader r = new StringReader(" "); + WordScanner ws = new WordScanner(r); + assertFalse(ws.hasNext()); + + } + + @Test + public void testHasNextTrailing() { + + Reader r = new StringReader("one "); + WordScanner ws = new WordScanner(r); + assertTrue(ws.hasNext()); + assertEquals("one",ws.next()); + assertFalse(ws.hasNext()); + + } + + @Test + public void testHasNextPunc() { + + Reader r = new StringReader(".*#^$#$"); + WordScanner ws = new WordScanner(r); + assertFalse(ws.hasNext()); + + } + + @Test + public void testHasNextApostrophe() { + + Reader r = new StringReader("don't"); + WordScanner ws = new WordScanner(r); + assertTrue(ws.hasNext()); + assertEquals("don", ws.next()); + assertTrue(ws.hasNext()); + assertEquals("t",ws.next()); + assertFalse(ws.hasNext()); + + } + + +} diff --git a/Java/M3-code/mandrill (1).pgm b/Java/M3-code/mandrill (1).pgm new file mode 100644 index 0000000..79d6188 --- /dev/null +++ b/Java/M3-code/mandrill (1).pgm @@ -0,0 +1,326 @@ +P5 +512 512 +255 +I*`j5?JTu?ʊJj?`j??TSI_T>_4?>uUTukjIsT?`jIS?)U`uUʒI +*)uT_jjsuIʩ3T`r}S>U__>IUS)jT_I_>5I`tjhSj?\>?uɓSIɳsS_IIUȴӝr]`>)ɳgQ\>S_t3>`_SuSjɒQ_Iɳr_j_SIӝɾ>)TS>\jӝʳr_ɨhh_]I__Str}^)IUHhjhHj}3Ijj}ɳɾr}huhӳssIsIu~>T`jIjɩԉsɩөIjTԴ~j~ԉʞhɞʓʴIsI`IIUT?ju*IUII4`IIj4*)44JIsIjIjʊI`)*`__TIuuʩʟsIsuIjjjIʩ_jII>II_u___j4usɳhTԳޒ}s\TITtɳSISth_hIIj>j_>_St_ӨS_I\}}ӓSjjssSs\4}>I4>`hɒ\II_jȒ\_I__>}3\rhTrshӝɳsSHIrjɒɳ}rӨr^_}rh\hs}_SI}ShjhȳS344IԳԳS}ɾsTSgjj_>jԝʾ^޾hɞsԴԾsgsԵʓSJI45TTuTITu45jI*?j45J)**uk?II4T`j4`ju_SIjI``jjTSj~T)sIʴ_Ir_`_SST_)Tu޾S}ʴrrII_sɝhST>j>I4uh_uI>ssjS}hɳɳsh]s}S_ShStɾrɒH]44I_rS}\ȒhSsHhSS\tSIIɳ}ӳsthS_}rIj}sj^sjjshӒSISɳ}\Ijt}IIIjTӒS>jS}ӨӨ}}<)IȾӒsɳ}_sS_TS}tsh޾j꾓࿒}꿓Դsɳs^ߴhjIuԫ~j)*__Is_susT?u*U4*I`I4?)*j)***I4~4j`Ijʟ>uj*?IUIsjj^IUShj_TjIu}j_ʴshH_ɳӝ^ɩrjjhh_ʾޞhj>Srs\Iʒhh44_}ɞssɒs}SI_ts^jjsTS_}\I\___SI\ӳ}}}S_`HtsSɒrhȒsӒs}hsIɳ}IHIjhIIIsjhrsuhj_SIISjrsIII\>>III_jɒS4I_ɳ>ITӳ>IhԳshj4IӴhssԒޝsɝ~ɓԓԴjsɓsITjhTItjIJIT4_Jj4?>jU +Ij4)I4*ʿ)*jʴjj૊jI4???_sTI?ʫ^ʉjs)jsjʉSɝhɴ}^ʒɉɳ}HjjShQ_h_4IIމ\IԨSI>_S_I)Usɉr3_rh`hh_\I>`I>_`_Sj>4I)?H?_HI_h}sIh}ȉh_sh\Ȓȳ}ȓSI_ssӒhshjII\IIIjsI__h_II>II_Ishhshj_rIIIIԳhSSrhhhsӳӾӨȳ\jӉ>Ijs}ɾs^s4jʉs}Գөsjɩ^ԈմsjɉujjԈsʾԩ~hԳSIsj_j?jssII__TUIJj*4I`uIU4)*TJT)4*II?sIJjvsITɿjuI4?ʫsjjjT`_sʫIIɩhɓ^j޾Ɉsʩhr곩h_ɩSI\Sth}I>)j}rj_hԇS_rSjSj}ɩS4IS_ss_tshjjS>)hShSIITIGI_\>_rS>)j>TIj}__)jIrӨȳ}srrS_rs}}hSSj}hjII_tsSI4_ISIT_>__4_Ss}}h\I)I3_4jɝӾӝ}޳s34_IjGIg4_ɒԒԾ곓gj^I_u_^jʴ^jIԴɴ_u_juTIԓjTjjT?_44II?IjIj_JI`TIUII?4uߊ4?T`ʊSʓ_uuʓSUʴIjsjj?U~SjjʟSu>ʓ}hjSʩSɴshsjI\ӳs_jhsjrh__I)`\_Ӿs4?_ɳg_sSɳɴhhI_hsI_Ij>s_StH_4rIjI)IIhIS}hHIIUӒsHTTj>>>*_QIuTj>>Ijɝ}_hIsS_jjSurh^ItSsh_I_Ө}}sjjjj_4I?I_rh__>4_u>IIIIIshhtshSughtShjrsӳ}Ӿ޳}j_4III}sɇS4ԝ޾SԾSjԒSԓusIhuʴs_`jjIjh^4ԾԊTtsI?`3*uj4IjuTJj4IT?jjjj_T4`4I~TʊIIjsuIh)II?_>juԞs_IShӒIu)TT\jjhhʝ\Ӓɾ}s_ss_uHjI_jStI>4UjjӒS_T_\jrɾɒ\Sh_IIU>4?__4T_IjIjSIt^\>4)>}hhj_SjshI__I_]S`tHs]_rhS)?_sSs^tS_S_hhɳɾs4ItH}^_SIjsIɨӳsSjSIIS_}jhh>I_I>?II>TIjhSTIshH_Sr}rӝȾr}S_jH_}ɉsȾsjSI}೩꾳ԩssjsԒS_ɴӴsu߿jԴjj_ԉutʾSjuԳTj}ʿ_jII5t44Ik?JTj?`_jtjjSju4_sjʓjSI4J`ʩITjs_`>ʞSʓjSɉS_thʩsS޾\Iމԩ\hj_tShs}SI_ht}sԳhjSjshsӳɒh\jS)I?I)?I__I)>ush>J4IhhIjɒsh}_jst4_>4U?45I_?>jgh_h\)IUSIIT_IIjhhshju_\_jhSI_I_s}sI4>T?4IIIIhhhssh>IjIr__h__hI_S}_sh}h}ȳӨ\Ishޒ_~޾ԝs4Tɳsj4j_Ӿ}ʞʴӈԝTTsޓTIsɓɾSIjʿsSjsI_kT)**?jjTʿTj`ISjSjJI`j?ʓhsʊɫ`jsshjS_SjIʟI5s_jsԾɩӉS_ɩrs_hrhSr_SʉsI)*jSj}s}rS__IIIuSI4I*Ijss>jHI}jhI\grs>IUITTI4>UII_sthHQIII_II_III_hsSS_}}h}SjS_ISI_sIItSSIIIIIT}SII_SI_j_S)JI>IIȇ^jtsjshӳrӨӳ}g4jިɳӝ>IIɾssԾ\ԓ߾^sj>jɩs4TusԾsԒSԓԞsԉɨԳshɓʴߴ^TjԴ^IjjTTT4J4JI`kIֵʕjj?jjʴuIj4?JU듟ʩIʊʫԴIsjhjɳSIjjII>uIj)I_IJjʉ\}ӝhssɝStj\hT_Th_sshԴI)4IIT__Sjjs}sjh_js}II_jhSI)5)USIIQh\Ih}\j}s_>_S>u__HS?_IthIHIuhI?tIII?_I\III_tsjhTIjIjI?IItj_I4III__sT_ISIrhI}IUjjhIhI__hSIII߾rsgrsrɳ곳sɾ\Iȝs>4Iu}g_\I_hIӝs^_sʝSsIj꿨ss}ԩɴԿɉԿԴԞuT^>?j`j_IjJ +*j*j4uʫj~u~ɞjʊI`_j4ʩ_ԴjjɴɓhjSIJ__թS__ItT>?_t4>}ɒ_s_Գ_ɳ^_sshI̾Qj}}\uSIU__4Ij4IIIThsHjhjIj_HjT_II)I_Ist\t}hsIIjII`__H_II_jS_jgtg___j_jIIII_ITtjt^jI__jS)II^_I__s>_tsh_hs_I_j\>TIIɒss_s_III_Sj}hHI_}H>_}sɒHshgިӒh钉h޳ɳrS>TU_hsӝS\ITj^ɉsj^g}ԴʴԝɫHT?~uvuTjjsH?_IJ_TU_JI)?jT4Iu_Tj^ʓʉj*ʴ}Ɋj_֩ӫʞS?I_jIɾh}hʩH>)uhS4Ӓ}_jj_IjT^SII\gɇshhh_sSIjS\tjS__sS}SI}SII?III4U4ItSI_II_jShjjhII?I?4U4>`4>**US>?j_sTtSIjIjII_UII?I_H_jHjSI_u}SI>I__rSI___S_ss_hS_T_j_I_Ij_ITIS_h}hshshj_}S}SIhɒӒhӳ\Stӳr~sjjIs>jԾss4u^_jɈ_ɨsԴsjsɩTIgTԿ޴~ԩԇ^I^jTjkj`Ijhs_jItj*u)?4?uT*?uʿj_Tഩ^jITJjʩɾj_?jԓԩjII_tjӟԒs}IIIjӝs}SsThStSI_<___ԳsshsɞSI5II5jT_}sɨssss\Is^4?II>*)4?Iu}hsSITSjIj>4?I?II)*_4I>J_?I*IJII?>III_tjI>45_II_I?_jSIIs}rI_>TIII_IȳST>}h}sSI_II_>I_shhjsӳt^}hSs_^_ӝ}}SӒrs}r\T>Ӓgj}sjjɈԈSjTʴsSԾ^TsI_ʴԴ߉SuԒsIt_I?_`ujj}ɟsʟ_jT*ku)JTIIsʕSI4IԉjjjUhsʓjԩt_T4ɉʫs괩ɩ^_}ʩsʞhII_hT_sSʳrStӇS_}SrsIu>ɩ>5IU}34?IjIIISIrSIUhSI)?IIIIIIIII)_rSI_j__jI?I5?5IjIIj___S*)I5tIIUI_IIIUI_>)?I?I?_I__s_hrhjh>I?It}Ȓ}>I}ӳsh___}hIshTjsthShhStIjssTssӾɾӳ\Ȓ}sS}sөhS4u_IuSIjԾs}T`jTɴɝɩsjjsɴ֓}sjs_s?ɫsuԓSjIUTu?*?uuj`TUԓjIuhjjjʿɫjʩԫII5Ijɟsjʫ~_tɉɩthjjSusSTjtgtʩȨrhs^_ɨSI?jII)_I?I_j>4??>?I_h>_usI_4_>4II)?II?I)*>I4>jIII_4>j_SIUjI_4_TI^54)*534_UhI_III454>?__jI_>III\j_sHHT_hhSrhȳhhjȳȒsS>TӳjhɨS_SIIɝsSɒr^Ӿӳ}ӳɝ}޳rɒ}\jTs^Its^*_I4޳s߾ɓSjSӾuމIj~ԴԴ^jԈޝ~ɝsIʩ~IuJu>jIuu*T +*I*T*__uj>u~ʫjIsIII`sʉjʫ4)Uus_juSjjɴ^ush^S_jH~_޳өs}rɩɳh^h4IIIIIIII_I_ISS)4)*)4?_jjthhI)4?_I44II__>4I?4>?}III_hIjSI)4?I?_S_I)*)?hS?I\>4I*IU)I*IIUIIJT?>IUSI_j_h_hIj}}sȒȨrSӳ}hS_jshS_ssshsIӳӳɨ}_rӝȨ\ȳ}}sS`_jI_\4I4IӾ޳sԝ~4jމɴsʊj4?ԩɾ~ԾԨhԴɓ4?j`jT_UjI`J*>`I?IIIjIjIuTIT`jʴsj봩sII_h^__ԩssԒjhSsɩhʴhs_StӨɒ}h\sh^HISIjsjS>hh3I5IIjShI4)))>4I?)4?Ijh4)?IIjj_>IIIj}r_tSj_j^_jTSIT_4I?II4IjjhHS_>III54>`I>II>?II>IIIU__IIIII_hI__\hȒȾӨgj}}\_}hhI}}hIIIIIItɒ\ӝsިԒsSsӳӨɳӾӳsɳhIIII_TTs>?4)`Ծ}^Is޳~>?ɝsssɴ^4?ɓޓɓɩʞԓjj~T_IIuIU_4)?Ju`I*ujj`4jI??jI?IʕԞʴʊ~`jԓԩhuhsIIjɴʴ}꾩_]I_ޞ}hhIIȳr\>_SI`}S}Sjj_ʴSII4IUI__SjHTj_t\HI?44ujIITI?__IhӳG_IjII4U_IIIjjh3?4IUIT_sjtSIIUII?)4I5T_>I>?II>j___hH_IIUht}hrs}ȒӇh}Ө}hhȝӳ\sɳrThT_hhhȒȨɒȾޒɳӝӈsS}ɨȒrjss>?TIIujHI?I__4IjԝɝSIIj}4IԾʴԝԓuIUʴɴԴsʴԴ_I??_I?jɩԩ4)?*j`>*I*I*II44UuIjS_kԝʊjɫʴɟ_jʩԫɫ>IIIjTԩʞɓuTIS)JsTɾj>IITɳӝɳȳ~hɓhI4Ij_Sɳ}}Hh_>ThsshIjI_t>II`thj_^IssS?I_IIII?IIItrh>IIIhS_>IItsIII_)_t}S_IS?_Itj]II_trsh_ȨȒӳȳӳsȳhjSIIjS__ȳ޾ȳӒ}Ӿ޾鳒}S_}jhTtɨ\jh_tthjjjI`_Sj_}sSjIjɴ~4IjɴhԴsjjuɓɴԩ~^`I454UjIsusɓ^j^>J4T`T4`I*I?_jII_s4jʴ>jԵjʴjjuTsshuԴhIj__Ij_ʴS4_SS_I_ISӨhI_IItɝ}_ɩ}jS__hjHI_hjIhS^I_4}jIIjS54)?jrSIjr_SS\_^I*I?I_4ISITII>t}QIS_UT_IhsSIII_hj_s}ȨȾȳs__h_j_Ij_44III4>jɳȳӳȳ}ԳSSj}j}hsjs]s_h}}}}sh^ɩh3IɴS__sjj}^jhujsTɉԿ~jʩIjj`_ujuu_kjj_IIIj_u}ITtT`__T?4*4uI*4`j4?Ij`sjԊSʟsu_uɊ_jsh_I_ʉj_IjjIhTT^Iɩh}ɒS>uSjhjsI_S\I}HIt3_\rTh_j}r_T_}h454_>4?j_4jIT_ITsjs}rSSTIIj_I_^HT_IIII}H}I_j__ss}hIIuhS_j}ӽȳȨȾӨ\__}HII4II4IӳӒȒɒhɳȳssj^srs_sssjssSIT`s}sIjjjsuS4j^ɴshsԳ_sjS_IhjSIjssjIjIUjj)*4```I?I`kTI_sTIԫjʕT_IIɟʟ^੫_sjsʩɞ4?I`?_Iu~S?IhIIsh4sII__]IIIjQs\j_ȳI^>4SS^_hsIII*4?II4?I?_I)4*>Tt~\_gj}}shSTIjsj}}jhj}sI_SI}SȞSS>}h}hӇȳȨȽȳȳȒȳɨӳgjII4_ɳȒrsɾ}hjӒިr_Is^S_ȒssjsSTsSIIjI_Ӓssjɉ^IsST^S_ɝ^_ɓ_4I`jԩɓ_jԓSj_ɴsj_ss5?I*4?j4I`jkIJ?TʴʊֵʓjuɊujʿʊꩉjɳsɓS`IUII)4?_jHkII_tsɝhSts_}Ih_S_}Hjj}}StsTjh__I)4?45I*jS_h44_j_jrɳ\ɒh>T}jtgSItshhshs__tSt\hȒ}SIjSsȒӳȳӨsӾrtSITjӒr}hjhӨӳ}ӳޒs_sts_hӒr}ST_SSIIII_uɳ^IIsS_T4IIhsIIɴSj`I_T_ʓ꿴ɴ꾓s_Tɾsʴ~j^Tjuu_ʓj_I4?*`?j?j*IʴʫITԓsʿʟjIjʓ_ʫjԩjsɩS>`_jjʓh4I`_Iu__3*?IsSȳޒhsh3tsԳg}ӳ\j}TS4__jjhjr>4j>IjI_?4I_Ss_TjSsh_ɒs_\}tsh\jh_rh\I}ȒȳȒӳӳ}hj_}SI>IjIӳrhu}SӳȳȳSII__^IIj}hȾȨhjjhSTtsjɒSIjhI^tjh_)JI_TSɳ>IIjsshɾsS4IީST4jI_uɴɳɩɓ޾ԴԴɴ~S_ԩIjjjukI?j4I?IUjI?4?4J~jjʫjIʴʉԴjhIjөɓsԒhItʟs)IUII*ʩIuj*III4j_4T*j_ɨhSs^Ө\h^r_SIjIɒS)45jj}4TshS4>U4_jsjɳr)T_j}hȒrSsɒrjs_I_j^>}ȳȳrȨӾިӳhhhtS_h_II_II?I)4>I_sȨ\trh}hjSIj_S__SI_T_IIIj}hs_}^__T?Ij_jIIIIIT_j_gSIjT_IjITS_4?jsjɾ}SI?T4Tԝ^II*`I4S?IʩӴӳɩ޴ԝ~꾴Ԟɝ^ITIjjjsIj?_jJkT?J)JIʊu>*U_4ujTJj__kIԩ^ɓʩj࿴Դjuɿԓj4I*jjh_I_j_I4?_TI4TIrj_jj_}SSɒhsjSS>sSj_S_jSӳ}sSIsޒhshI4IS_IjjsSssɝ\ɝ\}hӳӒrHT__I_uSӒӳȳӒӳӒӝȝIIIjj}hII_tII)54*IUrg_hT_rhT_>TTIII4_IIIItsS_IIIItI^TT>I__j_I?jII_IIII__}sI^I\TIIjSTjSTIITIIT_ɾ~~IIT4*jɴS?I*II4`^_ԞhjӴԫjԓӾꞈsuԩsI?II_TTJj?T>IJI?IjI*_jT_I_`_tjuʞsIIuʴ_shTTTɉjIjʩɴHI__?ss_sj_I4_IStjߨSIIjIIjs_h__sjɒ}_ɉ\t\}Sj_4IIjShshjsS_SȨrs>II>I_Uj_IIIIThsSȒ}gӒ}Ӓr^Ȓs_II__I__\hӒrtȳӳӳӨshS>j__HI_)I45I__h}ssIjj}S_I>IIIhhI_shI_sS_IhShII_jjhIjhI_II_?jIII_}SIT_STIIIIIII_j_ɳsSII?IIj>4?>?>`^I_jI_u_TUhI?s_sTITʾԩhɳ곓ԩ괓jɾ}jjTtTIju?j*I5IjTjjʟIII_TIjjI_IjִjtTjjʊ^Ihtj`ʉ^jj)uTjJT_ITIjT`TIjԩsshITj}SI_I)4Ih^Ij}_sSsSjjIIj\hS>4)*I_h_S_3^S)`I4?III4)_SS>jt^I\T}s^hsӳӳȝӝ޳\hIT>k_Ijȳ}rӝ}ӳ}sstsSIIIshjII?I>4II_S_j_sI__jhShSIIIII_Ijh_hsIjSI>UI__j}hIIIIj}_IIIIII__IIjII_`^jT_III?IIjItu_S)_IIIIjI__jIT_TjjItsjT_}S`jII4޴sj4t`jjTIjjɴɿɴSTjԩɳsuuj__JjjjsT_j_)JI`)I?uuj?TʕIIjTh_Sjʴsj_jT?ju`uhT_jSIj>uIի4I_J_jhHIjsIjjT_jIj_I}sj_jIII_IjII_S__tII_>jSh4_SI_S)_Ij_hI_IIjI_4>I?>4?__IIIj_I4_TSjS\gSTjӨިӳɳhjhI4?IIjj^ӳӾr\jssSr}H\^tIIIIIt}S__4IIITIjjjhT_SSI)I?II?IIIIt_SI4II4IIIIIII_II?I_IIsI_}_hII_II_IIU_II_hT_I?IJITT)hT?IJIjjIIT?III?h>4~^TITITԿ~jTjjjITɴ}Գsʩɴ޾uɩ~~ԉj_j`I?*_`jS?Ij`IITu?I?I)Tsjɓj>jԴʉj_?T5I_j`ujԩ_I_ԨjʓS4ujjII_TIIjIT__4IIjjhhIIIII_SItrI>___sIIS_jts}h_h}}>)*?_j_hIIITI>uS4I_?II?IIS>J_)_ITTIS^gshSIHjsӾȳ}hӾӒ}]S_TT>_Ihh}}}SjӳhSj_IT_II_II`sjS>4?I5tI>I_I_TIjSjt}hS_II?I_IT_II4I?II5II)IIII4II)*_?jII_jhjIjtI_I?IIIII4?_II*4?SI4?>I4_?I**?TITITTԴH4?II)II_ɴ^j_u_Tjjs_SIɝӾԴsꩴsjɴsԉj`_III>Ujj`4kTj`4TT4>hu_ʫjuԩSʩS_uj_ԓj_jIӓɟII_jhII4)?4I?S_s__SSSIIj_huh^I}h)4JtS_}h>IuhIjjjthS__)tjhIHIj_hI_4I?44j?sS>IIUI_jjS4)`jh_js_rSjh\ӨȨӳhhSTӳ}STsSjhjSj_I_I_J__I_IT)?I?ITjj__tSjssjssj}s}s>IIIIIII4)?_?IIIIJ_II_ITI?III?_S?UT4I?IT`)I)?45]4?I?I4)?II_4IIII?I_TII4I)>*_j_j_ISI4I`jTjju}sjɴԴ~SjITԴshTsIIjIJIu)`ujj_h4??IIʴt^ɴ}봿Ծsj_괩sʴʴIIujj_jjIj?TTITusS)5I?I_IjjujI4U_IjsTIII_TtII4Iu}hT>jIITITH>5>44>?t}>ItSthhhIj>?j_II4>?h__SI??)?4IITI_>>*))?4IjSsSs_Ӓɝ}ӨhT_I__jSuhSThɒӳ}sSSS__4_I?I?T_IjIIII>UTIIj}SIIIItsSI>I_sS_j_I_I__4>IIIIjIIIT_jTIjj>III)?>IIIjII`jS?IIj_IT?_I?TI*)?I?*I>I?jӓs_sII?T_ITIJI)TI`uj4IԓjTj_jjjj_ɩɓ޴ԩԿjjsԴɞuu_ujɴ_jujSjɟSuj4TuJju_IjuU4__ԓTjɓIsjԩsʞjɩ^j*jIIIj_I>IT?I??5jI5hSItIIIIII4U_jI5`sI_III?_I_\IIItsSI)I4II?_II`)>?IjSTII}}I_thj__TIII`_TjI44I?II?I5I?I`_II4IIjhTj}jSsSHj}rɨSIhjj}S_h_hII_jHjsȳ}hjjhI?I_j_I__I?_II?>`jI___IjhjSIt__SIj>Ij__T_Ij_s_j_s_hIIIUT__TII_TtsIII`_T_>?IUTI_I4I*>?I?TI?II_I4_SII)4?T_s)I*I?jtIjjsj_jIII?Ijʓ~ɉɿԴԴԩɫʫsɩ~jITuԓtjj_T_uɳSu4I`TjkjIIT4ԓjʴ^IIԴhԩɓjj_`ʴԴɩ?Iu_I4*?>?I>?s>IɉS_I_II4_uIH4I>I?_TIIIII`_II___I_IIII_I)T_sH444*)?_4?IJI_TI)?TI?TIT4I`II*4*4?4*?>?_UTIIII?IIIII>?I?II_jTs}S}h\_j}shIrӒshIT__jhshtSt_jS__ss}ssjSII_J_IJ_UjI_II54I>jj_jI>`>?jI_Tj_T__IjIII_I_I>_IIjj^jj_I_jIIIjT_jIIII?j`jjT>J?4U?*>J?II?II??II?I?I4?5?III_t>IIISJ_sjs^jԩ^I?`IIJITTԞɴjuԿuʞԞԴssITjIIJIujjԴuju_TTjTjIIjI`u4?U`4IJ4?_ʟIʴuJʩuTԝԴsj_juɴɩ)I?_?5))IU>ITIɩSjhIS\4Uj_4IUj_II?_I)TU_II_I>?I4??I?jI`IjjSIUII*4>*I*I>?II??4?*?*IJTI`j_jIIU4?5*I?IIU_JII*>*IIIII_jSIII__shS_\jh~}}]s_4IȒS>IT?I5I*>_^I_jSrSI_hIjITj_TII_T_IJ_Ij_TUIIUj_T__j_T_IIjI_s_III>II5I?>??I_?h_I_IIT_jhj_jIjjI?IT?II?_II)?_>I4?_sT_III?I*I44?I4IrS_jh4>4?IIIII4II?_4Tusj_jjIIIjIjuuɩԞsusIuɩ괩sTIʴsI??4?uII?jjI3?I)TʴԟhkhuIJ_jk`TԓԒԓ__jjԩuUIUj*)Ih>4)4III*jɴS4?IT?TI*_4*>*I_T?4?jjtT_TII`IJII?III__SJ4?>?I_II_??I4IIII?4I*)54?4*IjI?IT_JI)4*4??IJ>_J>?I*5?I_TII_ISj_hrhss_hISsj}hjt}h_J4I4JsSj]IS_jjjIj_IjjIj_T_TT_4?Ij?_IIjT?ITI?j_TI?_IIujjIjI_II_II_?IU>?I)?4>II>`II_IIIII_Ij_IIIIjIITII45*I?II?I_jI_I?I_UhIII?jI_HI?4?4UI4_I4>45_T?ITjS?TI4T5Tjsj__}jԴj~sɴԨsɓs~jIjʿs^jIuTjuʴuSɾT)??`u`uT5J_Iʕ߿uuJԴhITuujuʊԴɉjԴԫ~jjIS}^s>*Tuu?IIIIjT]4U4I?45II*5TI??`II?I?I?j4I??4I5?IIII_jSIIII*)UIII4>4*>?*>?I?_I?4?44I?IjIjII_jII5II)J_IT?II*)*5)*_?j_?jI_T_j}sȝs_>IIIjI_S__II_Ihj_II4>IUr}hs_Ij__jI_jI_I_II?_?_IIJI?_ITI_jIjItI_II_h_IIjj_IIIII_>*I)*5?I5IIIIIII?II_IIII_TIII_IIIII_III_j_jj_4U?I??_Ij?t_IIT_TIII?I?>?II?IUIjI4444TjITI?I?I??ITsjTsjTTTTIITɞjʓjIjjɓԩ}j_jjTs_juju4*I?UI?_`j__kJ`~IIʫʴ~SIujs`I`_ʴujʴSTɩjI4?ujʴjhI?I4*4IIt4Iu_3IU_I4>?I?4II?4*II?_jI?4?__jSI?TTITII?I>?I?IJI??IIII?4)?4??4?IIIJI?T_JIJI??I??I?I?TIUII*4?I*IT5??I?IIjI__IIjɨs34)?_SjT>?ITII4IIIjQII)I)_hhȳɨS___T>IT??I_IT?II_IJIII5III?II_jI_JIII_I_Ij_T_ISIII?jI5II5I4?II?>*I>?I5IITITIIIT_ITIII?T_J_4?I*_TI?I*I?4>?II`jh?I4I?T?Ij4?II?I?4*?II*I?I?TI4T?4T*4_4IJIIII?TIUIII_ԩɴsjjjɴ}^_j_jjsIjjI_`IIIjuSjJ_j4?4`kI?JIJu~T4?ɴ~ԾjIIԕsʩʓɳsjjuuIIIII_jjT>_jkj?_j_)IITS_44_`>Iu>jIITIII?II*?4I?JT`_T4*I?IIUTI?I4?jII?4j`I??>J_IUT_??>*4?I4?4??TII?TTIJIIIJII`>JI?I*IT*I?II*I4?IjTIs>_SjIIIII__II>?IIT_h_tH_jI>4?_j}r^_jIIII_I?j>?I`I?II??I?II?I4?__II?_IJ_IUIJ_?I_I_ITIII?_II?IUII?I)`I>?4II44II?_IITIUII>*III?_IIIUII*III?I*I?II4*I?I?4I?I*I*I*`I?I*IT?I4I4JIIII4?II*)?T54I?IIIUsII_ɴөjTjjstɩԴ~󾓉_ɳ^jTjʉsIj`IujjʩSj4`uʉS4U4?`ujjʊIIs`tSTjɴju޴ɫԴhII4U_Ij_ӒhsIIIjIj`jjɉhjI54IJIJIj4I4JjII*?*jT4TTjSIITII*>*4?*I5?I?I?I??4?4I?II?ITUjIII4?4?)4*?IIITIjIII*I?IIU4III?I4*I?>*?IIJIIT>T__IIIII_Ihj_sjII4I>?tsjSI?I?I>?IITjȳhs__T_sIII`>J_>?II?4I?`I?_?II?II_IJIj_TjT_IIITIIjI_IT_II>ITI_III?I54I*)5I4I?)?I*4?)?>jIIII?4_*I?IIhjIj_TI_I_III5II>45_?I>4?IIhS5I*?III4?_T?IT5I?4_II)TɾsԾӨs_SjɴɩԴsөӾSITsujuԉh4J֓S4Jj`uIʊT_Iʴʴ_T_jjԴujjsjTIIjUIT_hhS)I`Tjj4)5I?4I?I?_II_JI>*I4IJ_UI?T?I*4*I*I4*))J4IIU^I?I?)?II5IIJ4I?I54*?III?I?II?I?I?I_IIII?II?5*I**IIII4III?IIT?*I*IT_IT?4?IIj_hjsthS>*I?4I4T_I_?IIU_II__?_jjsS_TI_I?IIII?*jIjI?I?I4`I?>?II?T?Ij?IJI?T5I?4II4?I4IjISI)II>)*4?4I)4*I)III>*>4I)4)*4*>I4IITIIIIII?II?III4?IIIIj4Ij__IJ4IJ>I`h)sII_I*_TI_UI4?4*T4jIJԳ޾ɩɴԴjj鴴~ӾsI_ɩɩjj`jɉSk4`Uuʴ>?ujI?TI~uTju__TjʫjsԓhɴɊIIuT_*jsII_Iɴs4)4I)*IjII4*4>*4)5IT?4?I4ITI?4I?jII4?)??)??I?I?45IJ4jj4?I*4?*4II>*>?4I44*I*I4?I*TI4TIIT*?IJII5I4I4?IIIJ454?IT4?I)*4)_SITIjIII?IIj_hs__TIUIIu_S_T_T__I?>Uj_t_SI`h4I5I??II_IJII4?4?>*_?4?4?I4?I?III)?44)?>*)I)IIII4?IIII>)>*II>4>**I4II?)?)*))*45III*4II?>?*_4*I*?*IUII`\I*I?j_II?)?IUsIu>TI*III?4?jI4IIITj?TIITIsI_j44?j~ɳԴiI?_ԩ~I_j_jɴԓ޴jӴԓII4?I`IuII4T`IJT_*uuԉԩsuI?ɟʊs__TuuuujuII?jjII_S>*4?I`_44*>TI4I4>?4)JI?I?_*II?I?I*>*4?_II44*>?I>?I4?>54I4?)*>?T?II?I4?I*>?)?T?4I?II?I?III>TI?T_IT?II?5IIIT4I?I_I*I4?jusjII4_?jIIIIsjS*IUjIjIII?IUI?I5I??IIUjII?II_?I?4IUITuhT_ITU4*>*I?I4?4?I>*I*?>*4I4III>I4IIII)I>III)I4>I?IIjjujJjuuI`TTU4*)4?)*I5)I44I*)?>*IIjI4IIIuS4?II`I_IIII>45?IIII?II?IITIIII?TI?II>j`hT_hI_III)ju޴~_I45Iuj?ɿɳɳɴ޾~jIsII?T??Tjj~jjT*4?ujj_J5IIIITjsԩIjTʓjIIIj4III4?T`I4JjJ4>*)4III?_t4II454?III*>**T?jI)T?IT_TI?jjT>?44?I_I?I>TII4?II?4*5I4?IIIII>I?>4III?TIIIIIIII*4?I>?I*I?II)*I?IIjIIII?IIIjIjUIj_ITIIII4?T_T__II4I?>?I>TIIIT_I?I?4)?II?_?IIIIITIITIT_IJI?4?54?>*45I*I?)?4I)>I>*_II*I)?I)_4IITuukuvuvk5?4?>))5I5)*5)*)*IjS_4IIIIIIIIIIII?I_?)I4?I?)?IIUI45JUII___IIT_TI_TjjST_TuS_TIjujj~_j_uI)UjT_TuӳӾ޾ԓuTjɳjjIj`jI)``T`ujuTU*I?`uI44I4?jԴԓԴSI?ʟsԩ_II_ԩj_j)4*4I4>_}h}h>_hS`jIIII_STI4J_}sjI44?IIII4TI*_4?*>?*I?I?Iu_jIII4I4?I4?III4?)?*)4*II*4II4*I?I?I?I*I?4)?4*II)?4?I4?_*I?I?4I*45?I4?I*I?II?III?j_?I4J>?II_UjII__I>JI?jUI>*I5?T??I??>*I?_jIIII?I5))*5)5*4??T?)II__hS_hSI>I)IIt}sk`kʖTUIjH)U?)?)*44?)4ST5I_I_Iu_I45T5j_II?4UtSI?_I_?II_IIT_sIIT_TT_TIsjsSj_ӝɴɝsӞjԓsuujjjjjȴԳs^T_Iuj_5I?jkTj_kTIuUj)4)ʕjs>SIju괓j_Tʫɴɩs4jjTIT?I?Ij?I4II)5_hɴu4)hhS4?JIJ~>4?I>4**>TU\j4II*I_I)4II*IIIII45I*>454I>*I*III)?)>*)?)*)*I>*)IIIT>*)4?IIII)*II4?I44IUjS4I?4>II?IITI4?IjII?)?I*I?II_IIjU_IIT_UTTI?II?UI5I5>J45II)*II_jjjjjI4)?I4*)*>*))?I)TJshrSI)?)*)I_}ukkkukuvUJQ>45I??>4_4UTj)4?I__`}TIusI44IU_TI4II_jII?ITj_jTITIIIIj_TjThhs^jujԨɾޞhsjɉ_IjJ_jsjjIITJJIj*?Juj?IuT>IIԿʶsʩ^Iuʓ~_ʴuT_ʓԓԴɴ~hjhSjII4>_4I`TjjI4?_^IITjS4)I??4?II4*>*)?)*I*IIjII4IIIIII*I?_I4>III4?>I4>I?I4>*4)I**>*)5)*)*)*)**I4**4?4)*)*>II>*I?4?I)II>SII_II54I?J?*)4?I4_4I4)I)*?II?II_IS_II_IjI>?45I5?I?I4UII5_?IITIIIII?4?>>4I`jsT_j~rth>4>IIIsvvkvvvjQ5)*>*45I?jjS>4?4j`>I*II?I5I4_II?I?j?IIITIITIT_SITjsj_ӴӞӳөjT>4IɾɫԾshөɴSjjj4?u?I*`Tj*TjTjʫԝsֿʫhT_)IIɝԿө4444_hII4III4I>IT}I)4II45)4*)4?4I_IIIIIIjh*III_454?I?_4I?)4)>II>45*4))*4I)44>)))))*)4)*)*4I))4)?)?4IIIII4I4?4II_IIIIII?I4?II4IIIj_I_jjhuthSII___HTh_>II>IUI_II?I?II*I??)5*)*?4Iku^usS}h`tS4I4)4>U}vvvu`<))*)5*)II)I>IU>II>II_II>I_I`_I`_IjIITII?I?_IUTjITIIT_IITSTjӾɩss~ԾޞsjIjjjTuuԾ괿ԊsjjjST_usɓjIT`I`*)UujuIU_JjuT5TITʫu~ʓʓITʿjީIIUʵITJjԞ_))*>~4I)4)IITs44>*>jII>IIItsIIjTIIITI`jI_jIIuS4454)*II_I))4)4>?>I4))*4) +)*II)I) +4)I)4)>I))4)4)*)4)4U4I5)?44?))*I4*>*I))54*?I?II?IIII_T_Ir_jjsshT___I_I_TI5II)4545IJTsujTӨSI)?)4IrvuTug35)*>*?_IjSI?_?I?I`_j_j_j_4II_IIU_I__SII_ITT?II?jIIj^jssTju_sɓSjjjj^jITjɩɴɴԟԴɓtjj_)??us^IIT_tjI44`Tj_jII__j_I`jjT`Ԟ^ʫ_ʊɟsIjjuj}_jjjTjjjTԴT4)j`)II4>_34>*I4I4IIIS>TIu\4IUhII4*I*II))IUHII?I))*)*)I4)>_>I44?jUJT5I*_UJvJuv`uUu`4*)*I*4*)* +454?4I)*I5I>>I))?I*>*)54?4?I*>*I>*>4*)5))54?)*??II?_TjhjIhhh_Uhj_jjI__II)?)II?>Tju}sj\4>I)4)IJuvUT5T*_JUkukӽ)*I_`hhs_II_4IIIIIIIITI_JI?II4IjjSjjjS4`IIjjIsjjIjIIjԴԝ_ɳԴԴjɴʴsII?I`jʉJ?_JUjTIt)?`jII`IJ_Tj_ʩʫIjԴuujuԿ꾴ɫɴjtsjhI4tSIJu4)*)*)IIII_III4>jT4>4I>*4>I4>>?I>*III4)4I5IT)))}S5`vvvvuvvv`T`TU]HI>4>TIj_I))*)>4>?>45I?I>I*I4>*5I4?I_I)I_I?I?II>ItS_}hɳhIjh__jIII?I5I4I?)I?)uuuiTssSI5I)*)>}vvu`I4)*?kugH**)4)II}II_III`I_TI>j?4_4>J_IjU_sIjtSIr4^IIIIIIjԾ}jTjuɓsjT_ITjju~ԞjɫɕjIITjTTԞs_I`jTIIsTuu_IjuuTT?ʵɴTIuɴI_kJjUIjIsuԳʟTj`s4`)Ii_}_)4544IIT4IJSI4I445_I4I5IIII)II)_4?))5u])))*>)4JGJuvu`u`vvU<)4IU}ST>I))*4>4)?)*>I*I_II4*))*>I*I?TITjI4>jthIj__IU?I_IJIj_IIIIIII*I>I`I_TuiISsh_I>))4}U4)h4*_vuӇ3))*IIIsɳhj__T_?ITIUI_j_I_tIIT_jIIIj__TSthShII?_uɩsj_tɴ꿫jjjjɴsjujsjɾsIII?Ijɴԩuj?j`Ij?j~ʩjjSjjʴII޴TII?IIJʶj^Iɴɓj_4j)4?4u}S_hTj~)I_4IItI4I54)*4I4*J_S)I)Uj4_ITI}sII>II)4)545T44)4)}IUvvvvUjvU`vvvj``uU]3))jɒS)4?)4)I4?I>*I?T?>?II*IIjT_jjIIIT_T_I`_I?II?IUTjIIUIIjIIII5?4I4*IIs~_jSj^tII?IIIIIIITȈuu?~<4*IvuݝQ))I?_III_sjjs^t_II___st4_I`}I^jhussSTjɳ~~ɴsTjSɟsSIʴ^IީsjjjIjɊTʴIsjssԴs_jIj_TI_ɴ_jɳԊjIjiIujII4*ITu^II4>`4>*>?I_ɾ3I?4IIISIIjS_I_I>js>_)4>I)?)*) +>>SuvvvUvJT5Tk_kvjk`Q44>?_jIT>?j))4)*4?)?II*I54545I?T_ujT4??I?_IIU>IUI___jI_j____I_?III>)>??Tju^jh_III5)*)?I)I_}>IUG))45}_sII?_IjjSjIII_hjjjhɒsIjIjsIjH޳sIjsjj^IjjɊju___ԞɝhIIIJ_ɩjts~ɉsԩhjjʵԫjʠj_jԩjʩʩsԴIIT`ɓsuITTIjj4II?)ITT4>4I?_>II)I\III_I_sS4I4I4I5_S>ht\>?4?4))4)J^vU44)*IJUvvvv<)4)I_}}jS__)*))I4?4?44*III)*I*I5?I?_I?TIU_IIIIU____I_UIT_IIU)IIIII?jIiTju^__TTII>?)>?>)I))UvJI)ksI4Juӽ\))U>j\j}ssjSjII_ItjS_II___Iʒh}rjj}_ө^IutjhIӾɝhjjɿԩs_jITɳJjTu_j>`kTʓjjjuʓ~s`ԓԟԟjԴөԴj_STjʉ>II4*5*4*IJ)II)U)>Ij~>uI_I445*4)*`I>u}>?_?I_IIjI_Sj354) +))4~vU*) +)?_4?_UUv_kurH4IIIIjs}II_)>))*)))5I?III>?>III_?IU_IIJI_>*I>III___j_I_*II*I?54IITu~TT`u_jsh^I>?II?I)?)4_U?*)?I +UujȨ\)III_)sSsh_jjh___jhs___hsSI_hɇS4IhɩjɴԴԴjԉjjTtԴө޿II?_45I*Tjԩ3*4IjjIj^ʫ~u__j_ɩhTIɩjtSIj`I?I)II4?_T?4I?_s4SIII>I445III4J4I_IjjI__IIuj__IIIIHI4>?)4)4I^vv`U*443?J_`kk3II)44)IjjhIT_>*I))*IT>*4I?4?>?44UU_II?>`I?__jI*?)??5uIUIT>II>?II>4IJs?4uTTsSI?>4*)*I)))?}k*4)*_ur3I)*IIUjɳ}sI_j_jsIh}ISt}sI_jsss>4JjԾ}hT_uTsTIjɩԳ~TTu}I>Jhu~jԴs^I4IIJT`jIԴ_Ij*_jʫuSʫ`ʩssʟʩ~Դɾʩs>44UjT?TT>_II4_jTITjs)45j4)IUIII45TIIj>SII__}III?I>4))4>)4rivk5)*j>45Jvv`<))454?)j__s^j)I>?I*>>*4>4?I?II?I_UUI??I?U??45>?5*>5I?>??_?I545>?T_s^j_Դ~Shj}_II>4?)545)))JI*?4?uvvu\H)4)4?ITɝ~hT_jjhjhss_}IS}js^jIj^jjIɒr_SssjɞԾIɝ_jju_Iʩ__4?IIT_hIT?*JuԫʴjIJ~_juj>jɓjԕԉʓsɩɴɫjs>I?4?II4>Iu>)?>?5I4)?4Ij4I?_I>jt3S>IItS__`}T)4I>4))4)5ɇ~v`I*)4*k5JUv`v<)4)4)*T^j}hII*I?I4))54?_4?>T>*II?I?I?I?_I>I45455)5?5?5I_U>I)?I4__jjTTjTTʈ_Ijs_]I>)*)5)*4*)>vvkvv`>4)?*I5T>?T_IjItjjts_jT4>_IIST3))*4>rtJ44T)44)?5_``ʳ<)I)I`jjhs}S)I5*>)454?I4?I?IUjII45I?>Uj)5?II?)?J]SII?II?I?I?I5ksI~T`jjTSuԳh_I>*?I*)))) +)?s`Ө<))?4?TSԝ}stsS_jI_jS_t}^SjSSIjɨӾhTӓɿ޿ӴɴԴsIjjj_ju~~ɓԾɴ_TI?TUjII*Tjj~I?4?TjI4?uԩԿԓsߴԿɿӉj_IjsIIjUjII_TI>I)Iht34**IT>T5I_IjIII`j_hjSjj_T__jI곞H)))`*4)*)*4?_U`uvvɨ<)>4>I)IIӒshT>I)) +?4???IJ4?_*?*4?I?I*)*45II?tjjT_I_UI_*5)?>5TIT_k^jTjuɉhj_UI>I))))~v_5uQH +)4)?_Sjsɒj^sh}S_jsSjIjIIITӳs_IT4I?jԾɒ~Ծs~_IUTju_4UujԴuTIjTI?T?uj???`TU4*5ԟ꾫)_jjI>I4JʫsjʓɊss~jɓ~IsTI_sjsu_^4?_sts>4>__II4*jThIjSjIj_I?_jj_I_III) +)I^v_4)*5T`vr3) + +)U\hʞH4*) +)>*4?4?I?U>I5?I?I5I?Iu_hu__II5I?>`?TII4?>I`jI`JI`jjh_ItI)5I>I)*)I))))5}vkvuȨ<)*)_tsIɝɾɾssS_jII_j_SIIj_sII_Sjss_jIhSjISɝjj^jɫ~~hTjSʴs__s_IIuഴsj_I?__t4*jʵuԴI4s*>*IjI_jʴ~ԓߵjjuȴ}_SIIj_>_j}4jIs>U4_ssII)SJhIIjjshII_I>*??_)*>I)_\vvvvk@JU_v<))4>5}_h~`>I_Tj`>5I*>*II??I?_I4_>?__S_`I_T?>j`I_I5I5I?>TJjuTUTIjT4ss>__I>*454)) +)>u~uuQI))US_~ӳԝh_hsss}sj_jjhS_rST_ɳsjj~ޝsjɴ^juTɴ~_j괩괉_t_jsIɩԞjTjsjjjޓs_ɾ_Tʫ4T?4`ԉ^II`??juTTujʫʵԴuTʩԵԴ?IjssjhS_ӓSIԾS\4_>TI__IU_>_sITH>T_I>)?4)4J\uv +  +))J_TjS_S?j)*5I) +>U)*II?>4?I`jTj_II?IjUt4IU_II**?)*?JjI_?TTIku~ɳSI?I))5) +5)*>Isujr3)4?)*I>IIusӴɳɒ}h}SrjhrS}_sSӒsɳɴjjj_UjITT޴ԴɩsԴjjɩɾɩjjjjIjhSIIu_ksI?sjjkʕI4JhI4_ɴʴԊɩtsuIIIsjTI_Stɴg~sIIS44jSI__4_ushu~sssh3)))))^jvvv\3) +)) +)II_SS4JI4S)**)*?*55?JIUT?IJTTIIUII?I5IU_??>_>?)T_JT_UjT`4jssht_)>)54*>))I)4?vu_ȇ<)))*T\jɒɴɩɳ}}hsSss_ʳg_T_jssɩSrtI_IjӾjjjTII_I_ʫɾԩɉɾԩssjsTʴԩjtITII`UI*_Jj?4I`jhsII`ԉɓީsӴԓSj޾~޴ɴ^Iɝ3TU^jj>4?j>h>4>`_St_>}sth~ht>?I5I5)?)_\_vvv<*)) +))I?j_}~H``_)4*I5IJ4>*I5>*)*I*I?UI?j5TUT`IjII5J5>?I?I45I?I*?4Tkujj?j`jjjjI___>5I)I4545>?)))>jskvjTȒQ))*)jSu}ԝɝsjshTjsIhtSI_}Ӿhjssj}Sj޳sIjhTsjTsjjԴɓjjjӴԞsIUjju__TԵjjjs4uI4Tj^IjɊSI?IuʿɫjT`ԴsԴ~ԿɊusuԾIII45}S_SIUhtS_ts}}jiIII?I>5>)>rSjvv\)) +) +5))54_S_s~IS?4?`T44I??45>5IJ_?IUITUIU_U?_>*I?>_UIU>?II??u?4J*IT5jjԒ}hhI)\)I54J4)5*4I)?)4t}~kku_<)>4)UIIIIsʴӒs^IhSIS_jssɉh4IjSj~󾞩ɾuuԩԿjɴ~~~^Uuuju_T_Jjj__T`jU?4`IIuj44JʫjTʫԊ_4?T`jʴ~޳ɿuSI`Ihj>U_hsSIjs]S_s^s3))>*))))TQTvvr3 + +) +)>)4sɈ>?III4*?)*454?>5*?4?_?_II>?>I?IUj45?5I*JI`IT??T`T?`sjjhS)Ij3*44h3?45II>5)>iv`jQ))*)*II5QI_jӴ޳ȳɉshSshjs}ɨ}ȞhSSTjɴsɴɿɾɴӓԴ_j_ɞjs_Sjh_??4?I*IjɟTju`I`I?44*UʿS)j~ITuԴuTJ>IIIIIԿԓukԿ޴jsjhjɴh>ɒɾrsH_HjsIS4_rɞ)>?>*45*))4>t}>U`vv`<)445))4`)))5s_^4I`S?4*I**4*>*?I54?I?UIJI?5I5T?TI?*4I*UI4UI?*TiTIɾh_Ij_>T4?jkTI?TH4I?)I5II)*)U}sk֬`j_Q>)?>ITTII_ԩ޳ɳsjjjhII^Ih_ST_T\srTIjs_Tuujj_j_j__tjsjj~ʴsɾ}Tjɾj)?ɩԫ_j_4jII)?Ts>kTj^`j_)juSSjԴʫ_I?jjuԴʿɫhTɿsSɝS`t]thhus_ɉ_TT4I))4))4u}GTvvkQ4I)*)** + +4)*)4)4IsIITIIj>*?)**5*)*54*54*?J_II?jT?_4IT`juT`I?_jjIU)?*4k~I~ɩ_>??)?*?jI4JS))?>I))?)5)T>j_j^uʵvj_}H)I>)?>ttSI>U}ɾɒ~js_s_SIjhjThIIsShsj}sjjjɴӉjSʴujTjԳjsujsjI_T>I?_jsjsj~Ծɓ}~J`jI*uTju4TusjTIuIT޴~ɴɴԴujɴjjjɴjɳsI>T])h_S^sIstɳɒSQ)>45))4)*))h4_v`kS)>I)4)*)?I5I>5jSjTjh>?T)***4*4 +5)?>45I`IIIJjj?_?I?jI*IIUuI`_?)?4?j_T~sɳhII_>IUjSITjʓhIHI4?)455)*>?__j`uvvvuuJItQ)))>Iɞh}h_r}ʒ>I>>4*)))))th>J`vuH)))*4*>)??I?4TJʕh44>j_hs^I`_II*45*)***45?)?*?UjT_j__TuI5?I**I?_?I?I*T*?T}h_UI>Tj?`uiTITjI)I>5I5>55)?)))*II`I`uJ_Uv`kv_``Ith3))5))>uS>?j޾ӒhhSjII4I4}sӴS_hɴ\T}ɩsju޴ɴɓ~Ij޴ɩԫsIIӝsԓ_JkIs_jT`kTJTuʴʿsuu4?Jjjԩ_TjjuɩsjjjuTT`jsjs}ɨsjS}_Sjhh_\hɳ}SI>>4*_3>)*>) +_s3T`vvujjS)4)*I*>*)*??)*4?4*_j3?I_ThhjjI4?T4**) +*)4?I54*?4UT_`sujII??5?IU`UTJ?uJT`~Tԩsh_jTuH4j~I)?U_I?I)4_U>?)?>?I))*>*I?II?4I?TjII__hI) )jTH>I_곩ssSjT^IhSI_u}}ӳs_}h~ӾssʩjjuԿ~ʴ~sө_ɴsj_IjjjjjsɩsII4?I*Iu_4?>jIjTj4`ʓ4j_`jIԫʴhjjI^ɴjjI_ԴԴhSj_j>?uӿIII\j>rhs}hSjj_>>UI))))5)))>]35UkvkTuj4)?**454?II5I?TkII5jSsjTI*5*4*UI*>???>*4*uԓ~jJ_??III?I5_*tST?jkjjS)U_)I)鿕uII?`_I)*I*)*U*4*4?) +5) + +4?)II>?_I)>))  +>_Ө>I)u}jɾ}u_jthssS_h^ISIIT~Ԩsɴs_hI__ujIjӞ~T괉sSITɓsTU4UI*_TjJuʫI`jI4j4J_ʵTֿԞhԟuT޴Ӵɴ~sԾɴ~ɨhSTtH_SjhhɒSH_>>U>I)) +))jth>?JJUkUv_UTJI))*))4))*4???4?IUT?I4IIshtII4_Ij4*?4**IJ?)?5*54?`TkT`IU`_`I5I*I_`ʴTJ?IJTujԨhs_h_I_34)?ԞI_4j_II>)?>)I5?I>)* +) +I*)) + +))IItӾ}h>usߝ}sIIshIII_S4~ɝhIhjSI_jh_Ij_uӴөTӾɾɟI_ɴsɴɾ___`_TIjԓ_ujIT_ɓ}T44**ITʴuJ~uI4ju`_j4jʫԫjjԴԴԩjjUߴɞjuIITɿjމ~~ӓ^>ɳH\II_hj_ɾSuT_h4?)ItII)4))5_JI?*T5J?UkU_U?>?I)4) +)**445*_?>?`uIkII4`3jTI*)*)*)*TS)*)?*I`IIUjI?4UI_I4*_~jIT?*TjjjʳhrSg3)*IUuԿjuII?))*I)?)?4?>)*>*5)) + +)h)_ӳrII}ɴ~}ɾSI__IjI__SSIIIɝS\sI>sӾӳȳhɿɩɳɩө޾ɓʴujjjI?j?jIjsj?_ujj_ʫujj_juʩjTʫʫsujuʞju5jԞʴsI~S~Is_SuԨIh_SU\s__I5_?>TT454))> +I5*?T*?I4*I*))))))4 +*)5?)545)*ITjʓHII*ISrT>?I*54*?I`_44?4?*>J5__>*??_?5IJuvuuju`I?`TjTTjsjth_j*>4?_jjS5))>?I)5I)II5)*)))?) +) +) +)3H))It޳S>I`ɒSsShjIISI?jIT4ԝh}hjɴ}II?IIɳɴɴjӾȩɴʫs_ɴI)Jtj_~uj_uɩSu4`ʕ*jTIjI4ʴTIjɳʟjsj_?4*Ԟ^jjuɴ~jjTISI4_ԓ>}HrsS>jjh^jԴh)>4>_H)45)))))))*) ))))4 +)>4`~?)4>U)3u}s3?`?I*4 +??*I*j_4*?I?I?_I_)?JITJ4`kuTI?jJjTT`TUI_I_>_hI5*>?_TI>ITII45I)5)>I))>I4))) +)))4)I)jT)ITIII_ɳH>I_t}SQuhɳSjISjThS5IU_j_IIվ}I޾~t_jjjɩhsөɓsɳɴjjjȴɒh_꿴jSTީsIjI_44JuIT`vIJ4JʵSjԴ~u^uԿɫʫujԴjuTjJuߵu_IIsjSS)_}hj_Is}hh}ө}sj_IT\4>)454*))*))) +)45)? +)) + +) +)))hh~_?I5)I>jɒ>*??*?*4?45?4)?JJj??)??I?4?I?U*jUk`TT4J}TT`TIr__I_)*>*)U>>___}rStHhIU3>I>I5)5>)I*)4)I)4)>>_)?_Ih}hI>)IIӳI~Iӝӳssj\_III?34U}>>ISIjɨs3Ij?ӒsjɩɩӴɊTj`ʴtTʳIjjɵjuk`u_uj?`jʫʵʴԴʴj`uʵhTII_Ittީɓɾ~>I~~hS)I__jʾ\j_t}ɒsshI>_>}4)>))45)*)))*)* + +) +  +)ྟ\IjjTT4I>T}\>4*I*TUT?I4?`TJI??T?)?III`uUuԾ^I?I?_uߨSI>5I5I45_jȨhj\\>__S_45)))))>jT}]>ɨ34>>IIɳsɓɾ޾}sss_jhjSI>jIj)ɳSS_jIIIhhI_ɩsԴɓjɴ꾩ԴԩԩɓhUjTuj^ԳsTI`ԉk_j`uʟ>`T`_4TԵvjuuɩjIIIIԴɴԴuTuɨ󾩉iӞS___ԝs>Hɞ~sjjSIIj}S34*)I>>)5)))  +)) +)*kj_))?)5I)?>>J4>*ɝ>)ɩs3*5?)**jkuI44?55?5?JTJI445J_U?JiIuIs^TH)?>_>)*)?hjʳԉ}sh]HtH_TTh>>>I_Ȩӳ\>>>5_II__}}ӳԒjsr_j_IIIU^)j_>Ij>ɾSh)I4Iɉhjȉ޴ӓꞓ}uӴsujU`I?I~5?JTʿ>?UIjuԓI44j~ujjk`juJj?TjԴ޴Tɓ~ɩu~?4I]III޴~T>ɞ~T_rjhIhStrjhh}}ST}T34)  +) +))) +) +5)) + +) +))))))U}S]]_>TIHI_\)5uI3)*??THj4*55JU_`TJ?Ik*uJIIU_IsujujhI)UH>>5?I)?5_>}s3)IIgH>}ӽ靨Өh)44I_ӝ^r>?IIj_>j_II_`HI4>jSIhH_js޾ӴԴԴujsssjɴsj__TIUjT__u_jIT4?JIktI`?TԩjjӴsjJ_>IjԴԴ^ɾhɩ~]Ԟu>__ӳ}hj}_SI}htht}}ԞԾhSɇtIj>_sTh>)>>) +)))) + +))I)))5U_>Sӳ޳s34*sH****?U_`ju?J?J4U^kuIT?_ksIJ4?jku~ssH}_h_>)4?jɇS\hsɳH>>jtȇӳӳӨȒhh>))>>ITӳɾs~ssjjs_SI_I_I^}SI4Ijj_hTsIjSɩS4jsj޴ӾӞssɿԾөɉsjɴɩjj_juԴ_UjTuʴuj_III*4JjSJI`ʴ^TTɴԿu_IJʿֿԩɴɴԩɴhӞsިh4IIh}\~tshjt^_t]}sr4_uHIIJ_rSj_T))))*)))))5)))I5_>_}]}}ɾӾިH))>?}j)4ITTju_I*I*J5**uUui5TJjuTuT?uTIkS`r>I5>I5I5>?I_Ujhɞ\IIj}r35jSsɳsӒS_h_}s)>))5)>I)TI_IӾ}}ӝɾrsjhT>4I)?SrI}sɴsSIjI>4II^S_jjjuӝɾɝhj޾ɴujuӳɩjujԩju_T?_I_TTujS)???ԫ_IujT`k?4?TʫsuɴjɿɿԴԿɓʿhԝIIS\jjSj}hjhrI_hӞɝ_hj_4)>?_I_}gHhIT_S>_IT)5>>TS)thsɩ}޾ީr)4>?)4J>)*IJuTuuu_4*?kuJ4__s^JTUuv_Ikuuj_TTISI_IU>I>_I)?I>4u)Iu^ӳs_Is\>II___I>ITtS>>45I5)>5)?>?>I?jIɾӝssޒɳrSIhjI_IISIj>I^SIjɒSI_tj}ST__ɾjuɫԴjT?Tj_tɉɴɨsjjuuIIJTjɞɟuuIjI~ʫԊI_IIj_괉sTujj`ɫɴjT`I_IJjTkԿԫ~jTTI?jT>_~~hh}^IjsS__st}~j__jh>)5)))J}}Ӈs]ȨӳhjsSIӾrɾ}shT_h3?))*))*?``TTTUk4@U`J_?T4`T__U_`k_~Tu_ӒshH?_?>uh]_I_UII_Isjs鳳h^_IjɒS_IIII>II45>?)>?)_?Ijhshިɾr^޳ɝSj^IIjjSI_>II_sSU^_jusɒSjԴhsIIIIhɴshuɓ_ɴɩɩɾ޾ԩɓ󾒊Ɋj__*IIIuԴɩIJJTUjIj_ഩsԴj_I_jɴԿu?jtԩ~jjshIr_^t~SSsthh_3I>_SST__r_>S)55__I}ɒȨ}^_}s4_Ӓ}ӳSSjhITI>I>)*4?4kԓS_U?55vjvuvuIJTjkTiTkTvTT_jh_)>ItS>U>j_I_hjjԾӒhHIӳr__hIII>IthSjjɳөs~_TӒ~ɴr4Ij]III_>hI_rjsHuԉHIIIjSSjSI`I_ӴhsɝӴɓsjjh^jʿɴrst_II4*Uujuʫjsʫʩ^jjIuɴԴ>T_ɴɴԴ޾ɫ>Tj~_hɳ^hhjjhjSj}I__}T}_jSTI_sIɉs_tH4>)5)?T?II_}s}S_hsӾsIӾrjI__II?>)?))*>?)55 +*J4U_IT44JUvvu_kuuuJTk_J_vu~u~_hH>I5_jS>I5>?I4s}hsɳɴh>_Tj~}hussӝs}sjԝӝSIII_SsIhT>S)IɉhIsIɉ_I_IIIӨ~usөss~ԴԿɿӉ}t__~Ծj_I?*4*44*hʫsj޴ԴsjUj~jԿSI_޿ɉԞss^^}sIII_S_ԝhhI>__I_Sshh__j_h}35>ITII_I_I_Ij_II_IITIjsjsjsSTsSj_hshI>j5h))5?_II))*5T45_Tu445*J_vu~_ujk__kv~u}hHUrI4_)II_sӳr~ӳS_Ij_II_jIIsj޾sɾԾӴSST)II_I}S)__j\ɳ}hI_j4I_t^j}sSIjɩsɴɓɩh_jɒj~Դ~sI_?_>Jj_IujԴ~ԿԴIIj_sTjɿ꿴uɴ~_juɴi}sӴs_tsSsI}S_>jssSjh4Ihj_hs___S__h?T>I_IjIUj4_TSI_ɾ}}_IHI5IIj)>)>U)_)tuS?_s_**4*55JTJɩiTUT_J_k~ɩ}hjI_S>>II>?__\Tjɾ}hӳhss_jSIII_hjjs޾~Գssu)I`H4_tsshrI^)}jtSITT}ӨsIIjjujuɓӴԴɩԾɴɴӴɓj)I?4`Iutjj_ju_u_>ʞITjuɕsuuj`Tɴu_?jɩsIIԿu_hu~ɩT_Ծhsjj~_s^j_hShsS_hj\jhjI4ITjhj}j_hh}}s^jjj޾ɓh4jII__Itj35>_5TI)`4usSJu^I4**?>JIJ5uvuU?jU_uv~Tuɳh}}_HI_tH)45II___H_SjԨsӾȳsh޴s>jTԨ^jshII?___ssStshsIj_^)I}SIj_I_jhjSujsjӴɓөjӓȴhstjөj__IjjjTԴTT`I4Ujɉ_^jj_޴ɓhIj__jSjI_sԨssrs_hSts_^II*4?)4js_ɾ}Tsӝӳӳss_IT_Ⱦsj~I>IjhS_>)IIth_I))I`T?*_u^>I*?5?54`vtuTuj_jUuTkuTTuuj}hSII}H>>5IT)sIITjus4T~jɾ޳޾ɿɩ~j~4IT4_StSI_IIj__^_SjjS}SjSIs^ɾɴ^_ɴɝjӳsIԴ߳ɓjT?_ɾsTtTIuuI*?j_ITʫjSI`ITjuɴssjʫԿɩԞTt^4_tɈ_S_Sr}I}\_hhIjsjr~jIjtjjI_s~sjjjɳ~sT)_]s]I)?_>S_)I*4uu_T_jkI4*I?4*4JT~Sktk_Uuu~~uuuɝh_h>jhhIg>It])jIII*>`jS4_u}s~sTjjs~ޝިɾsSjSju_II)It_hsss_s_IhS4IjȴS_jjtsIɝӒs_hIjӾɩɳjɴjӴɾԴɴusjjjjj__TUjIujkT`j4UjjsTTԓjɩɓtjԴԴ}ɞ~iI)jts_ɞ^_>_~s_s}}hHs_Ihssss^IUj__jIjjIjIT_Isɿɉ}S>}Ⱦ\ts}}h_HII_ɇ>)>4?_~~kT*UTkI4*I`u^uuU~T}h_\jhh>I>`_)III^h>^Ɉ~IT`TI?S?IISShItSIjɩ}_IjSI>^Ӿs^ԩsTjjjssɳhIjjjԿ~uөɴʴԴޞhII?I?III`Ծj_j_I)`juI4`j~sjjӾʴɴɓԵʫ~Tjuuֿj~T>uS_~S__stɨhhhj^II}jhjsjjhj_jT_3j~SITsIsɳrIj>jS_TsIj_ITT4)IIsӾɳ}SI_ssHTI_HI))*?)5I5t^U``uj?ITj__u~^TjTɳ]hɉTH))TjS}}SIIT5IIjI]I4juuu޾~s~jɾޓ^I*IUjT?IIjIjI_j_hjhStSsh_sɾshSTj}ɾ^IIj}jsɾɞsjjʴtjɴsjIɫ_II`jjjuɉ_jjI?Iuuj_sɩj_>Iut4I?TjT??jTI`sjԴTII?J޾jjjj_JI~jjjɴT4T}TԴSIԨhshtSghԾhSI___s_SIISS?I`_ԩԳɾӿs~Ӿ~~}^jjjT>sr_ST>4U4>4I4?usT?U_U`@_k~~~uuSjTIJ4?jr_}S___Sh}hhH>)I)Uh\_TIs>IIjj>j~uԾ~SuS4Tjj4IjuTI_jSIIUh>SI>hS_}}hjhs^`SIɓSI^Ԓʾɨs_j_IIjԴ޳ɳɉɟjsߴ>4`_ju_I4juɓsTI޾޴Կhsɴɴɩs_ʴT>_itԩsޒ~t_ɓ^}htsTj`I4)5`S_jS~u~~~suɞ~sӾӴӓss_hTIj>4I_jh>IT4_shj_S4IIhIuSTuT_JvujTTjt_~UuuT4Ijrh}h>_ӳhhI_4>4`}ssjuh44)`44I?uTuuh)?II*II*)`_)*4)U_}sh_hS_hsh_r>jsIIԳ^husjsjsjjjt}^ITsIIT_jjIuɴ޾ɩɳɫ_jɳ޾ɴjIjjjhT_IjɩI_jTuʓuIʩjTTUvu^?jԴʊԴԫsTɴӴ~_j޴ɩs`hTɴ4_ޞs~)_SIԈTjsjIs]j}HI>I>t>)>4?I)`_sɾS4Tɾ~Ԩ~ujT4I)uSIII_}SjSISI_tS>_H4) +IUSs~ujk_U_Ju~I_jIuɒHtIS>_)IIjs3>*>5I))>>IIt}}}r}sSS_hSIISsIII?>?>T_I_jsSjshhhh}SjSTjHhI_jԇ>Ijh_jSjssɉsjjԴɴsjjuɩ~ɉɩɴ_ɩSS_I___J?Iuu^__I?4>ujIIjjʴɓssjuI_jsjӴssjtujujI~I>IT_SIsIiIhhIII_S)t>?Ijj^_^\TT`s_jTjsH)TI)*>T__}sr_S>*4))*ISu~~T_`_J4UUj`Uu_`jj_jS4IɝȒɳht_SITIT_))))4>I_hh_h_hi_ts]]h}ssjȾs~juT)444)?I_s}hII_h\uIj3IIIT`jj_hIj_ԝsIjɩɴj_Ӿɩ^_ӴȝɨsɓII4ɾ^I4I?>**)I5*?*IujTʫjTujU_IujʴsSI)*Uuԫ_?I?juu_~޾j]st}>_T>)_Ԓ>I>ӝ}ssthh)4)*>T_sTTTuuI~jʴST?IjjushsIITjԉ}h4IIs}hjhS>5I5)`_S_~_u5TJ_k^j߳iT^_j`jjvuuuT)jh3)?I)))U]th}}r}jjII>II)I4))))5)*)I>Ih>s>_S_j}IITssj_I}S_IIjIʩsIjIIIj곒Sjj_j_jɾɳȩԴsjsɓh_IIIJj>J*I?J___ujjTTTTTuj~jԴ}jTT?>`?I`ʿԟT_j?I__jI_jɩԾ鴓ɾԨhɩ}_ɾi\өSs}SII__4>)?II4?>I)4Tjө~SIT_~Iu`^sIjjIT)4`~I_^II))>sIIIIIIT)TIh~uu_JJTvj~_Jitj`v~u~4I?ӳr}jh>JH*5)54>4t}Ƚ|rhII>>_)?))*_US_}>__jtshjshjshjhSɳshjs}shT_IhIhuSIIIuө޾ɴuɴɓuɴөԴ^ɫjj*)?*I?j~T`uuʴhʫԞөԴjjɨsɴԝ~?Iɾ~Iu_hjSs~өsIht3)_>tT>T5))?UTIIIuuԾsSu>JIU)I?TI_h^4_I__SSjI>))>IIsS_I>4T3>_>)j>4IIsSj_^`4*kJ_*T_v޳T_uIIIIӳS_j>)I5I)IIȽȽȽrsiH)4>II)I)___IIIhj__IjSIIjɩޒ}S_s_ss_ɳssTrSSSȝӝshsjjɾɾsjɫɩɾɴssH?4)*`T4Uuujʫtus_sS_jߴʫu4`js_ɴӴԴ_Կԝht^>4_ɴ^I>TS_hshj4I>UI>I)*4)TJI?I>)?TIJj4jhjj)?I)IIII_jjs>))))4>4U4TI4*I4U)>*4I`S4)UII_h}~~~5*5?Uuijߩʩjkvu`ʳ~H4jUr}sHII>)*>I_}ȽȽȽȽȽȽȽH)5)?I?II_tHj_hSItsjI^ɩss_ɉshsIjjɉsjshjjɴs}__Ȟh_jɟsɩjjjӴ__ɩIII*IjU_j)*u`IuTjIII5iޓɫss_uj4IɾӴjjjsԴ^Tsʨɿ~>I5^ss}Hu__tSI~}_hS_tjHII>I5I)44?IIJ>44*jITIIT)I))I>II4)I)I4>ISI_HI44)4)54)4)?_U)_UHI__jssԝsTuij`T4*4*T*T5u`vjiu^TIujhHu3)*))I_ȽȽȽȽȽȽȽȽȽȽrHI_>II)I>_IT_hIshsSs_sjhIs^_SIjjsssjԳɩɳȩ}ӝȉhөɝujI?II`_ɩhTs?tj4*?ʕʩT_j?_ԴԴޝɵsɩԿjԴ__?_j_U_ɴ޾~_ɿhIj}ȓShIjs>_>__SI_j}s__SIuSTIIT4>]hH)4?)4)I)))45)>IIIjj^ISIhTS}r}rh]S>>I>)))?)IIIIII?I3Is^5TUiT?`UI>*I4TԳ_~^Ijr_jS)))I4tȳȽȽȽȽȽȽȽȽȨrhrhhSs_shTSt_sII_jsSԩjIIj_ʴshjshjSTsIjԩɳȨөӴsɩɴԩ_>jjȩ鳉_ju?k?*kʊʫu_>)?Ju~ԫʞsuʴԴԩʴɩ~I?4S_ɝuS__sӈ^ts}^3k_SI}Shshs_S>IHII_js)))4>Ih3)___hhhhI_SS__ss}}h}|}gHH>4))5I>?_>h_}>jti_uIJj54?Iu~ɓuhI)TshH>?4?4)_jȳȳȽȽȽȽȽȽȽȽ}\IS_>I_IsjSI_SISsSjsh__Ԓɳ޾ɩjjsɓԾɩɴIjԴɟI``)*?4?ʫʴ~ɴԿԴjTTjԩʴj_jj>ԿԴjjuɾɩԩ~_4?I>iIjT~h_s_)}^3Ij^tSU}sh^_hs_jjIII4_II__4__jh_T_Ij_j_I)IIIIIIjjsj}sȨӽg>)))4u~Ss_jSj}~~k4*?4uu~jjIIIIjjhjhI))))ITjȨȨȽȽȽȽȽȽȨȨȨSI_jI>jhhSSIIIhjITTs_Ծӳsjj_hTsjӓɴɩɳɩީӓɴsɓԾjIjujTIIU?j`T) +*I`֊ɓ~jTjSIT`kkju_ԵjީԴɴsjjSIu~i_ss}sSs3>_hISIISs}I_I_ItII_Is4I)?)5I4)*>4II>>IS)>3__SS_HII_s_s}ȳӽȨH)))?_]>`Hj~H޾~jU44***k~jj~ThIjStsS) +445*I>tȨȽȽȽȽȽs^thSI)4_rjShsSI_Is>I_ISuʾSs_sɳhSIjԞhɳӾɴɓӴԴɴj}jj_jjj_4jS`T4ԓʴusTjs4Uj_Ij^jӴhjIII54IjԴԿԿԫԴ_>SUItsss4IT_rh_S_>>uhh_I_hS)_jhj_^II4II)II)))))I)IhSShh]r|hr}}hSj_ȳ޳Ȓ\>I) +)?I)_>jSIԾt_*4J4)k^utjuv~us^I4jjH)44IȽȽȨȨȨhshsjhhSI}r}}S_SIj>I_jsIII_IISj}hjj޳sӾɾԳ޳өөӾԴߨhsɓsI4I4I?TɩjjUIʓTjTjjɿSus_ssshIjju_jԴSIjjԫԴuujɴɊtԾjuhjj_T_III^t~3r~HI_}jsIST_I4>4IITI)I?I)j44)4>IShShrSrӨӳȨgHI *5))*`h~i`?**45_T?`ujkvvu^?>?)?_Su34*4*IIȽȳȨsh}s__}hh^jjsSjIIIII_j}sI___tISIh4IISIjSushhhSɳɳsjsɓӓ޳Өɓ޾ɳsII*IIITuɓj_j_UjuUIJjkIIj^II_Դ_Jj_uII`TtujjuɊjuԴsTj_ɞjɩjIi_ktsT^_T_}sjs_~}S_jS_I_ths)IUj)?*>?_I)I)>4I}sr}ȽȝȳȨ}>I))IjS_Ӓ}sԉ__UJ*5U5)*J_j铔jTvkju_S4?_jsI)>*)*??TIjȳȨjsjjjj_jIj_II?_T_)?))`S_}t}\I_s_I}sԳj_I_j)T_uɾh>Isjjj^ɴӴɴӴɓɩɞjjTj_s_TɓI4I*jɩ__T?IUj_IuTj_kI?I*IuʉsTIjIjԩԴhSIj`ԫ~IIj__ԫ~TjԿsTʿuj~>J_jj__S5sth_S_>>5jIT>?I)_I>>I)II>I)III_hhrȨȨȨȽȽȳȳ\44?JI_j^ޝt_45?*54**u?_Ԩ~uvvuSj)?)IuIIU4)?I_4T_ӽȳjjjjh^_IIIII>)>?ISSIIII__jIjI4_shjhIjIIIʴS_sh_IIIIjԩsɳhIɉsjӴɩɾjjuӳԾh__sI4Iɩөsj__*jj_j_II_ɴs_uʫjjjԿԴu`juj߿I>~޴jԊ^IS4T]sHHSI_)*>jI3))I?_)`T))?)II>I_IShsȽȽȨȳȳӳӝsI)45T4_r}^j???4?TJuTuɞuvtus>*>IusS4)4*4*I_ȨsssthII>III?SI>I?>III_jSI^sh_SʩSITSUjT_j_uIj_ujuӒs󾳉өԴӴԳީӾӓɾɾhjssIIJ_tshjsTj__J)?_jjI^juʴjʵߵʿjj_SjUt_u鴫~Ԩj~S)>tI^_hԴs>jhJ)_)h4>}hSt^j>ITU__I>I_>_h^ȽȽȽȽȽӳSS4)?3s^_~I*TJ5T4J5_uɓ~_TuvʴSI*>s_)*)?)I?I}ȳhhhhhSI3I>II_I_S4I)u}hSI_^_uɳHI_Tt^jhsӴs޴ɴjjsjӴөɓɴSj`_jɓjɩjjJߟsII*ju`ԿʿʓT_?IjIjj`ujԩTI?)sԞɿs>It_h^)5uIɨhs^IIɨT_}SH4_>II>?IIII_>>IIhShȲȽȽȽȽȽȽӳ~^IJ*T4Uj_^uI*@U?@*5j5u`Դ^_*_vS)I5jI)>?I?ITȽӳrsrhhh}}}h}_\IIhjH_jj}ssɒsI_jjɴɳɩhTjj__Ijɩɝ޳ɓɩɴɳɩɩsII?IIɾɴjjɩ)uujʴ~I?jIJjʴsTT_ʫ_TjjɊuI>jɾ~TItuԞjԿԴsɓ^iɈT5IS>~__^_ItST4>uII_~>?Hh_3?_III>I>)I>43>I>_IrȽȽȽȨȽȽȨȳgI444UIsSjt4J?JjJUJT@?5JuɓtUukv~h>)??II>4?_II_ӨȽȽh^_TjsshhhG_sSS__I_IhȒ>I_jI_jT_ɈSs_sh}_hI_T_shɩɩɩɴsɴӾjj_IT_j`tITTkuu_jTʫI_~jԓɾԞjjԊ_juԓԩɴɴɴɓss~T)Ij󾓉Ծuj_s__ItsTSujjI)S_4>TtI)II4II4?_j_I4)II)IhȽȽȨȽȳȨȨ~~??*4Uss~~tjj5_`_J??T_?jTԨijvk__S>?>?U)J5_Uj_`_ȳȨȨȽȽȽȲ}shhS__s_TsS_h_h3IIIIIuhs`IIIIt_I4tɩsSI_ɴɴsөԴԳԩjjIIɩӒɴ~_jtTIT_I_j_huT_jɿ>I?4*IuuUӴԴʵߓʿʴԩ~jɞ^I4I?Դި4_hɞ_hS_I_~ITSsITujI_jI_jII4Ij_T4)>4)>T)4)))_ts^IȽȽȽȨȨȽӽȳs4**Jj4r~ʨʔu_5UUj`JT@_U?uɴtuvvkvԨtI)*>I?ujjjȳȳȽȽȽȽȨhhjhhIIT____hh_>IUSjQ4IjɴSI_jԴɩ^_I_ɴɾɩɴԩsjɴɴɾԾjԾӳɝ_jjITj_ju_>uuIjSIII>?`ʓI4Ijj~jT`sɴɾ~_ɴj4jj~ɓT~hhsSIshrI>>T>ttH]t}sj>I__)))?>543)IShssh^STIsȽȨu^))*4*Iu}ʿjUU`UU_UU_@jU޳ukvu3>?>_Jj_TjsӳȳȳȳȽȽ}h}sr}>SsIsh}_}TI>Tjjs]IIɴsSI_ԝɴhSIjIIjɾӴ޳ɳsjIԴujԩɴh_j__Iujhj__TTjʫ꾓jjj*jsII_~uɊ?*)jTɟI?ʊsTujTjɵɴԫԴɴ_Ijuj~j޴ʨj_hhsI)4_jjI}r>_jhSths__4I>II)>>S}rsrrhr}h^rȽȽȳȳ_J?I4JItJ_jU_JJ_UJ_@_ɩvvvu~)>5IU_uj`jtȳȳȽȽȽȽȨhhSh_^ssssIӝSjtSI_II_s_SIjIjjIjӾɾީ_jȩsɴjIjԉɾjjjIɞsjɴɴrIjɒjjjuujIjIITjԴhjTʵsԿɫԴɴj_jujɩIII4IITIuIIIɞɿԴsT_IIhSTIjjSjI)js_sT_sIIIUj__>)T}hh}sjhIj}ȽӽU4*JIjuu^ʔTj?U__T__`juuvvvkʞS4I?_`jkjTjȨȳȽȽȽȨshssSSI_js_hIIjjjIussstjs_jtS_IjsSjjsjsjjԓhɉɴԫsjsT_sjhӴ~Դ괊S4?j_jjsTIj4?TUj4I?uTjԾTTkԵɾsI5?J߿Եԕ_T_ɿԴʩ^4I4I_ɝԿ_TSɴs_j>I`jT4_jiI~?j_4Tt}uhjhIIj]h>__srr}sssjhȨӽȽӝ_T*?TIuijʳʩj`_5j_UUU__jʴuʔs_U_IjuTjTuȨȨȽȽȽȽȽ}ss_tsjsI_shSjs_>II_tsI>II_}jjjԝshI?jjɩԴsɞtɩ޴ɩIԴtT>Iu_4IIIjuTI`jTITuju~4ju_u~sju`ʕT_ʠ൵Juujʴɴ?>*__ԴhjԞTԞju_jT>I_I?>4?jjI)I>__hS_ITITjHS_}}srrhjsjȨȽȽȨȳ~u???JTITHgɔʔt_5_UjU_Ujjkvvvvk`stt_?T`uJTuȳȳȽȽshjsSIIIIITIjjsIIIhItss_r>II?_ɞ_}sɓSjԓI_sjjjɳޒɓӓɩh___T_IIhS?IUԴ_ut4Ijjju_I``juʕuITjj_j`TIj_`ujTu4?IԴSI?TjkjTJju`j__jԿsjII4I4IԿuԳsjsII__tjsI>I??4>Ijɾ\>tss_thh>I_}rȨsh_sj}ȨȽȽӳu__4J4j^ijJUTJTj`juuʩʩvvvvvujTT_UTjjӳȽȽȽȽȨssjjI_jII>4I4>IIIII_}__IIjɴh_jjIsITɴhIITIjɒԳɴɩȾȴӴӴɩɴɨԩTIT_Tj)I*I_T?Iju_jju?jJjT?Iֵ`jjjuɩjIT?Tj}sjTI*>__hɴ~TjJtɴjj~?TUujԞIjsԴu)II>`jI_II_I)Th}sI_I_jI4IjshrȽhsjjɝujjjJ*_jT45iɳtT_UU_U_T`jjuu龟vkUju~j`TkTTjȽȳȽȽȽȽjjhshIs_}hhSII?_S_I_S_j___h_jɓjI)?4U}sj_sSjIԴԩsjsɴɩɳɾީɩȩɾȩʴԴɩj^_ɩ_jI?IJ>Tj`jusIITIJkT?4I4`ʫjTԾsjʕʿ_4?4__uԿ~IʿjԞT_jIs^4_4)4I_IIT~shI_II*>)5II>jhsȳȒ^hjȳ޾ޓtUU?JTTTITuiʴʟ_`_UUjv_j_ɴuu`u_jJ__uȽȽushhshI>Ih>j_h>j_IIjjjs_Is_I^j_sIjɩsIjjӳޓhsIԴԴөӴɟsɴԒsjɩ__I*_juuj~I4_j~u~IuɴԴɴԴɫjI`Դɴ~ɞԾӝsuTjsII_Tԝ^_I_I)I`j4_uIjI4I5IIII)_?_III`T)IIIhsȨ}hsȽȨȳɩt@_J4`_I___־ʩvjJTU_j`vuvvvkusTTT__jȳӽȽȨ}hrsS_hI>I__jhhjr_hhTHIsshIIIII4jjsjSIjӾӞjɩԾɴԴӳɴɊԓssɴɴ_ԩS4*ɫjTujԴujԫԓɵʵʵuJTTIIuʿɴ~ޞjIiIޞSIuIIII_jjujjSI__>I?__>I_I)>4)?II_SȨhjӾujUT*J__`ʟk_k_Ju`vvuvvk_uu~jUu`jTȳӽȽȽȽ}rhh_hIjhss_j^IjjɒS?_>?IIuɳT_ӒsԩɴsjԩɴɉɾꩩӝԴӴӴөjIj_sj4IITjs?jT*`ԴjTTʵjjjTTjjԴjTuujuuITjtԩ~sjujjujTI~ԉjIuԈIhj_sj^II)_IjTj)I)`UIjuI>I5I?I>>5>ts3_IIӳuUTJJTUjjjkT_JkT`uԾvujjj`uuȽȽȽȨȨrs}hhhsIhjhI___SIjɴHI?__j_ԳhȩԩssS__jӉɴԩsjɴ޴ɩӴԾj_jIUɉɴjjTjjjuTj__Ե_uTU_ʊ__T?Tkuɩ~jjʉɴTj?juʫsj_juusst>44)UhjthjS)5>4I>5IhS)Ij_j>TIITjtȽȽȾujUT5uTvujjU_U_k_vjvvvvvkjJj_jȽȽȽȽr^__shjɳhjjjjT_jjIIjjjjuɓsjʴsөɴӒɩ~ɩȩȳɾ_II_suɴɩɴh~jIIT`jjIIujTjuj_II4_ʫ_>T?uɫjɾjjԞ~Tj_jTjju~tjT_Tjj_s~ɞ^Ij_I_*II4UTI)?>?>HI_H_I>?3>I_IhjST_ȽȽӳȾjU_J_jʾu`_Uuvvjkuvvj_jujӽȽȽȽȽ}hhj}Sjh_sh_jIIII?_ITIIIujIIjɓԩӳɩԩȾөɳsjjjjɩjTTI4?TjTIju^uʵsԿԴjԩjjuԓ~sjuIIԈu~4Ujs_I>__>II_sSthI>IHhhhh}^_ȽȨȳޝ}`T_uʿʴkk`u`j`jj_jjvvvuu`jk_jȽȽȽȽȨȽȳȽhsh_jssjhtjs>Tjj_II?jjIjI_jjIjjIjjɩ޴Ӵ޳޴ȴ_T?I`_jʳsɩ_TI__j~s`j4?I`jTj_ujjjTjԞuuuTuT_ujuuuɴɵssjj~jjsSjT>TujI_jjTjjI_j__hh_II}hSISS_Sh\jȽȽȽȨȳjuk_U__Jʴjj`j`_Ukv`k_jv`uk_ukjuȽȨȽȽȽȽȽhhSsh_js_jhI)I>_jh_j_jɩssjjTIjɴөɴɴɓ_jԩtI_?_uTjujɩ}j4jIII?jԴsSIIIT_ujjuusjuujjUTIJuʴuɩԊs4?IjTjjuԴԴujI>5j44?IjII4UIII?jIT_j>IItHhI)I_}rsSIȽȨȽȳTjtj@_`jvUjvuuʾvvvuʴ_`uӽȨȽȽȽ}hhh_s_}hhh__SI_ԾjsshSIj_jjI_uɩɓɓөjt_jɾɞ_j_jTIj?4jԴuITԴ~j^jjT^j4I4IU_Tuu_j_kʞuʬjJ4?^IsԫhSj4>44*44?II*IJTI?_II_s)>4)I?_>IjSHIhrs}tȽȽȳȽɩ_j`_jk``jvj`kuvvkuvukӳȽȳȽȽȨȨȽsshsIIIII_StɓhIIThɳhsjɩ~ɩjɾԴԩh__I4IIjkjT?IJIJ`T4U_tjT~^I~TI`ʵ4*)*)*UIuu@TtuhԩjTIT_jʵuuʕ4IIS454?I_UI>45)I_HU_]Q_I_HIHhȒshȽȽȽȨȨȳȨӳvvukjjjʩvUj`uuvtJJjjkӨȨȽȨȽȽȽȒ}hts}ȾsSI_ushjhIjhɾӾjөɩɩj~ɩs__j_T_ɴӴߩ}jhTIIIIj󩉩_sj4I?t^jj4J_?jI*)I*>4ISSԟjIITTsԴsT`TII?4>jujԴIIjIj~u_TI_JII*`juʉI`_hs_}__hSSS}hhhȽȽȽȨȨȳȳӾvuvukvkj`u`j`juvvvjUjjkȳȽȨȳȨȽȽȨhsjh_I_jh_s}hIIhtsh_j_jɩhS__ԳsIөɳɴhsɾԩɩj_jr^IjT`TI?IjԞssTɊjjɓjIjԫ^__jSjɴTjʿujs_sujIT`uTI?T_j>suޞsjs}}hI__sȝȽȽȽȨȳȳӾuuk`jjuuvvuukj`jvjuuvtJuUuȽӳȳȨȽȽȽshsjS_St^_jȳrj}shII_ӳs_jɴԩɩɩɴɩsjjuԴsjɳӳɾөsjs_jjII*?IujTUi4_ʉTTJTuujʩTIT_uujsjujjԵԴɿjɿTIIjɴɿuT*?j4U)I_TI?T_sjsjs__hhIhȽȽr}ȽȽȳɞuuukʾkkujUjUu`vjTu_`ȨȳȳȽȽȽȽs_js_Is}sh_sths}ȩS_jjjTsɴɴԩɴɾɳȳɩɴjԞj_TUjjjTIIusjIT4IU`I4?ITju_Ijj޴jjTIɴɴԿ~IT4Ijiujuu_TIuu)))jIIjjjj^Ts}jjjTII_sȽȳȒrȽȽӳވvukuvvukj`_kuku__uȨȨȳȽȽȨȽss_jIIUjhsjssss_ɩs_ItjIjsjsȩssɳjɓөɩ_jj_TIuɴj_TjI?Ij__ISTj?I*44ju_jjԳj_Tj^Ij_T`T_jԞuޞITIjɞ~ԾԿI_t~^)?4_jIj_s~shhj~S>_hȽȨrȽȽȽȳȳިkvj_vvkukjk_`uvvvvutvȳȨȽȳȽȽȽssj}hI_jssshjӝss_hh_sthhj__IIISɳԾȩsӓsh_޾ɴөjT_jʾɩɉj_?I``IjʫsujTjTI*I?4JjJI44?UITʿ~ɴԿsuI_u_`ʴɾԿuTj~>S4II_ɨT_jjss>_t3)4IȨȳrȽȳȳȾȾvu`kuʴuv`UjkuuuvtjȳȽȽȽȽȲȽȽshssjɓshhIIɾӳӴɳɒɳɓɴ޴ɟsu_j`I4I4?TjT?I_ISjԞ߿skTII?ITsjjju_T4?ItuhTj>޴~}hhhhh}H_sjS))?tȳsȽȨȳ޾vjuvvjkukvvvuujjvvvv_ujȨȳȽȽȽȽ}h^_}t}hssI_}ɒɴsjӾɴɩss_jssԩs__jT`ԴSj`TII?I>Tɴjj4I?ԴsSuɴɴԓjjThTӞSIIjSI?444_uԓujI}sjjSSS>_S>4)4tȨrȨȽȾӾkuvvvkjk`uvkkvʟvvvjvȨȳȳȽȽȽȽh_hshssȨhshhs_jө~ԴӳȴөɾȩhjI_Tԩ_j__`jj_I_?ujjuTjj_Դ^juujjjTTjTTJITuԴTsj~uuuuɩ^ɞ޴ɿT4)_Կjj~IIS_~__hhsIIts_tsI)>_hHtȽȨȽȳȽȨȽȾӾvuuujvvvkvjkuvvvʾvvvvtȨȨȽȽȽȽsȨhI_hjIj}hsh_sȳӳ}ss}Ȓ}hsɳhTIɴɳȴөj_^_j^_jjs_usɴԓj?j`jjhԴj_TT_jj)*I`?`uj_IusJjujII?I_sԴu޿__`juI_jԞIIujhhԳhII_^IIUI_IhȽȳȨȝȽӳިk`ukkʟvvvvkvvvvvvvvjȳȳȨȽȽȽȽ}Ȩh__I_hhȳSs_jjӾөӳ޴Ӊj_suɴɳӴʊuʓu_jj_uu_IjuʕT_j_IITjTIjɓԿԿsIIjjujTT_TI4)T_uޓsI>IIjsTI>I?>4)4)I_ȽȽȨȽȨȽȽɳvjkuʟvvukvuvvvvvvtӳȳȳȽȽȽȽȽȽ}hh}}\I}ssSssӳӴӾtjhs_jɴөɉɴɳӴɳsssjjjuj_I?uʿԫjI4II4?jjuuhTIjjjjjTTujIIԴsTԴsJj_jhTsTITɴjjɳsssjj>I_j^_S>jsstȽȽȳȒӾvUuKԟvvjuvvvvvvvvvkiӳȳȽȽȽӽȽȽȽ}sȽȳȨs}_hI_}}sjhjɳhs__sȾӳӳshjjTsjjӳӾɩjsɩɾɩɩɴjɴԊɉjI)JI?TT?JI?T?)I4)T_j_TjI4I?uTT???TT*jɴjujTsT_ԿTjjIjsSj_^sTjT`sI_I)?II?IIshI4IȽȽȳȳȽȳȨȳӳӳ`uUuvʴvvvvkkuuuvvvvvv~iȨȾӽȽȽ}_ȨȽhssh_sS_s鳩ӴɳɾӴɩӾӳɳԩssjɩT_j_`IIIj?IjjjjI?jsT45IjɴɴʿI>4544?IԴjԿɴԓjԓsjsujs~hssI)__ThIIuhSIHHȽȨȽȽȳӨvuvkkvvkkvvv__ӽȳȳȽȽȽȽȽӽȽ__}s_>__I}sɳ}s_^ɩөӾ޴ɳӾөjsԓɓ~j^j_ӓjtsI)U?IjjT?4Jjjjkj_TITTTjɩj454T``ʫII?ITju~jTTIsɿԿjusɴjssssjӴԴssjhsh_^3_III_sȽȽȳȽӳvkʩvvvjkjuvvvvtjӳȽȽȽȽȽ}ȨȽȽ}shh}hssɴs_jɴӾs^ɾɾɾɳӝ޾ɩI>`_`jT޴Ӵɴ}IIIIIUjju_`j^IjTjj_jI4?uJ_IksjTIT_T_TԴu`SujɿԴɴԓɿԴ~I_tjɴss^II_hjssh))*)IJ^SȽȽȳȳȨӳӳӞvkʟvvvuuvvvuӳȳȽȽȽhȳȨȨrhhsjӴ}}I_ɴɩjs~ɩjɓӝs^jɴj_II4_Sjʾ~ɞ^IIjuIJjJujTIjɞS`jujIIIIuuʊjIII4`ɴuTjI_uԾԴɫԞɴԴӾiITIIjɿj^_Դ~sT4>)_s_jjhsItȽȳȨȽȽӾvuvvvvvkvvvuuȳȽȽݽȽȽ}Ƚ}sөh_sj޳}shsȳөӳɴԳޓɴɾԴԴsjjIUɓjuh_JjjsjTTjIIjɴTI?jjjʴjuTT4jʿԞ_jTTTjʿTjuujju_ɴɓԴɴ}Sɾssj^^I_jSj^_ȽȽȨȨȨȳkuvvvvuvvvvuuȳȳȽȽȨȽȽȨhhhshs}hSh_ӳɝhI_ӳɞ޾ɓsɳɾhTɩɴɿꩩjj_TjjIIkII?T?_Tԫ^TTUuujTjT~TɿjujjjԴԴjIj_Ij_jujju_ss~jIsӾssS_T_jSȨȽȽȳȳӳȾkvk`kkvvvvvvʴu`ȨȽȽȽȽȽȽrShsjɳӾhjɩsjjɾsԴ޴sjhIjIITJԴɟԉuju_usIujjI???j괴^juԴjjjԿԴʿuT_~jTjIj_Tɾh~4_s^jj_Tsjh>IjSjhh}ȽȽӳkuvkvvvvtȽȽȽȨȽȨȽȨhhsȒshshjԳshSӾӴɴӝɾԴIɴɴԿӓsjT_4?ITj^_I`SITjsjju~ɫjԵITjujԫT4?II^IɿӞh_sj>))I_sssjI_sh~sȽȽȨȨӳ޾vjuvvuvvvvvvtȽȽȽȨȨȨȽȨȽȽȽӾs}hjӝS^ɓɩӾӴɴjɴss_j?IT`sj_jI_TujI_ITTɴTujjjk_jjjjʿjj_ԴuII_ujԴjjTtɴӾӞ~hsShss\tȨȨȽӽȳɩkkvkvvvȽȽȽȽȳȽȽȲӳɳɩhӒSjɳɩjjɾɾɳɴjIjITɩsӳjUIT5TI_ɉɓS4?*4III`jTUj54TԴɴs޴jIu~uԫʵ~jjɴSI_IsjӴɴ~jT^__T__jsss_sjhs^hȽȽȳȝӳӨvvjvjvvvvvvuȳȽȽȽȨȨȨȽȽhtӳɳӳȨӴ^_ȒsjjөӴɩɴuuuuɳsTjԴjT_jtjʕIjjj?4?jj?`?I?*ITuuuuԴjjʵԠujjujjԩjԵu_II_jsTj_sh_ɩsIIITjhhshj}}hh~rjtsthȨȳȳȳȽޓvkvvʾȽȽȨȽȽ}hssshsӳӳsjɳӾӾԳӳs~ɴjs_jɓ__J_j_j_uT4II?4Iju~IjujjjIjjIjuTjuIIuujjj~uj^?*IJj_4??Iju_ɴԴi4Iɝsjsjs޾~jjjjSIIhsȽȽȽȳȽȽȽȽӨvvuvvvȽȽȽȽȽ}hh}hȳӳȝөsɩsjsӾԴsԾsTɳ^ɓS_IjɴӞjuTIT_I?4_II4IT?TujjjkTjjIIj?IjT44ɴs44TuԴs_jj`~I4?TIj֠ʴuԴjuII_j_~jhT4)>`_hj\ȽȳȨȳӨvvvvvvvvȽȨȨȽȽȽȽȽs}}ӾӴjjjԾjsTjjjɝӓuT?jjITUj_j_Tɩjj>*I`j4jTIuTI4IT4IIT`_j?TԿʫj*juI__TT`uuT?IuԵsI44TuԓussIhӴɨsjII)I_Qh}ȽȽӳȨȨӽӨvvvvvvvvȳȽȽȳȽȽȽȽȽȲsȳȳhs_S_ɳ}hshjӳӾӒөɴsTjuuԴʊʩjjɴjjuԩ_ju__sIjjSjjjITujI4)IjjT_4j_jTIʫuTjuu~_`TT_~`jk`_*Iu`jj^_s޴޿s_s_޴js_I4IIsssshȳȳȒӾvvvvvvvvvvvvvvȳȝȨȳȳȽȽȽ}hssjȨȳhshөӳhsɳssTӒ޳jjjjjjɴjsjuɩst_ju`u_jsTII`I4JjjIIki?I_ɵ*_jj_4II޴sIuT_TjԴɴ޿~jɿԞiITTsӾss_jss}ȽȽȽȳȾӝvvvvvu`vvvvvvuȳӳȽȳȽsȝsjSӳȳӳӳөɾӳɴsjjjɴɩsjj_?TjTIj_Us_T>4_Iujujj)T4JT?Ij}TIIIj_jj~ԵTusԿTsɴ^ju~jԴs>TTST_ShrȨӽȳȳȳӾvvvvvjkvvvvvvvvʟȽȽȽȳȽȽ}s}r_hrɩӳԳsɳԩӴɴɞsԳ_jjjjsjjI?4?TjjTS_^jj4?TTujujʿ~IuUjj4TIIJI?TUjTJI^jjTI_޾s~jsjjsjTI_jj~uTjj_h_s_sjsIshȳȨȽȨȨȳӾӾvvʟvvvvvvvʴȳȨȨȳȽȽȽ}sh_ȾӳӳhhӾɳsjԴӴӳɴɞȒ~j_Tj_󳓉suI?T?`jjj~IIIuuTj_I?*4?TjT?Tj`uUI>*jԴ_IjjԕjuT~ɾs~IhhI_h}TIjj^T_rȽȽȨȳȨȳɓvvvvvvvvvuӳȽȽȨȽȽȽ}}sӳhj_ɴɾɩɴɴɴɳөɝɳɩɩj_T_IT_hHIII_tIITjITTIIT_jTIjuhITuIII?44)4Iu_II*4I*44JJTԴjSI`_4Iɿ~ɿs~s~_TII))>jshȨrȽȽӳȨȳӾvvvvvvvvvvvvȳȽȽs}ȨȳȨӳȝsɳԩsɴԴ~ԳɳӓsIj}sjjjujj`ɩIITIU_)ISIuIj_jjʫII44JII?4`uuuT`^I_s}hIS>IjԠ~TJ޾~jjԴuj_TIɴIjI>*)?>)I4T}rȽȳȳȳȳȳӳvvvvvvjȨȽȽȽ}}ȳȨhȾȳhӾӳөɩ^_TӴөɾsөjjɟII>Tjɴ^IjjTTTIjujjuTjʴh~I4ITTIjsԕ~T`ukuTII>S_ssӞsu}T?jj_s~I4)))>_SI4>_hrȽȽȽȳȳӳȳӾvvvvvvvvvvvvvvȳȨȨȽȽȽȽȨh_sjs}h_sӨӳȳ󳳩ӾӳȩsjԴɩɳөh_T_?j_JjjuujujjjTI4``TTʴ~s~uuujj?TI5?I4*II?TɴɩɴsjɿiI^IIJ_usII4)I__S)44IȽ}}ȽȳȨӽޞvvvvvvvvӽȨȳȳȽȽsss}_IIȳȳӾɳɳ޳sԫɩӴɳSjjjjjJ_UIjI`jjujjTjjIj_jjTjj~IjjIjjjuuuj_TjjuSIssjjh_jjԴɴԾԴuu_ԴɴjtT_s_^I4III_~4I_J_I))_Ȩr}ȽȽȾȨȳȳӾvvvvvvvvvvvvvuȳȨȨȽȽȽȽȳȽsshs_}h___I_Isӳӳs~ɩɾɳɓɴsj_IjjөԾɾs_j_j_Ijj__J~IjjuuSIIjkjjjjujujj_h>I>jjԩiTuuju~_ɴԿ޿j^IjԴT_TjT>)44Ish^tȨȽȳӳȨȳӽȳɞvvvvvvvvvvvvvvjӽȨȳȳȽȽȽȽȽ}s__h_hӒrhj}ssjɨh޴sӿԾɩuɴjjuʴsɴs_Tɉs_j_T_~>jjjjjjjI444*II?T_jujujTjjiju~uu_jjj~TTIjssԴsIIIIɴTI?_TI>T_~_^4h}ȽȽȨȽӳȳӽȳ޾vvvvvvvvvʟvvvvvvvvjjȳȨȽȳȽȽȽȽȨȨȽhh_shɳɨȩs_s޳өӳɳsӴөӳӳSTTTԳujh}j_I_u__jjIujjjuTjjuj_Կ_ujssj_Ԟ^~ԞʫjԿsԵjhujɴ~su_IIIII))j_T^4>s}hhrȨȽȽӳȾȳӽȾޞvvvvvvvvvvuvvvujӳȳȳȽȽȽȽȽs_sj_ɝhȝɩɳԞu~ɩs~jjtjTIj_j_?_IUjj_}T`jujj_TuuITTjTjjjɿɿuԿʴԞԵɓuTjju^I_Ӿ~S>hs_}hs)4*IjjssȽȽȽȽȽȳӳȾvvvvvvvvvvȳӽȳȳȽȽȽȽȽȽȽȽh}hS_h_ӴӞԳӾjIjITɴɳs_j_uөsj_Tjjt__jIjuUII?j`IjjssuԴ~jTTIjjII_4IjjʿԵԿ~TSuuujߵjjjsss_ɴTjj~uI>4t_SjS>4_hhȨȽȽȳӝӳȳӾvvvvvvvvvvvӳȨȳȽȽݽȽȽȽs}__sht_j_S_}_Ӟӝӳ~ɴԴsjɩsjjjjjԴsjsjjjjjI_jtj___uuuujujjssjs_sTujjjITTujTjuu_jIIjjԵԴusԴɾth4jITjTIjssjIj_SII4)IT_hhsȽȽrӨȳȳȳԟvʊvvvvvvvvvvvvvv`ȳȳȳȽݽȽȝȨtst}hhjjhhssjɾȳɾɴjɳs^jjjjjɴɴsT_jtt_jj?uuITTujTjj_IIIjjTjTTj^Tj޾~~~jTjjuI?Tjj_sjjjjԿɴhj4_4II4I__s_jjsTTThj}ȽȽr}ȳȽȳȳӾvvvvvvvvvvvvvvuȳȳȽȽȽȽhstj}}}shIӳӾssӾӾӳԴԳɩsjjjjjhɴɴɳjɴhS_j_`I_U__`T`uII*I4II4ITjuuTTTTT4UTɴʕsITu_su~Դʞsuuj~Ӵ~j~jj~TTI4?T_IIIIIhIsjhsS}}ȽȽȨgȽȽȳȳȳȽӾvvvvvvvvvvvvvȳȳȽȽȽȨȽI_jShjISSȩȾөөɴɩԴ_susɴɩjjӾs?_j?Ijtj_jUjuuT4Ij_IjTjjuuITIITjuI_?jIIIITIjsujsIjԿijsuuuuujɾԴjujIIjS_Ij_4IIjjS^^III_hhs}ȽȽrȨȽȽȳӳɩvvvvvvvvvvʾvvvvvvvuȳȽݽȽȨȽȽh}s__ssȳӳh_shɾȳɳӾɩsjIjɴsȴީɩ~TIjɓsjjjsjUjjtjI?Uj?UTtj_jjjIjTTj~jɞjjIjjjIIIT4I4)?TIussjujTʿ4IITԴIThjԴԝjʵs4IIj~TIɾ}IsIJII44I_ȽȽȽrȽȽȽȽȳȳȳɾvvvvvvvvvvvvvjȳȳȽȽȽȽhth___>___t~Ծtɩsӳsԩӳ޴ɉɾӴɩss_jTIjsjj_jT_jI_j_j_I_?I?uuuuɕsjus?_jTIT4TjjjԴjuI)*)?IIIT_ԴuԿu~uɿjshIIT_jIIII4Itsjjhjj))4)I_h}ȽȨȽȽӽȽȳȾӾvvvvvvvvvvvvvvvvvvȳȨȳӳȽȽȽȽӳȽȽȽhI_jt_tɳɒɾɒӳɳӝȓԿɴTjTɳs_I4?jj޳}j_IjsTITj_j~TjjjIIIIIjjTjujjujhj~ԞSjsԿT~ItTI4ssjTss_IsST_}ȽȽȽȽȳӳȳȽӞvvvvvvvvvvvvvvvvujȳȳȽȽȽȽȨȽȽȽ__h_ɳɳS_jɉsjsӾɳ~ɒshjөjjԿɩsɊ__u_JI_I_TTIj_II_IjI?TT?T?TJԴjI_TITjuujjujsTjTu`ԴsɿԕhIjjT5J4I^^IsjtSTIIIjshrrȨȽȽȳȽȳȳɳvvvvvvvvvvvvvvvvvvvӳӳȽȽȨȽhsӴj}sӳɩӴɴɴɩjsjӳsI_IIjTTsɩjjjjjjj__j_II_I_?jj_jj_jujTITj_uTIIITjJjI?I?Tj~ɾ~ujTjԕuuT_TI_TԿuh~sԩsj_Tjjs)_jjIi>sɩhT)?))44I}rȽȨȽȾޞvvvvvvvvvvvvvvӳȾӳӳȽȽȽȨȽȽhj}_>_}__sӨsɴs}__hɳ޳ɳɩӳɴs_T_UjjUjUj_IU>_j_jjj4TITITsT_jTjjTjjTITT_jԿj_^jʿuIIIIjTI_?4I_u~~jujIjjT_ɴ~jjTj~ԴsIT)_hrȽȳȽȽȽȾɩvvvvvvvvvvvvvvvvvujӳȽݽȽȽȽȽ}}ӴhɉhIԳȝԾɴɾɩɳӴuj__IJUIJI?UIUuuujj^ITj_I_TjIT4?4T`IjuuT4T_޴ɫJ4tjԿsjs~TIuTIIITj~IT_ɴIjj)IIj`_I44Is}}ȽȽȽȽȽȳ޾vvvvvvvvvvvvvӳȳȳȽȽȽȽȽȽȽȽhs_hsȝI_Tөӳɾɴ~ɴɩju_T?tj__IItjI_IU_`jjuujjuTjkTuTIT_j`j_44*4II?II_4_?ujɴTTT_uI5j`TsuI_sTIɞuTTTjޝTI_jIt~jI4_))?hȽȽȨɩvvvvvvvʾvvvvvӳȳȽȽȽȨȨȨs}t}hjɾӾ}T_jujԩj޴ɩjjɳj_Ij_IjjT_jjuTIjjI4II`TjjT_TT_`jI_TjuTITjԿԿIjԿԴu~^~jjuTIjt޾ިɩӓsuII))?))4_ȽȽȨȳȳӳvvvvvvvvvvvtȳӳȽȽȽȽȳȨhhӨ}hɾs_htj}js꾳ԳɳӴjjhTjsujɓjjjjɾsU_j_UIUjU^ITTuuIIJI?4Ij_ujTTjTjksTjs~s_TjuT޿s~ɴsIT44jɾӴ~ө}jIIjI>)*>T__I>hrrȽȽȽȨȽȽȳӳvvvvvvvvvvv߾vvvvvuȳȳȽȨȽȽȽh}r}__ӴӒȝɴsuj_j_jjhɾ}__jjTIITTjjjIJIITjjj_jjj_ITIJIIjITI?jjT4>?I4I`jjީ޴ԴʴɫT_I4j~?~~ujɓ~4I>4I_I_jIhHS}ȽȽȽȽȽȳȽӳȳɩvvvvvvvvvvʩvvvvvӨȳȾȽȽȽȳȽȽȽ}hhȨ}ȳȴjjjjɴɓsjjhjɴɴsԩjj_uj_j_jjjTITTIuTjjuIIIIIjTujuIIIIIT__j^IsTI4`jI_hjjsɴ괓jԿɕujIjjsTjj~Ijɩ~ITjTusIIIIIjTII_S_}ST}rrȽȽrȽȳӳɾvvvvvvvvvvvuӨӳӳȽӽȨȝȽhs___h_shjӳȩӳԳh_jsԾɓj_jɩɟsj_jI_T__IUjSIjtj_jj_I?s_I`sjjI_T_jTI4IJT44?_Դs_jI_ԵԿʫɞTjkTTIIjԴ~uɴ~jI_4?j^I_TII)?II*>>UhȽȽȽȨ}ȨȽȽȽȳɩvvvvvԩvvvvvviuȳȾȳȽȽȽȽȽȽȨ}S_I_IIIt_j___ӳӳȨɩɳɩjɩөjujj_`j_j_I^jITjsjjusTT?jj_uukuuʵ_JJ_jTIIIԴ~jjԴԿɩӴsI4IԨɨ~j_jI_454?)44>4Th}ȽȽȝȨȳȳȳԓvvvvvvvvvvt_ӳӾȽȽȽȽȽT_III_j_j_IIȩɩɉ_jjjj~ɴӳӳӾɉs___`tjt__t___I_u__ʴsIjjTT_T444*j~uII4*I_TI4TI_j^ju_usS_jjԿ~uT_j_SԴuT)jӴhs4I>j)5)*)4_}ȝȳrȽȽ޳vvvvvvvvvvvvtȳ޽ȾȳȽȽȽȽȽ_h___I5IIIII_ӳsɉshɴɩjԴɴsɴӴ}sssj_`t_I__jjJTITITTTjjɝ~T)?ujI4?>4II?4I`jjujɴus_I*I_sԿ޿sӴԓ^>_jj4)4)5_sȽȽȽȨȽȽȳ޾vvvvvvvvvvvvvȳȳӳȳȽȽݽȽȽh}h_II_>I?_I_hhӳ޳ɾӾӳӳԴɾsjj_jjjɩs_jjjtjjs_stjj_j_^I_ujjj)II*I?jj__II_jsS?I??IjITʿjTIJT4IԴ޴ɴuީԨssIsT)5>>IS_rȽȽȽȨȨȽȽӽȳɳvvvvvvvԾvvvvvvuȳȾȽȽȽȽȽȽ}__I_`II_j_j_ɨhh_jjhs_}ɨԴ޴sɳs_TuujTj__Isɩsjsɴjstjh_jsjjjujssIT_jjIIT_jɴTjTjTjuuԞT_j`II?jjԿuhӾɿIS44?jIIII_rȽȳ}ȽȽȳȳ޾ʊvvvvvvvԾʴvvvuȳȳȽȽȽȽȽȽȲ}__ItthT__ts_ɾӝӳԨɳɩsɩsjh_jjs~jsutj_U_j_tj_TT~_>TTTTjjjuITjjTIT`uT_5*?)`jujTujuIITIjujjs__jIjjIjԴԿuɾj~uTjT4>4I4)))IIȽȽȽȨȨԓvvvvvvvvvԴʴvvvvȳӳӳȽȽȽȽȽ}s_hh_s_j_st}hj}sɴӝɩӾӾs?Iɴɳsj}jj_tj__jsujjjjITuusjTI44?`T?IIIII__I4)?Tj?5jIujTjjj_jj^I?ӿɴ~jjThIII>jsjI_4)_SȽȽȽȳȳɩvvvvvvɳʾvvvuӳȽȽȽ}s_t}_ts__j_Is_ӾɩɳȳԾsjjɴjjɩjhɩshjTIT?4JT_4I_j?_I4?IjjjjjuTuujjt~TtʵjjT4_ɾɴԴ_I_jujj^_jII_j_I>_h>)Is_srȽȽȳ}ȽȾɩvvvvvv龩ʴvuȳȽȨȽȳȽht_h_st__jtɳɳɾɴӞjjȳsT_jjjjTԴuujIjjjԳj_j_Ij`jhT_I__Ijjju)4)T*?jITuuuTk44***?*4>`u_s~_jsj~Tsujjsjuɴ~TTTIIII_ɴjjIII44)?I)I4_jsIhȽȽȽȽȳȨȨȨӳީvvvvvvvvvԾvvvuȳӳȳȽȽȳȨȽȽȨhtsjh___s_ӳsjjjjsӴɾީsjjjjɩhjtsjsITj_jjtj_I___jjjII4I*__I4))4UI*TITʀJ?4* +>)IԠjIjjʿ~ju^_jjjɩԫjTԿԞsj_j_IT_II>?I4*II*)II4_}ȽȽӽrȳȾɾvvvvvvvvvvvʾvvvvӳӳȽȽȽȽӽȽȽsh_I_s_I_ɾjɳ޳I_jhj__IjIjsssj__j__IjU_j__jI_`__TI`IIITjII)I*I?TT4ITIu_T?TjuTIjsT_TujTʕjjsjjI?ujjuTsԴԴ~II_ɴss)T>4_I>J)))>_hȽȽȨȽȳȳɩvvvvvvvvuӳȳȽȽȽȽȽȨt__I___j__j}jsshjӴ_ts_IuӳuԾөh____jIIjIIjIɴt_IJ_?_ujt`j__j_j__T_j_j~I?TII4?4I?>I>IjjjjujjjTUju__ԫuɴjj4T_uTII)I_j~_ɾɾsj5_j>uTI4II5jII>jhȨȽȽӳȳȨӾԩvvvvvvvʾӳȾȳȽȳȽȽȽݽȽȽ}st__]jIh_I__jI___jhts}}j__jsɴɩsj_I*I_?Ihjjtԩ_IjkjjT4*4UjIjI`ujjkTTUsjjjjj_u_TIʴ_ujI_TuԓsjsT_jjj_sIӞj4IU_IIIU4)5I>Ih_ȨȽȽȽȽȨȽȳӳɩvvvvvvvvvvԩʟvӳȾȽȽȽӳȽȽȽs}___I>II__jj}_IIIII>IIts_jjI_T_ɳ}sj_jjjI_j_ӳsjj^_ITj_uTITJTTI?uIITIUjII4?IIT_j4T_uuTjT_ujjTTjTTTj_TIjT4*IjjI?j_jjsjjsjԾs)IIj~h__uHII5>I_^)tȽrȽȽȳrȽȽӳȾȳȾԩvvvvvvvvvȳȳȽȽȳȳȽȽȽݽ}jsh_th}}h_I5hITӳsjhɴɓɩɓ~sjhS_5I_jju_j__j__tjtj_IuTTj_jju^_jIII_I_s~uuI_jjj44)*45I_jӾԴuTj޴ԾjsITIIɩs_4UI)*I*)>_ȽrȽȳȳȾɩvvvvvvvvuȳȾȳȽȳȽȽȨȽsts_hjԴhɴөɾjtȳɩsjȾ}hjjj_Tjjjj_jjIujttj_TUjjsj_sj__ujTT?_IIs__jjUu)4IjԴuuuԴӳӾӾsi44UjjI4I)>?I>?))_ȨȳȲȨӳԓvvvvvvvӳȳȽȳȳȽȽs_j__II__s____I_tjhjII___hӳȾӴȩԴɴөɳɩɳsITIjjjjsjj___j_j_jjj~jjusujs?_u_j_?4*4jjuj~^ITjsjj_*>I?Ju_~jɾ~ɴ~T))Tj3?jI4?jjj_hh>_ȨȽȨȽȾȳԓvvvvvvɳvvuӳȳȲȽȽݽȽȽ}t__II?I?jtjt__II_III4IIӳɳӳɾȳӳӳ~Ӵɉs_jhjjjjjujj_j___IUjs__jɾs__j__TTJ_TTjjju?IJTUI)4Jjujj`ʿSI4IjjjjIʿ~Iu_j~sɿjjS>4>I4^>>4?jI4)I_jS))tȳ}ȾɾvvvvvvvvvԳvvvvvvӳȳȽȳȽȽȽ}sjhI>___IITjjhIj_tI>t__ȞөԳӾj~ӳstjjhj__s~tjtjjj_jjuujujTTjTj_IIIjI)II`jjjj4ITIkjIIjjjjjIjs_ɩh~sIu~)_Ijɝ>)4?_uIIuIjUsIT>)>>_}ȽȳȳȾɾʴvvvvvvvvv޾vvӨȽȽȳȽȝshT_jsj}_j_II__өӾs}S_hjhԴӾshjɾө^_jjjj}suuu~j~jIujT`jT``jI?I`TUjTjTI`jts_ITIITIjjTIjjjT_us_4I*Ijssɨs_suI<5ujT__~III}I>^}rȨȽȳӾɓʾvvvvvvvvvʳɾvvvvvvvӳȾȳȽȨȽȽȨȽȽ}hII_>?Ihj}hTI4__ӳӾӳ}uӴ}js_ɩTjjɩs_s_jjIj_jstsuuu^TjjujII4*)4 +**45*ITԴ_TUII_TTIIjujI4`~sjjsI>TɴuԴ__ST)UsI`~III_sI)IiȨȨȳȳӾ޾vvvvvvvɾɳvvvvvvvȳȳӽȽȽȽȽȽȽȽ}s>4I_}}__I_II_I_IӳjjԴssӳjjjjjj_jj__jtjɩuj_S?II`j_jsIIh_TjIjjuuujTTIIITjI_II_jsj__jjTTT?IjI44^I?^TI`~)Is_j_I)4)_}ӽȽӨ}ȾȨɾvvvvvvvɳɳvvvvvӨȳȽȨȳȽȨȳ}hII__II>I?__I_󳒉sӳjjɾԩsӳ~js}jɩtj____j~uuTjTTIjujTjjujjj_jjjjss4?jj_uuuj4>4IIIT__TIIujs_T`~I44Iԓ_>I?__I4>~>IjTII))>IȨrȳ}ȳӾީvvvvvvvԾvvvvvȳȳȳӳȾȨȽȽ}__IT___j______}s___sjȩȞsjTɩjjɴɩs_s_IIj_j__j__jj_jjj_hT_jj~sj>I4>_ujjjj4j_?j>JuuTjJI4jhhIII4jtɾhjusjuII`SI_Կj>IjSjuT_jsu_j4I4>>4>4_s}ȽȨrȽȳȒ}ȽȾɾvvvvvvvvvԳvvvvȳӳӽȨȽȽh__jtj}I__IIT_}_I_hstӳsɳɩj_j_jIITI_ɴsj~}jjss___jj`jssu~uI__T_*4U_IJJI?*IJjuT445jT>>jUjԴusjI?I_u~I~jjj~I?)5TI4_~SjT_uII>_IISj}ȨrȨȽȽȨ}ȾȨӳȳɳʴvvvvvvvvɳvvvvȨȽȽȽ___ItthI>U__j_hӨȾɾjɩsjsɩsjsjjjj}jj___j_Ijjs~~ju~ujT?T?4T_jjTu4))*>4?TUjUjujIII_^j_Tjj~IIjjsI?4tk_I_jT_~u_T)?*IjTI?T4I~us__hshIItrrS}Ƚȳȳ}ȳӳɾߩvvvvvvvvʳɾɴɾvvvvvvvvȳȾȾӳȨȽȽ}}I_j}}h}ssɩsjh}S_sjɾөjtjɩsj_s__jj__jt__jsju~jjjujTjTusT_*4?) +*4IjjJjjT__ީjTI_kT?u`TTI5I4?II>_^I?II_I4>)I_^IjjTIJ))I)I}rgȽȳȨȨȾӳӳɩʩvvvvvԿvvvvuӳȳӾȽȽȨȳȽȽȽȽ}hh_jISjI_stssjjhI__jjsjjjtjɩɩɓjj_jjj_jjj_sjjjjj~sjshjujuj`TJ`sI*TI5_I)I?I*4*_usI?jԴsTTjsII4*)I4jj))*)4T_sT_TuuuIus4?T4?_~SIjjI)4)_Ƚ\}ȳȾȳȾɩʴvvvvvvvvɳɾvvvvvȳӾȨȳȽȽȽȽȽh__I__I_hss_Iӳ}s__T_IIjI__jjɩsөjsɾ_sjsjujjjj_sjjhjjjjujsj_jjTsj^ujjjII?TTI?T`I4)*44*IsTjj>_II*4*T4_jTI44)4_^I4?4__juITj^4)*II4?TT))I>StȨrsӳȨȳӾԩvvvvvvvvԴvvvvvvvvӳӳȾȒӳȳȽȲȽs}SIIIIII__II>IIӝ_I_`s_tөөȳs_js_jI_I_*_?_jkjjhj_j_jj_jtjj_jj~j~juuj^usuujTI?)*4)>4IjJT45444II`js_TU_hTTI)4ITSjhIITII4IjjII_jT4?Tujs4I_s4>III>?III>)I>44)_Ȩ\}ȽȨȳȾȳӾɳvvvvvvɩvvvvvvӳȳӳӽȳȳȽȽȨr_hI_I>?IT_S>I__S_js}ɩӳɨjjjsɩsjsI_IIjIIIjshjj_}jjjjsjjjTII44Tjs_TI??I45I4~4*)*4*T?4*>TI`jԫjj_TIIIj_jTII5ITIIjIII4)4UjhIjjjjI_SIIujS4)IjII_s>))4ȨȒStȳ}ɾvvvvvvɳԩvvvvӳӳӳȨȳȳȽȽȽhsIII_II>I___jjӳhsjsɾstj_ssԩɩjjӨs_jhIjj~jhsjj__j_jsIjj?ITjjjuj_4ITjɴ~~_)44)Iju_^TjTI4?)4`jjjjjT_I))I__sjts~I_jjIIII5jjjjI_j>jjh~TIUT)4)JIjIIj^))))trg}ȽȽȳȨȳӳӾԩʾvvvvvvvԳɾvvvuӳӳȨȳȾȽȽȨȽ}shIIU_I___s_ӴsӳsɾɴɩhI_T__s___I_?j_T_Is_TjjTTjjst~sjIIITIT_uTIIIISjjjII?jjI?uu`_*?*II**))??Itjtjjj>_T_II_TTUIh__ItjjIII?s_Ij_uk4?4`~_jjII?I)*))))4TȨȨrSȳȳӳɾvvvvvvvvvvԿԳvȳӳӾȽӳȽȽȽ}}sI__t_I)IJ_SIjth___jӳ}_stss_js_Ij_s_ssjUjj_IjIjjjjtTjtsjjjjTThS4_TjɾԴT?>*I*44??JI*)*)4>?_4)4_I_jujjsII?jIjJ>)?ITUjTIjԿuIjjjTI4TjT))?I))Ij_jTIj_4)))))I4>iȽrrӳӳȝȾӳȾɾvvvvvvvvvvɾɩvvvvvvӳӳȨȽȽȽhII_tj____T___ȒsjsԳȩɩӝsj___I__IUIjshs__^_ȳsh_sjjsɩjsjj_sjjIII~}shujshISIjTI>4__tsT)?4jII?4?4IIjjITI__T^>UT)*5454*>?tjtjIII4II_sI*>4*_jjI?IT4_~I5)4)*)))tȳȽhȽȳȳȳɩvvvvvvvvvʾvvvvӳӾȳȨȽȽȽrh_I4_js^_II}sh__ɩ~s_jԴssh_t__j_st_SjɩshIjhɳs_j_}sɳ_jhj_t}jssjTITɴjsjjs4I_jjhshhhhsI454?I`sI>JI_I4_kusT?hTtuuTj4I4I_III?>4>I_IjI44IT_ujj_jT>)4))I)II}ȽȨȨȳӾɾvvvvvvvvvv޾ʾvvvvvȳȾӽӳȽȽȽhs}HII5>I>husjj_jtj}___IT_sɩ_jɉjhjjjjj}j_I`jjɳsujjjjujjujujsj_j_SIjީ~^_jssII?IIII?jjujuTTUTjjss_sIII_sj44)?I4545>T?5II)J_ThujIII*)>))4>ȽȽȨrȽȽӳȳȳȾӾԾvvvvvvvvvvvvvɳԩvvvӳӾӳȳȽȽhI__}}SI5II>II_jh_I_j}stsssԴɉsjTT__T_^jjj_jujju_Ij_jhhjstjhtjj_uuu_jT*I*4IIITjjITIjjujjuIIu4Ius44?ITIsuIjII_`s_jjjj޴Ծ~_4>I4)>`IIII4IIjuITTIII`T>)4))Ihȳ\}ӨӳȳӾvvvvvvvvvvԿvvvvvvvvȳȳӾȽȳȽ_}I_IIh____I>I_j__IIIT_jөӒөj_j_IsjɴTj_I_Tjjj~jjj_T_I_Ijjjjj_s_jts~ujTujTIITT_Ijjuj?J4Iuujj4I4*I*))UuTIIITjj~TjuIsI_`jIIIUjjjujI_IUs4)?I)*)*45Ju`uuj_II4>T4>jtsS>ȨȽȨ\ȽȳȳȳӳӾvvvvvvvvvvvvvӳӾȳȳȽȽ}II5IUII_IhI______j_II>IɴjӝӳhjjjTjI_jjtjj_I_IJ_Ijj__tjtj_s_juu~uTjjjIjT_T_ujIIIj?IIIjjju_II_jIIJjTI??uIIT_jj_U) +)?u^_jkj_~_I)*II)5_)>)4IIjjuI4I44>4?>4))Ƚr\ȳȳȳȳӳӾvvvvvvvvvvvvvvӳȨȽhI_>I)?___>j___jI_j_tjөsjjstI_jjII_jhjjj__Tjjj_jjjutssj_ssuuuj~uɓhjTI_I**5?II???jTI_JjjT4)*I>*>I>jI_juu4)?4>I`jT)?I`TjjjsjjjIUT4)*)?I?TII?>*I))4))jȽȽrȳȳӳȾvvvvvvvvvɾvvvvvvӳӾȳȽ}hts>II_>Uth_I____T_j_T_Դԩjsjtjts_js_4I_Jjjjs_jj`jjjjjjjj__T_jsjjjjtsuuu~jjTjj`jT)) +))44Jj_TI?4>?j_jjj~j__IU_j?st>4`TIJu~uI4`jTII~I_?_I4II>`T4)I4I)4)))4tȨȳȽȳȾȳȳӳȾvvvvvvvvvvvvvvԾvӳ޳ȾȳȨȳȽȽ}hII_TI}_IIIj_jIIIII_Ijjtjh___jj_jTus_I_I_j__өj_T>I`__II?I_jjshj_sshjuuu~ujTjuII4I>TTjTI`T>IIII_T_?IjIIjj~`j_TjUjI>?)_jhII`T)4II?4Tj?4JjjI?_III4I>?>)I)*4)))UȨ}rrȽȳӳȳȳӾvvvvvvvvvԾɴvvvvvvȳӳӾȨӳȽȽȽh_I_s_s_I_II?j__s_jItutjssjsɴsj_T_hTt_jsjjjIjjsjusT_jj_j__I_Ijss_jjIjI_ju^TjujuujuTIIIjjTjjIT)>)?*5Tjj_jTtI`jT_j?45)?III>_jj`j4Uj4>)U4**I*>~TuSjju)*I44?I4_II_`TTI))))))>h}HȳӨȳȾӞvvvvvvvvvvvvvԳԳvvvӳ޳ȨȝȽȽ}hIjIIjIU_jI_hIhI__hjhT_j_j_j_j_I_j_j_jjjjj_jjhjjj_JI?IIUj__j_JjjIj_Ujs_jjjjj__j_IIJI_TjjjuujII_usIT}uIII4I?I*_IJu`*I?T_Tjtjj_III4ItujTjI`_J?44)*jIU_II) +>4?IIIIT4)4*4I4)*?))I>4IjjT)I)) +))4_}ȨȨrȳӳӨȳȳȳӾvvvvvvvvvvvvԳԳvvvvvvȳӳӳȽӳȽݽȽ}sh_I_II_j_hj_jhhI?IIJIIjtjtjI_jɴɉɴsjɩsIjjjIITjjjIjIjTjjTjj___I_uj_Ij_jjj_TjIj_I__IjjjsT_jTjsITj~ITjkuuj*4))4IT_II4?jjjujujjTI4*I)I54>4_jI4_4`_u))?)?I)?jTI_j__j>*_IɿIjIII))))))UtȳhȽȳӾӳȾȾɩvvvvvvvvvvvvɾvvӳȾȳȾȽsIt__t_I_III_sth__tjt_I___jjɩjuԓjjjssjT_4`T?IUII_jjj_jtjjjj~j_jj_jj__j_I_UT_jj_jjjTITj~u~sjjThTjTT?II>TjjujT>I>IT_`sIIIJIUI5>*II)j~I4))?)IIs4>45TIjsjTI`T?jT_u~T_j~j?TIJ)4)))) +))>ȽȽȳ}}}ȨȳӾȨȳȳɩvvvvvvvvvv鳟vvvvӳȳӳȾȳȳȳȽȽr_jhII?I?I)}jjj_jIjjjsjhs_Ij_TI5_ITsj_jjI_T_jjIj_IjIjsIIIIII~s~~jjjT_jj_?IJI?I?ʫu>_II_T>_j>I)4)>Ujj4)*45)I>U^ITTI*45jsjuh4`j44*?jjI454I4I4)*)II) +)5tȨȨȳrh}ӳȳȳȳȳӳvvvvvvvvvvvvԩԾvvvvvvvȳȳӾȳȽȨsh_I>)I5IIjt_IIjhI_II__js_IIs_j_j_Ij_jӳhTjjj_^j_jT_jjjIjT_jujT_Ij_j_kuujIT_j__sjjjIjTjuu?jjItT4?_I?Ij_44I_sII_jIjIII>*>?44)?I>?I)5)>)))) + 5Ӓr}ȽӾȾȨȳȳӳӳvvvvvvvvvvvvvvvɳ龴vvvvvӳӳȳȳȳȽȽȽȽ}h__jTI_>5j___sh__ɳ}j_j__jɞ_jjjjIӴ_Tsjjjjjjsj_jjjsj_s_IjjsjjI_T_jjj_IIU_T_j_uuj~s~ujTj??`TjT_`j?I?I4IU4_jjujITjJ_u_UI4I__ITsjhTI?IIjT5`TI?TI?)??IIII>*I_uI))) + )UȳȨȳӳӳȳӨӳӾvvvvvvvvvvvvɳɳԳvvvvvvӳӳӳȳȳȨȽhj_jhj}_jh__h___IIjujuӳj_jjT_j_sjjjjsTuj_Ij_Ijjjj_IT_j__j_I_I_jITTTjjuusu~uuTj_jjjjsjTUTj_IIjIIII4IIjj45TII?IUjIjj)*T4?Ij_jTIIs_ujIIjjI>I_IjIIII?*_jTI?454)))) +* _}Ƚȳ}h}ȽȳӳӳӳӾvvvvvvvvvvvvɨvvvvvȳӾȨȳȽȽȨh__ts_shssȳjjsjhɾ}^~ʴɴssstu}jjjs_tj_sjj_jIIjtj_jI_jjjj_I_IIjIT_`_`Tuu~~T_jTITjIItjjsTus>I4?II_T4>45>5)?>Jtuj5>I?I4I*sIIII`jTUujjjIJ4)IJ_44)?>**)  +JȨȽȨȽȳrȽȳӳȳȳȳȨvvvvvvvvvvvvvɾvvvvvvvӳȳȳȳȳӳȳȾȽȽr_shs_j__}shh}h_I`_j_tj__Ӊɓ_jɫ~s_jjstj__IjIjIjj_jjjsj_j__UIIUIj_jjujjujjuu_jusTjsjII_?TjTT_j_jjjIIIITI`jjII?4I4?5)?I?I4)I>4_T_Ijj44)?j4)`I4_*I*I`jT?I?jjj4>))?))>tȨӳȳrȽȳӳȳȨȳȳӾӾvvvvvvvvvvvvvɾ޳vvvvvӳȳȳȳȽȽȽ}s__S__h____htj___jjtth___Stjs_jjjT_jjjSIjjIsj_jjsjj_jj_u_jj_sjjjjjjjjtj_j_?jIjjjujjuӴuT_I`Ujj_?T_TjjTuju__I__jujII54)?TjI*?4?T?III_hSj>IjI)5IIUIT*4*>?JI*)5I?*)4) +))ȽȽȳȽӳӳȳȳȾvvvvvvvvvvvvvvvɳʩvvvvvӳӾȳȾȳȽȽȽȽrh`j_IIIj__I_}th>jөTtj__jts_TIj__T_TTjJjIjITjIIjs_^__jjTjjjj_js_jSj_j_stj_j_Uj_j~sjjjsjssjTI4*4?_uIT_I4UTIttj5I*tujJ_`I?5)>IIT_S_ɓj4I)4?I4?IJ) +4*IUTj_I>>)>)))4jȨȨȒȽȽȾӳӳȳӳӝvvvvvvvvvvvvvvvvvvvɳԳԳvvvvvvvvȾӳӳӳȾȽȽȽȽȨrSjtjSTI__jhI_II_I___I_s_Ij_js_jj__jSjs_T_j~sj_j__T_j_jT>TtɩhIuj_j_I`IhjhIjtsTjjj_j_j_IIj_jjs_jj~uu~jsussSIjj_jjjIII_II*II*>?uI*I)5Iju?I>4I4*jIII545>))*))_HII?I`j_jI4) +)U}ȳr}ȽȾȳȳӳȳȳӾvvvvvvvvvvvvvvvvvvɳɿvvvvvvvvӳӳȳӳӾȽȽhIjI_?4>IjS___I_jUSI_jɳ___^__t__sts_jI_j_I_?jtuhIjjjjt_js_jsI___jIJj`jj_j__jjj_jjj_jj_jI_Ij_j_jɴujuɴjjT*jj4III_I_j>*4?)?ju4?I4>TUTjTj4I?IjjI>*I?III5jI`jjjT)*IUsTII)5I>4>)) + + )_ȽȽȽӾӾȳȳӾvvvvvvvvvvvvvvvv޾޳ԾvvvvvӳӳȨȳȽȽȽȽh____tIIIIjh_IIIU_____өh}s_jjj_?j_j_jI_jTjIj_jTjjssjsj_jjs_j__jIIj_sIj___t_j_Ijjjjhsj_jjjjj޴~ujjjujujjjjjjj?j_kjI4U_^TII*?>I4>jju_IIII?44*)Ij_TI_?IIIkjI_thI4)?II)) +)tȽȽӳrȽȨӳȳȳvvvvvvvvvvvvvvvvvvvɾɳʾvvvvvvȾȳӳȳȳӾȾȽȨȽh___IjII__ThtST_s__j_jTsjj_jj_jsj_T_Tjjjjjtusjjjss_jITTjt__j_T__jj_jhjhj____jԴԫu~sThjsTI_T_`T_j`u?I_5444?IjujjT_T_I*4?T*I?j_juu?II)?TTI*I)4)) +) +?Ӿ}ȳӳȳӝvvvvvvvvvvvvvvvvvɓɳɞvvvvvȳӾӳȳӳӳȽȽȽȽȽshjhjIjjjsI_j_jjjtIT_I_Ih_jsjjj_juuj_IUjjsj_jj_sjj_jjɩt__T_Ij_jȳjtI__I_t_j_jU__j_IjjjԴuuTTj~jjuj_IIJj?II4)5_jIIj__4) +) +)*>J_J_`4IUTI)*)??IIIIthI + + >ȽȝrȽӳӳȾȾȳɓvvvvvvvvvvvvvvvvɳԿvvvvvvvӳȳӳȳȳȽȽȒȨhj_S_I____IjɳII_I___j_T__`sI>I_jsjj_j_IUI_IIjIIIj__shTIjjjs_jj_ssɩsjss_jhjӝjtjj__jjh_j_s_j_u__j~uujjɴujuj_T`uujj_jI4?ssT_JjI) +)*U_jTTjIjjjT)?4)I4_))I?tsI)III)IȽӽӨr}}ȳȳӳȳȳӳȳȳӾvvvvvvvvvvvvvvvvvvɾԩvvvvvvvvȳȳӳȳӳȳӳȽȽݽȽs}II_jS>_T_IIIIjs_I__htj__j}II?4T?_jɩjhI_Ij_`sI_j_T_jjjtTju_jj_jjIjsjjjIJIIj_I_I_jhj_T__jj_j__s_js_~uujjuju~ujj`I*I>?jjjjII?I_)* +5I`jjI?)?I`jTIITTI`uI_IIII) + + + +4_ȳ}ȳȽӳӳӳȳȾvvvvvvvvvvvvvvvvvɾԾvvvvvӳȾӳȳӾӾȽȽȽ}}___)UII__II_I__j_I_jjSI?jjj__Tjtɩs_II`jI_T__j_jjjjTII_jjjj_hj}jt___j_jI_j_jshj____I_}_tjjj_jԿusuujjIuI545J_jI_jjjIII_?)545I`jTT4J^_jI4)4II4))54 + + )5ȽȒ}}}ȳȳӾӳӳӳȳȾȳӾvvvvvvvvvvvvvvvvvɳԳvvvvvvvvӳӳӳӳȳӳȽȽ}r_>j_j_I_I>_TIII`hj__t^>?js_j_TjjjjjItj}jtTj_jjtjI_Ij____jjjs_j_jsI_TjttIIj__tSj}js_jjjjjj}ujhju_?)*IIJIUTIIIII?4)?jI*UjI*)?jU_jj__>*)>?I>I?>?II) +)54)_}ȳ}h}ȽӳȾȨȳӳӳȳӳvvvvvvvvvvvvvvɳɳʾvvvvvӳӾȳȳȳȽȽȽȨ}_jtjhIsIj_II__}ss__jujIIIjɩIjjjjjT_II_Ijjsjh_Ijjjj__j_jtjj__Ijjj}jj_I_TjjI?I_j_jjI_IjhT_IɴԫjsTI4Ij`_Tjujj5) +4I5JjjjIII)JII?T4js))??T4?)IUjjII_j^IItuII)44I) )]3}ȒrhȳȳӳӳȳȳȳȳӾvvvvvvvvvvvvvԟvvvȾȳӳӳȾȽȽȽh__j_ts>_I?_ITI__tts_IhjtIIjjj_Ijs__j_4jT?jjsjjjj_j_jsjjj_jujs}j_T__Tj_jj?_j__jh__s_I_Ih_Ij_?_ITԴԞjusTI>*IIjjuj`jjI5>jUjujIIII>IIT)5I)4*)5ujjI_II)4)I?)IjStȨȳȳӳӳȳȾӳӳvvvvvvvvvvvvvvvɳɾvvȳӳӳȳӳӳȽȨȽ\I_hIIUj_IITIII_}j_h}__hhjs_I>IsIj_j?>II__h_I_ujj_sjs_j_jsT_jjjI_I__jj__`_I_`__ITI_IIIԵʫjjj_TjɩjT_TjjujT`_ujjTjI`ujtjujSIII?jjjI*I5444 +)5IusI_jsjujjTI____4I) + + + ))tȳ}ȨȳӳӾӳӾȳȳȳvvvvvvvvvvvvvvɾɳԾvvvvvvvvӳӳӳȳӳӳȽȽȨȽȨȽ\IIU__t_th__I__SjtIs}jh__IIjTsjjT_4Ujjjjjjtjhhjj}sjj_j____I_I____TIjjj_T__I?II?TֿʿʴujIjTJTJjjjjujujjjTu_jjjjujj_I?4I)*)))?_`4UsjII54UT4I5T>sTII_)))))  +)))_}Ȩȳr}}Ȩȳȳ޾ӳȾȳȾӳӳvvvvvvvvv޳ԟvvvvvӳȳȾȳȳӾȽr_____jjS_jj_h_shIt}s}stsjIhIIUsIIIjt>_j_jjjjjtjtjTI_j_jj_jhsj_j__j?T__s_T_jjIUjj_?߿Ԟ_ujjjjjujTIUT?>ITII*>I?)*)*) +4?))`jTI_?54?T)*_jhjsII>I5I>) + + +))_>}ȳȨӳȾӾӾӾӳӳȳӾvvvvvvvvɾɳvvvvvvvȳӳȳȾȽȨȽh>4>5>>)?_____jh4>IIjsh_sjjI__IIIj_j_jhIIjjjj_jjhhITI`jj_jjjss____jj_II_IjIjjIIֿԵԵ~uujUIjIII?4I*_T))))>?45IIJ4?I?I54)?IuSj_4I5445I + +)I\h}ȽȝȳȳȾӾȳȾȳȨȾvvvvvvvɳɾɾɾvvvvvӳ޳ȾȳȳȽȨȽȽȽȽȨr3>ITI)5IUh_>_45>I__hjs_jIjjjsI?Ijt_44>jjjsj_j_sjjjj__jI_j_jj_jjtjjhtjj_j_T__I_IUI__TԴujjJ4TjI>*>)_j?4)) +)54?4*>I*>j_I4*)?I?T_jII)I5IUI)) +)?HH_Ƚӳ}s}ȳȾӳȳӳȳȳӾvvvvvvvvɾԩԟʟvvvvvvȳӳȳӽȨȨȨrhIII__jI>II_j__jhII>__j_jIȩsj__I_j_II?IIIjtsj_jj_j_T_jS_IIU_j_j_j__jjtSjjj_jj_jʵʵ~jTUI`jjI?>I*4I?I*>I)*>)?))5)IU_uuj> +jI)*?II>II?4)>) i}Qjȳ}ȽȳȾȨȳȳȾvvvvvvvvvvvvvvvɾɳԳ鳩vvvӳӾȳȽȽȽȨ]45_I>>>>II__SI5_5>I_s}j_hIjT_jjj_ɩshIT_Ijsjhh_sj__I_UIjjjh}jjhjTjjIj_j__I_IT_jj_jj_U_I_IIj_Եʿjԫjj_``I*)*4)4I?I?)?4Ij~j>Ij_j4))*?I4)?jUI)?))5)5U)_HI_4TI?I?_I>T__jI>jIIII?_jjjths____I_jhjjj__I`__jj_ItjIU_jjjj_Ij_hj>jjjj_j_jj__I__j_T_j__SjIjIIIj_ITUIԴԫɵ~ɴuj`uI44?I4))*I?45IU>I^>?jjuI44I454)?I?)44?>I)4 +I_?)>U>_hQ>tӳ}hӳӾȳӳӳӨvvvvvvvvɳԾʿvvӳӳȾӨȳȳȳȽȨȨ\)*?__>____I>U___5I?)UI____II__Tjjhj_js__jjj_I_`Sjj_tII?__jTj_j])Isjjjj_sT___jT_T__j_jjjjj_UT__I_T__jtʿԿuʴjjI_)>I))I?II>545I?jjjJI`jI?uuITI4)I>?I)I?II))) +))I>hhȳӨrȾȾӳӾvvvvvvvvtɳuʾvvvӳȳӳӳȳȽȝӨȳr35I_jIII__jIIIItIIT_>II5hj_th_jhsjjs_jjj_SI___s_j}_sts__S_I__TjS__hI__T_I_?_j_I_jԾuʞuI?I +4J4UI_I4>IIUI_*>?jjT?4*>jT)I4?IjIIIII?II*)*)I) + +)5_rr}Ȩ}}}ȨӳӳӾɩvvvvvvvkvvvvʓɞʩvvvvӳ޳ȳӳȽȇȽȽrH>_II>>IUII)545Us_I_I_>?_T_II_j}_Ijtj_j_jsj_sjhjjsɩsI_4j_jsj_js_jjjI_I?_Ijtj_jT_jj_jITIT_Ijj_T__ʵԵʫɿԫI)*))`44I?jj___j?_44I`jkI*4JII4U_I*?I4TTITjS>))))5)>_}S}hȳӳ}ȽӾȳȳȳȾvvvvvvavvɳvvvިӾȾȾӳȽȽrȳr}tHj_j_jII5>IjtII_jh__IIUI_III_UjshUj_T____`j_jIj_tjj__?I_Tj_T_jjS_jjjjsjs_Ij_TjI_Tj_j_jtjTI_Tj_TjhT_IUԴԴʿԫԕ_jU>?)*T>5IIIjjS44?Ij?jT54>*) +*>4Jjj4III?4IIjjI4?>)5)) +)J}\S_}ӝ}ȳӾӳȳӳӳȾӾɾvvvvvvvvvɳɾvӳӳȳӨӳȨȨrS?I_j_>?I__>I}h__I>_j__I___}_s_jshjj_TIII^_jsj___jjjjj__j_j_Ihjj__jj_jjsjsjjj___Ttj_jshjs_jII?j_j_Ij_4ԵԵԿsIJuI>?>_Ij_TjIj_IIII)))4)?454))II)III?>*>*)>5)))5II54I   +_GS_ӝ}}ȽӾ޾ȳӳɾvvvavkvɩɳɾvvvvȳӾӳȽȽȨȳS)I)?I_j>4>*4?tjjII>___tsh_hsj_jjIj__jj_IjsjjIIT>_uuj_jjIjjj_j_jjjjjjjsӒjj_tjjh_Tt_jjs}jts__j_jIIjI>II_`__jIIUɿԿʿʵԿԫSI*__I*?U4I?I_I4ITII5I)4_jI) +I?I**))?TI___TIII)I4I>)>4 + +Itr\tȳrSȳӾӳȳӳȳӾʴvvvvvvvvɾɾvvvvvvvӾȳӾȽȽrrs_>ththI>I)>I_th)_jjjhjIT__hjhIII_Ijjj__hjjjIIjj_TIU_IT`jjs__hjjut_j_sjjhsj_jj_jj_Tj_hjsjjhIUTU_T`_IIjshsIIԞʵʿԫɴɫjjjTI*)5_I))) +)4)*I5I4)4>T?*I*)``I)4I?I4I?_TIjI?>4)5I))>J45))>_\Q_}޳}rȨȳӾӾӳӳɳvvvvvavvvɳvvvvӾȳӳӳӳӾȨȽrSI_sSI?_I5hIjhs__II`s_s_j_tIIjsjI__ɉjII_TIsh_j_I`__Ijsjs_sjjj_jI__j}jjthsjhjj_j_T_jjjjITI_T_TITT_jI_4ʵԿʿʿɵujj_4)>??>))*)5I)54)?4>*>I_`I_jjT +4 +5)?I?)?4?I))?II))I?))))>}rӳ}ӾӳȳȳӾvvvvvvvvvuvvvvvvvȳӳȾȳȳӳȽȳȝr))*I?I>I__jII)*>?_T__jts_jhjt_II____jj}jhjjɴs_jj__shI4I?Ij_jsj_j_jI_IT__IjIjj_Sj_jj_jjsjj_Ijtjhj_IjshT___h_j_IIuԵԵʵԨԿߵujjjIII45>)I*>?4)54>jI>45I>>IJjjIUjuuTI4>)I)II5II)JI?)44)?)))?j))))_}}StȽӾȨӾӾӳɾvvvvvvvvvvvvvvvӳӳӳȾȽȽ>)5I}hIIJUI?45jI>>?__jjIIj__S4IUTI_I__T_sITɴsjjjITIjIjT_jjj__IU_IUII_Th_jshj_jjst_jtj_ssh_s_Ij_II_Ijj__sIIu`uԿʿʿԿjIII_I_I_T_) +>?_T)*)5_jII__TIIIITI)I*4?)*)*))*)**IUT__hH4>?))))) +)trr\h}ӒӾȾȳȳɾvvvvvvvvv޾vvvvvvvvvӳӳȳӳӳȨȳȽȨr_jjISII)U_T>?)II>jh_>I_j_>II_jI_j__jjsjɩsjjsj}sj_jj__T_j~t^I_jhIj__jI_TIs_s}jjj}jh_jI_TI_j_jj_IjIjIԿԿԿj_T_4))?I?_II?445_u_I*)*4jII_uI))*)*5)) +IUtIII4 +4)5IIIII_?>?tII455)))) +) +__}rhӳȳӳȳӾȾȳӾɳvvvvvvvavvvuɔvvvvvvvӾӨȳӾȳȨȳȽs_I)?TI>>?>>?)454>?____jtjI>?>ts___h____IjIj_Ijj__jjs_j_IIujsjs_jjs_jIjjj_Ij_jj_j_sI_IIjh_jhj_TsjTII5IUTI?thjIIjI_ʵɵԨujusj_jI>`4I_jJ4T>?jj>T4J_IIIjII>))I)I)?Ijs>?j))4?IIT?I?I?I?I4))) +)5>) +)3t\\_}ӳȳӾȳ޾vvvvvvuvvvvvvvkӳӳȳȳȨrȨ\3)I_`tjII?jh))>?th__h__IUj_I_jjsj_jtSj_II_jjh_sI_IIIT_j_jj_jss_Sjj_j__juhj_T_Tsj}jsjjjj_jj_T_jjjhjIII_T___j_I__TI?ԴԿʿʴj`jujԴjjjI>I*I>`I?I4TIII`_I4TI)?4>IIII)5I_IUjI?j_I)??II**>_I44)5II>*>))??I))Ij}r\_}ӨrȳӳȳӳӾvvvvvvvvvaʿɾvvvvvvvvkvv޳ȳȳӳӾȽȽhI)5I_I))I>?>I54I___Ij__}hhhhɳhsjjhIII~tjjj_uj4I?jj_SI`jjT_Ijjjsj_j_I__hI_ts_jj_jjjhT__jjtj_?_TI__jjh_I_?IUIIʵԿԞԵԵʿuuujjjj_I_I?_`_jII?_I?j_j_?)?)>4))?)II4I*I*4*II_IJI?>I4IIII*I5III)*))?_I>>)5))>_\\tȳȳӾӾȳȳӾvvvvvvvavvvvvvvuvvvvӳӳӳӳȽȨȳȽr}_TII>?II>5I_?IS)I)?_tshjh}hȳs__sj_T_IjIjs_IIu_jITj_jsIIjs_IjI_Ijtjj_jsjh__S_jT_jjjttjj_jjjsj_IjU__UTI_IIUIԿԿԿʿԴʞjjuuITjITIIIIUjII?IJjj`IIIUTUI>4)*)I)I4)5I>4)>?>*)I4I?44*I4>4I?II)I>I?>T)4))) Ur\}ӳȽӾӳӳӾɩvvavvvavv޳Դvvvvavvk޳ȳȳȾȽȨȽȨrIII_jj_I>__I)?>I>I>I_tsish}hI_h_s_jh_jhjsj_j>I?__jsIjIjhIjjjh_jjjjjIjII_j`I_jtjjIjjjj_TsjIjj^_jjjsj__T_T_TI_`jjjj?ԵԵԿԿԫԴjJjjj_jT?jIJ_IkjujjU_T_ts^>)>)?>4*>44_I4)_T>II)5*I5?)4))?4II_jH>>T>>?)> )_tsrrShȳӳȳӳӾӳӝvvvvvvvavvvvvvkӳӨӳȳȾȽȽӳȨhH))?Thj_IIthH?>Ihth____hI_t_II`jI}js_I?4_uj_j_IjhjjsjjsjsjT__I`I_j_jjT_I?jj_j__jjsj___j__jjjIjjjI_I__T_I__I_ԿʿԞ~jju_IT>`ujjjjIIUS44?T45)?)_`jI)4?_jjU4I?II?)*))4?I4I`_IIj_4))) + +)>_rr]}ȳȽȳӳӳ޾ӾȾӾӾvvvvvvvvvvvuvvvvvvvvaӳȾӳȳӳȾȽȽȨȽrST))))>?>IIU_h_tS_sI_hj}S?II?h_}h_hIII_jjsjjI4I4Jjj_sjs__T_jsstjS`_jjI_jjsjh_I__jjjjI_j_Ijj_sj_sjts_jj`_TUj___ʿʿԞuuuju_j`ujjjI_TI?IsI5I_jI))4)*I>4I)I?jjII?_*I?II*))?>>I)4)UI>I>)) +> +)U}QSȽȾȳȳȾӾӾȳӾȳȾvvvvvvvvvavvʞvvvvvvvӾȳӳӳӳȨȨrȽrS_TI)4II>IIJs>I?>I_T___I>III_IIIj_s_T__js_tss_I>Ijjj_ts_SIjjusjhjjs_jss_j_jj_SS_jsIjj_T_j?_j_s_jIJIjֿʵԴɴuujuujsjj_jsI4>I))*>I4I)I?II_IjI?I?4?II)*>_jII4>*IIU_I4)) +))5) )I}rrȨȳȳȨӳȳӾӾȳӾӾvvvvavvvvavvuԳԴvvvkvӳȳȳӳӳӳȳӳȾȽȨ}Ƚh3II?_I>)5>45>jI4__hh__I>I____I__js__jh__j_IjS_s_4UsTsj_I_jjjjjj_s_I_T_Isjjjjsjs_jjjjI_IT_Ij_IjI_ԵʿԵʞsujuuuujusII_?T4 +)))*>I?4?4*I?*II4I))?I)II>4>*III>) )_>s3>__}\tӨȽȳӾӾӾȾӾȳȳӳӨvvvvvvvvvvavԩvvvvvvvvvvvvӳӨȳȾȽȨӨȽhH))5__I3)?>5*5I?>I_I>j_h_TS_s______j_sh_h_IIUj__jjjj__ssjj_jIjsjsjjTj_jj_jjtjjII_jjjhjjjjjjjjjsjjjjjj?jj_jUT_IjJʵʵu_jjuuu`ju`ujjujtj)4*UjjI))45IT?I)>4)4I?)*54?4))>?>4I)II>II)))?I))>))?QhȳȾӳ}ȳȨӾӝȾӾӾӳӾvvvvvvvvvvvvvvvvvvvvakvȳȳȳȳȳȳȽȨrh_tth_)>>I>5II>Th}}hh____s_}_hIIII__j_jhSIjsIj_?`jjsj_jujs_Ij_I_Tjj_j__jjjjj_jI_j_j_Tj}Tjsjj_j_jjjjjj_jj_j_Ijj_jI_ʵʿʿԵԵujT_ʞjjT`__Jjuj`45JI) +I?`))*4?II?4)?)?)UI>) +)I4I?4)?>?I4III4>I)?4 +) +)))_}\StȽȳȳȾӾȾӨӾӾȳӾvvvaavavvvvvvvvvvvvȳӳӾȳӽȳȨ}ȽHIhIII5j>*__III_hS_I>thTI_T_sj}jj_I_S__h__sjjjsjjsI4jjjsjj_jjIujs_j__I_Ujh_js_h_jjI_IjjI_jjjj__j_Ij_jj__jIjjj_jjIjjjjʵʵʿʿʵʿԵɵuʿujJujjuuu4))U5>*)?4544?I)I4I45I*)) +)*>I4)*>II))4>?II)>))) +)))Urh}ȽȽӳ}hȳ޳ӳȳȾӾӳӾӾvvvvvvavvvvvavӾȾȳӾӾӳ}ȾȳȳȳȽ}}ȽȽȨSI>)5>?>5*I)*IIU_SS__h_jhshthIj_}s_ts_j_sjIj_jh_j_^_sjjhj_T_j__jj}jIj_Ijj_sjjsT_TjII`I`jT_jI_jjsjjjj_jֵߵʵԿԵֵԿuʴuuT`uuI +) +) +44)?)I*)I44)?)I)45I)?)*> +5?II)*)*>UI)I?))) +) +I_tH)>t}r_Ƚӳr}ӳȳ޾ӾӾӳӳȾȳӳӾvvvvvavvvvvvvvvvvvvvvӳӳӾӳȳȽȽȽȳ}ȽȽhSI5>?I>)5I)5)>)5>>_>h__hII_ts__II_I_jӳh__Ih_sjI_I_jjjsjsjjI__jjj_IjsjjjT_?_ITIjjjT_jj_IT_T`TjUIjjjjIj_Ijj_ֿʵԵʿ߿Եʵuԓujjjju4) + + +)Uu_)*>?)?)?>>)45))*>?I4*4)*))4?))4)I*I>II) +))I>U^II_}}\ItȽӒrȳȳ޳ȳӳӾȳȳӾӾɩvvvvvvvvvvuvvvvvvvkӳӾȳӾȳӳȳȳȽȨhhHI_I>>>?)?)5?)I_Ih__s___I__I54_I_}jsh_IUIjjI?_jhIjhTj_jj}j_jjsj_jjjTITj_IjjssIjSjIT_j_jj_j_TI_s__j_jtT___j__jjIjʿԿԵԵʿʿɓujjTI`T?))) +>`jI*)IIUTIIIIIII))))IJ)5) + +4)I?>I4I)III5>4) + +))4>>_}}}\_}ȨӳrȳӾӾӾȾӳȳȳӾɨvvvvvvvvvvvavӳȳӒ}ӾȳȾȾӳȳȽȒ}hȳȽS>I)*))?II__h4>?>>I5_>I___I__h`__IIIIshIj_jh_s_jIII_?T_sII_IIj_j^sjjjjj_jjsjjh_js_jsjj_jjjj_ThjjhjjjhjI_`jjjjjj_jh`_T_`T`ʵֿʵʵʴujuuI?4I*4)*4?I4)?II?jT>)4)4)444)*)5H3))4)?45II)>4)) +)))IT}\tӳӾӳȳӾӳӳӳӾӾӾvvvvvvvvvvvvvvkӳȾӨ}ӳӳȳȨȽȒrsȽrh>)4>II_It_ht}}}}hS_II_I__I_I____>_sSj}sIstj_SIIjII_I__j_I?III__j}sss___j_jjj__jjs_sI_j_sTjjjjjsTjjjs`j_jjjj_Ijjj_ʿԿߵֵʿʿԴh^u~4I?*_??_T5)*54J>TTI`III)545*> +*)*H3?U_>II>III?)) +) +)>)))))Th}S_Ӿȳȳ޳ӾȳȾӾӾȾӾӾӾɳvvvvvvvvvvvkvkvӝӳȳӾӾȳȳȨȒȽȽ\hI>_I>I5_I>Ijsshts}ShItS__I__II_I____}hh___I`hj_s__4j>IT_`s_jsjjjSjtj_jjj_jjjhTjsTjjjs_jjjjsjjjjjjjjjjjTj_T_JֵujjԴ޴Ij?4)?I?j?45*_T*_jj4>?4))*)4) +)))*II44I`H4)I?I_?_H)4)) +)I?)>_shhhrrS_tӳȳӾӳȳӾӳӳӳӾɳvvvvvvvuvvvvvavӾӳȳ}ӾȳӳȳȳȨrȽȽhSh_I4))5)5_sh_)I_thIIhh_jhjtI_sIII_^_s_jjj_IIII?_IT_s_^jTu^jjsjhjjjsjTj_jjhj_hTh_j__u_sjjjjjj_jjtjjjj__jj_ԵʵuިuT5*T?_JIII_*I>Jj4>*4>*>)?>?>?4>>*?TthHHHI))II_hjI))5 )>))>_II>I_hs\h_ȳȳȳȳӳӾӾӳӾ޳޾vvvvvvvavuʾvavk޾ӳӾӳȳȨȨȨȨ}Ȩ|h}H>5)))>I_jh?>I>II)I__I_>>_>_hI_Ij_sssshj_jIIjss_j_I?_IJ__T_jujj}sjs_Tj_Ij_usIhjj_jI_T_I_jj_j__T_jjujj_jjjj_jjj_jIֿԵʵɉ>44?IJ_j`_UT)?4__TI>I>44?4UI?I))I))*IUII)_>>__I_II))I5)>>I)TI_hI))IIt}}\tȳӳȳȳȳӳӳȳӾӳӾ޳vvvvkvu޾vvvv޳ӳ}Ӿȳ}ȾȨȨȽrsȽȽr}H_SHI>)>45)5II?>_I_II_s_jsTjh}I__jjjjhs__j_S_IIUjjjjjIj_jjIII_j_jIjjj___sjjT_Ijjsjssjjsjjsjjj_jTUjjjjjjTjUj__TUjʿֿTjTIu>45TujuUIII)?)I?III?III)4?4>4)45S)*>) + +)*^))>I>__]3>tSSiSt3))5IIh_}\h}ȽӾȾȳӾӳȳӾ޾vvvvavvvɾvvvvvvkavɾӨӳ}sȳӾӾӳȳȳȳ}rȳrh}rr}h}}h__>5)IJIII>jhI__III__hIIh_hjjS__hjj}___Ij____I_h4_IIU_jjjtjh_jIIIIssjtssjjjsI_jj_sjjuj_jjj_sssjj_I_Ijj_Tjjuj`jj_jjjjj_߿ԵʵֵֵujuTIITjjuT^_T`IT?UI44?4>4III?I*>?>)) +)U>4544))))UH)4*IItthHt}3US)>))U>>_}}r}ȽӾ}ӾȳȳӾӾӳȾӾɳavvvvvvvvvv޾ӳӾӳȳ}ӳȽȽȨȽ}S_SHI>hSI_h_hI)_)I>II>I?II_I>?IIt>I?II___jII_IjIjII_}TIIjjjj_jj_jhIj_jjjIjIIuɩss_jsjjj__jjjjssjjjjjTj_T_jjjI_I`_j`jjjj`_j`jj_ʵֵuuuT``kjT`jT*jɴsI?I_j?I>)III*)?I>*45*I4)) +)us345*))4U()>4>j}HSITs3?)>)_hSSh}\hȳȳӳȨӾӾȾӳɳvvvvvavvvvvvvavɾȳ}ȾӾȳȳ}ssȨȽȽȒȽȽrIH_H__>H)4>}SII5II_I?jS>IIII>_I4?>I5?I_I_>II__H_hIsIthj_IUIJ_JII?jjts_TI_j~s_jIIj_~j_jjjjjj_jj~sjsII_^IsI_TIUTT_jT_jjjj_jjjjjjֿjujju`juIkuSI*_I>?4JII?I4)*>*)J?I*>sI4) +4)>III_H))5tS)>)5_hQSt\hhȨȳȾӾӳȳӾ޾ɩvvvvkvvvvkvvɾӾӳrȳ}ssȨȳȳr騽rhh}hhSs}jhhIIS)))?hhII>_II>*))I>Hhh}s}}shS>I_jshj_IsI_I_IIJIUII_jhII_jjsj_jIjjjs_jsjjIjj_j_II_IITI_j_shUjj_jjjjjjj_sjj_ukuujujuu`j`jɉ>IJ4II_T_445I4?4`jI4*5TIJ) +) + +)))4I)>4>`h3)>t\))>Ih3Stȝr}ӳ}}ӾȾӾȳɓvvvvvvvkvvvvvʴvvvvvvɾӳ}sӳȳrs^ȳȳȽȽȨ}rȨӽ}S_S3I>>SI>h_>I)54I5II>4ThӾ}hI_sh_I_s_T_jj_II__Ij_jjI_?j_jsjjsTuj_s_jjjTjTUTI?TI?TjjjhTjTj_?jjjjj_IjjԿukujjuuujJjuukTjuu3II?>)*)>`jIUII)>?I>))I4*)*)?I?))IIt4 + +   ) +5hSQ}Ȩ\_}ȳȳrrȾӳ}ȾӾȾӾӳ޾vvvvvvvkvvvvkvvvuvvvvɳȒ}Sȳ}sssӳȽȨȨrs޽Ȩ\h_S>___>>)>I_thS))>ITӾsIII4>_}hjӒhjsIj_hI`jIj??jI_jsjsjsjjtsjhjjssjjjjjT_jI_T_jj_IjIIIIUTjjT_J_IIj_jjjjTUj_Եuuj`uJjku``uuJIj3)I)5)5II?I4>I53)*>?)?)>)54)))*))]>3))))I}r\htȨȽӳȽȳӾӾȳӾȾԩvvvvavvvvvvvvɨӳ}}sӳȨ}hssȳȨȽȳrr}Ƚ}hhhhh))II____>4))I޾sSII4>III>4_IhISIIHj~Ӿr_TI_js_I_j_III?II_uTjj_jT_jjjj_ususjjjtI_jjsIIUjI_III_Ijj_`II`j_jj_jj_Եʵʠuujj`jT?IJjɉ3)) +) +I +))us3 +44?I*)45))5))))jI4)IT33)) ))J}\_}\_ȳӳȝȳӳȳӾӳ޳vvavavvvvvvvvӳrsȾȳ}s~jȾȽȳȽrȽg}}}hhh_sSHI>T>))3)IhӾhIIII)II>I__SI5II__IIIjjI_4IIӨs_jIjjTT__I_T_IT^_~s4_sTjsjIjjjj_jI_Tj_TIJ_jTIUT_jJjjjI_jjjUjjԵֵuuukjkuuTu44IIs3))4) +)454)*)4))jhII4>*))>I_)))>}ȩstS)>_hrSr}stȽȳ}rӾs~ӳӾӾȾӾȳɾvvvvvvvvvvvvȳ}}ӳӾȳsjȨȽȨȨ}sӒȽr\hh\t\h}s_ȳsSTIjhII5_?II?_j_S_T>I___j_I__sjS)I>4Iӳ}_IU_jjjj_j?I`IjjhIsj_4j_T`jjjjsjssTjIjIjjjT_tsIj?_j_kj_T_Jjjjjjju~uuujjjjkjuII4Ih3)>*) +II) +))?*4I_j_II4)>_hs>_4))5sh_}>)5_h\_r_Ⱦ}}Ⱦӳ}޾ӳȳɳvvvakvvvvvvvvӳshӾӳȳȨsssȨȨȳ\ӒȽ}QtshhSH?t}hhts_4>II5II>?ITIITjh>_I>4U_ts_sIhj?)?I4>4IӾsSUjTjjjjT__TIj`j_sITI?T_jsjsjjjujjjj_jj_IjIjuIsUj_T_j?IUjjjjj_u~uuuuuuuuuII)4))?ɓS)) + +ji3)4)Tt_hhj}ssII4I)5)UI>>)UT>)))>jhhH\hȨ}rȳsӳȾӳӳӳӾԾvvvvvvvvvvӳsȾӳȳhssȳȳȽrȳȨȝ\ThtSIT>I>_tSII>UI)?)I>*>I45>?__T_II__4I>I>4___I__IIIITjɾs_Iusj_sjj_jj_T?ITJ`_TUT_ujs~sjjjsjjjsj^_T_Uj_j_IjjIj_TjTjjjujjߵuJukjujjj*4)*4I*ɩ33 + )g +) +)*I_jj_STI4II?4>))5) +?>_I)jS3)>_hQ_}}StȨȾ}}ȳȳsӳӾȾӾӾ޳vavvavvvvvvvvkvȳ}sӾӾȾӳӳ}hȽȨȽȨrȨ}r]SIS>4_jhII>I_I>45>III_I_I_I)54_t____}__I5I__jsI_sIIIIITIIɾ_jI_j_JjhT_IIIjtsjIjsjjjjjssjujtusjjj}T_jjT__I_J_j`jTIjjj_j_j_`ʿuUjuuuuujTj`TI*4*4ɴh U~) + + ))޾SI_}T)))I?_))5}h4>Ut_III_trh}hh}Ȩ}h}ȨӾȳsӳȳӾӳԾvvvavvvvvvvv޾ӳ}hsӾӾӳȳȳӳȾȳȨ}ȨȨȨh\hhH]S}}}}hhsI>?I_I____h__SII>I_j_II__j_j_II>I_h_Sjj_II?I?IITɾ}T_jT_IITjsj_jj_jT_jjjjjjjjjjjT_Tujj_TIT_ITUj`jTU_jJԵʵ֠ʿߵu_u`uuujjTjJTI)) +) +)44jɩQjS) )4t޿iI)*>?I_IU)5))))55II>I>)}3_tsh}htȳ\}ȳȳ}sӾӾӳȾɳvvvvvvvvvv޾ӳ}gTӳȳȳȒ}hsTȳȽȽ\}ӳȳrS}}hhS__sII_II*I_I_I>?_sI_I__thS>II)_I__II?I__jIhsS_IIjhӒj_j_Ijjj~jjjTI?jj_jjujjjjITj_jsjjjsjjhssj_T_`jjjj_`_?TI?I_`j_j_T_ֵuuT`uuujT??_II)44))))I`ԞhH)>_^I5_))4>4I)_?)_))5>)>?)>)5II_UI)I_hS_}ȳghȳ}hs}ȨȝӳӳӾȾӾȾӳvvvvvvvvʴvvvvv޾Ӿ}hT_ȳȾӾȳssItӳȽȨr}ȳrh}rhhII>I_I>___III_IIIIIIII)II_js_jhhs_h_IIj_jIIjs_j_sTI_ȳs_^jjj_IUjjsjs_sTt^jjjjj__j_T_ITjjsjjj_TjjjjjST_IjjjIjJIIJIT_IUjjj`ʵʵjkuuj`jjj4?)>4>*4I) +4Uuި^4))4Ijh())Uj>I)I5)I)4?I))_jt_H>) +__]ht\ȒS_ȳsӾӳӾȾȳvvvvvvvvvv޾Ӿ}gjӨȾȾӾȳsThjȳȨ}}SsȳȨ}S}Ȩrh}s]4>ISI_SII>j}}^IIII_II_Ijhssj__Ijtsj__hSI_ss_sh^ts_jsɳs_jjjjjjj_jTIhsjSUI_T_U__jjs_j_Ijjjjjjjjjjj_jjjjIjTIjj_TT_jֵֿֿʵߵʵ֠kuukuԫjuj*I4>I)*)*I*)54I4))>4_jtȳsh3)))>j3I)I_]}s]H_ITTS)_I4))) +>TSht}Ȩ\htȽȳrS_sȳӾȾӳӳȳvvvvvvvӾ޾^_ȳӳӳȳ}s_sjsȳȨȳr^Ȩr\S_ȨrhSh}hI>UhII5I*>IthIII__IIII>I_ts_S_I____Suh_sshh_I_jjTstj_Isjjsjs`sTjjj^jsjssjjsjjjjjjT_jjsTUjjjT`jj_T`_jjjj_IJjjֵ߿ֿԵ߿uuuuSTI>I4I)*) +>)>_HST3IhIIII*)*I?jj}}ӴȳhSHJI> +) 5>45thr_Ȩ\hȽȨȳgSI_h}Ⱦȝ}sӾӳȳӾӾvvvvvvvvvvvvvvv޾ɾȒ}hjȳȾȳȳӳȳ}s^_jSjhӨȳȳ}ȨrShh}ghshhhsS_IS__sIII4)I?I_I_I?I_I_I5II?I>UhII_j_sj_sIIjsSjhj_IsIjj}jj^j_jsjjj_Tjj_jjjjjjsj~sj_usjT_jjjjj_jsTjjj_jjI_IT_`jjjjIj_߿vujkɴuTTT_jthI)Ih>>S>ThTI4*4 + +) +)5?)5IjIIII_III_>jI ?) +>)>>)I))?)>_hShȨghȽȨ}hIThrhӳ~ӳȳȳvvvvvvvvvvvv޾ȳgjȾӳȝssssIȳȨ}ӳrrhȝr\t}s}HI]I__h_S_jS4JI?II__j_IIIIIIIIIITIIIj_t_IIIIIIɳsIIITITT?I?T?j__^_Tjjss_TssjjjIjjjsjjjjsjhsjjsjjsj_T_IjjIjj_Tj_jj_sj_jjjʿߵԵukujk`_?I_?II?I_jjTjIIT>ITh}sSTjus>>*)*>?IIU_j_I_j_III)>4>I)I54Ut]S>>)))5__H)>thhhhS_\rȽȳrSIjӳ}ssȾȾӾvvvvvvvvvvv޾ӳȳ}shȾȾӳȳӨ}ssIȳȳ}\sȳ}S_}\]r}h}s}hsts_I_4I?II?III_4__I>?__IIIUII>shs_h_ssIjj_j__jI_Ij_jjU_II_T_Tj_ujsjIjjjjj_jsjssTjjjsjjjs_jTjjujj`jTjI_jjjj_߿uujIT*4>*_ts_II>_j__IIjjjsTIT?4*4*)*4>jI___I4>I5I*J_I)4>))4U__I)I>)>I>I)))_TrhSt}\h}ȳgSItȳ}sjsȳӳӳʩvvvvvvvvvӾȝ}hӳ}sssh_}ȳȳrSS3r\SrhhSShs}_rII>IT_shhItSI_jsI?II>_IJjhII__hSj_TIII_T_js_Ij__jI_?I?_jjjssjh_jIjshjj~jj^sjs_jjjIjjjsjj_jjjIj?I?jߵʿuujTIJ_I__jsI__jI?III4*>)I445 +)I5IUI_I__4?>?>)4I_I_I )__}]_t}rhH)5>>hhr\_ȳ}hȳsSSthssjhTjȾȳӾӾȾӾvvvvvvvvvvȝ}sӾȳȳrhsssSs}Ȓ}}ȳrSI>_rrSH_}hhh_S_h_sh_s}IIIII_j_sI__I_IjhhI_h}sTth_j_jIT_j_ITII_T__T_T_?Ij_jjIIIT_jjjjsjjjj^_jss~sjjsjjjs_jj__j_Ij_jj_jj_jj_jIIj_jʵuujIII_JjI*)5IjT>)4)*))>I)?>)4)5))III?>*)545T_4?Ij_II_hIUjI_>) +)_>tsS_hH>I)SI>}}hSt}}}ȽȒgS_js}s_sjsȾӾvvvvvvvvvӳ}hjȨ}}^IsȨr_ӳrhS>_}rSh_rhhs}h_hhjhsh__hjh_}hhI)IIIjsI__j_sɾsSIITIIIITjJ_jIj_jjjjj_j_j_IIjjIjjss~jjuTjIjjjjs~j_jjjjjju^j_^jIITj_jjjjj_jjjsjjsֵߵvuj`jT_T`jI)?>`j)4))II)I>4?I*I?)I???I4 +4I*II_III)4>II_?I))>IS)i}Sh_t_H>)U}rsrhȳs\I_sssӳrssS_ӳȳӾɾvvvvvvvvʴvvvȳ}}IȳӳȨ}~ss}}Ȩ}\sȨ\)3>h}}}rhhr}}}hSSI_shshhjSIS_^_I>II?>II>II__I_sS>III__jIT_Tsjjjjjj_hj_T_jj_Tjj_jɳjjsjIT_Tjs_sjjjsjsjjs_Tsjj_jj_TjIjjjjjsjjjujjjֵֵֵvukujj`T_jTjIJ44I*I))5>44I_j4)))?4) +5)?)?4?j_>I__>445IUHI_I>))JI_tsI>>I)IHHT}h_h}SS}rSss}ȳ}hӳӾ޳vvvvvvvӾg^jȾȳ}s}SThȨrss}ȳr}Ssr}}hhst}hh}sjj___II>I_I__I_sthIj_I_IT_jtjhIjjIs_jsst^`jtjtj_jsjjjjTj_jjj_jsjjjTjjTjj~jj_Tj`js_jjjjss_ֵֵvvuuk_?j`I?I))?4>4))II)>?III> +)*54 +) + +)5IU>)_T__*))) >jhHI_TrSITITj34)_}hh3_rrrhs}ShhsȳssȳӳӳɾvvvvvvvvvvvvӾgSjȨ}hshjȳȳ}\s}ӳȳrS>hhȽrhhhh^h_I_IS__h_4>IITIhI_S_II_I___sII_>s_IhITjssTIjjIjjjjjjh_jj_jjssjjjj_TIj_jjIjjjjhjsj_T`_sjjsjTIjjjjjjjjjj~jujj̵ֵvuJI?IJI*I +4*>?II>IIjsI__II4))*>)4))?)) +)5))>>?)_*)*ITII>I>I>?I_II__4>>I)))>)5)HTr}\h}r_}ȳ}rsӳӾȾɳvvvvvvvvvvʴvvvvv}SIȳȳ^_Sj}ȽrhȨ\SS3j}Ȩrhrr}SS_hIS_jɳSIIII_I___hhSs__sII__T_sThj^_jjjs_jjjjsIT_jj_jjI^j_jjujjjjss_?_`jsj_T_Tjj_IIj_^jj~jjjTjjjjjjjjs~jsuu4*_I5I*>I?j___j4>?I4?I?I?jIjjI?>?)I*>UHIIIjssII>II?T_j___I>>))I5_th>>_H5hHh]h}rhr]SH_rȇrsȨ}sThӾ޾ɩvvvvvvvvvvvӾg>jӳhsS_ӳӨȳȽȨ}Ȓ}\ISSt}ȳrS_hhh}hSI}hh_SI_}hsh_}ssɳS__T__jIj_jjj^_TIjsjsjjI__`_I_IITIITts_IT_jsjjsj_TT_sjsjSjjTjI?TTjujj~jTjjjjjjjjjjjussֵʵuJ4**?I*TU*U_jjjI)I)*)I)*4545*)>U>45I_j]}}shth}IHIjj_jI*)JI)>?>>4>tSIt}hhST}Ȓ\Str}}ȳȳs^jsssӾȾӾӾɴvvvvvvvvvvӾgsȳȳ}sssh^ȳȨȳȳ}}SS_Ƚ}rSI}hshhShhhhhs_hs>IIT_ShSjӳhs_hTII___S_sS_hIjI_I__T_Tj_jT_uh_j__jjIj__jIUjjjjhjs_jjjj_jIjjjujsTITIjjjsujusjjjjTTjjTujjI4)`jJIJI4I_sjI)*)>?I))?4)4)IT4I4ThSTII5>?II + +) +*4I))U>h=IH>_r\hhȳQh}}\hӳ}ItӳӾɳvvvvvvvvvv^jӳrhsh_ȳȨrs}ȝ}r^SIsȽrSH}r}}sSITtH_H__Shj}}tjhIsh}sI_j__jjIsjIT__IT_jjsjTj_j_Tju_TT__jT_jIjT_sjjjj_jsjsjjjj_jjjjjjujuuuujjjj_jjjTu_ֵֵֵ֬ʿֿʿu?)JJTk4I*5_I)*)5)J4)UI3)>)>)>))5??*?I?II?>I)__jjjsjIIIHh]}](= ))j_H_>H_jSSI>}rhȨ}g}}r\ȳȳ}sӳӳӾɳvvvvvvvvvvvvi^IjȾӳӳȨ}sSjȳȳȨ}hȝ\II>shȨrrITr}r_hj_hhs_sIjrhjhh4II)IIIIssh_shsT_ITUjjsT_4jjhTjjjjIjsjjshI__ITjujjhjjssjjs}sjjjjj__jsjsj~jjsjusjjT_jjjjjֵֵߵԿɿʵʵʿuI???jTI?4*III*45I)*I?)II>)_ujI>))))?I)*>*454>I}Ծɳ]HI>_II?I3>5_s_SIh}}\T}rh}rhȝ}sȳӾȾɾvvvvvvvvvvv^TsӾӳrhsShȳȳȨ\sӳrr>)_Ȩr>IhS}hsr_}hh_S_h4IIII_jjss_I__S?>4_I__IjjsIjsjshjsjI_Ij_jjs___IIjTjI_IT_I_II_I___ssthss_sj_jjjjsjjssjjjjTjjjujsjjsjTjTTjֵֿԿujJT`ukj`44*?)54>44>I>T]3>4jsTII_j4 +) +))*)))4ɴjIT4*IIIII_ӳSH_]H>>HJh}r\H4_}}r}h}StȳӒ}sӾɾvvvvvvvvvvvsӾӾӳ}r^sȳȨ}rhӨ\4)IhȨrSS>_}rh)rS_II_hIIII>?ITIhj_jhSI>II___thshsjj_TtjshIj^jh^_jsjtT_TjI_tjsIT_IjI_jsshjh__jjj_jjjjjjjjjjsssujjjTjjjjuj~sjjjuߵʿuuTJ_jJ_jT5I?)**5ThhIj_I)*) ))) ))))3IHޝshjHSI))4 +)T)I_h}HTI>_hȳQIt}h}}\Sȳȳ}}T_޾vvvvvvvvvvӾӾȳӨghs}ӳ}Ȩ\hȳrhSHIȳ\rhhhhshshShhsh}hhshhhII_II?>sIIhhh>hI_j_jsj_jIII_shsshTI>Ij_jjjjjIjT_ITIIjjjsTTI4TITI_jsjjjsjjsTjIjjjjsjjjjjjjsjTjjjjus~sjusjjjjֵֵֵֿku`uJT`5_JI4 +))))4I))I>hhɾɿӾө>)))?>))5>hshthS3>I_\ht}<>I_rs}S>jȳ\shsɾvvvvvvӾȾȳ}rsssȳȳȽ}rӽ}hS>_}}ȨrS}rSS_rhhhhhrhh}hh}h__jS>I_I_sshS_I>I_jItsIjjs_jj_jjjI_jTIIjITjTjIIjjjI_Tjjjj_IjIjjITjsjsjsjj_TjTjTjjT_jjjTjjjjjjjjT_jujjujj~~jujֵʵʿku`uJ?J_uJ_J +))ThɴԴ_Jjjjujuɝ~ɾӴi +))>j)ITh}h\>S\]_S}ȳ>4)?Issh}}>_h}r}}}SjjӾԩvvvvvvӾӳ}}h^Өgȳȝ}II4IȝrhsS]rhH_hh}s}sSIjhII)I4?__j}}s_hI_I}sjjjs^IItjjIIIT_T_js_Tj_IIjI_^j_T_jsjsht}j_jjjsj_sj_Sj_jTjsTjjjjjjIjjjjjjsIsjjjjjjjj~jj~jֵֵʵֿԿ_T4TIISI^ԿԞjujjs4IIttH)))>?jI*)*Ծ~jsT_II)4?II)))>H))H}S3h}hS_ThhSIsȨr3>_}h^_}HSISI}}h^Iɾvvvvvvvvv޾ӾӾӳӳȳ\shӳȳrghsȳ}S>))I_Ȩ}rShh}rhshS}rS_hshh_sh_h_IIII?_SIII>I_hhI?_j_hjtsshT_jssjs_T_IT_Tj_T_I_IjIIjs_I_IIjs~SI_jjhjsjjTjjITIjT__T_jjjjs_jjjsjsjj~jjjjjjuujֵֵֵֿʵԿujuT?II))IIIIIjSI_) +)54__}jިs^_I_IIII>IT>>T> )))_hStr}rtsQ_h_S3>sr3>Sjhh_ȳr>IIIT_sSjss\hsɾvvvvv޾޾ӳ޾g_sȨ}ȨgSȾrrhh\>hȨrr_ȳ}}}r^StsH4>>j}hS_hshSI_t}__II_IIIIhSj_sIII_j}j}jssI_I_?_T_jjT_jITj_jjTITIjTT_jjjjjssjsJTJ?T_TTjjjsujusujjsjjsjj~jֵֵֿߵߵʵֵߵuT*45II54III +*>*))5_I>T_}]SI_4ިIII_j__4>I)Ihh|g}hH>>S_]>>)_IIhhs}rhhhS4)I_}SIIISSSSII}sӾɾvvvvvvvvvӳSSTs}}Sj}SUh}r^Sh}}ssShtr\SI>STthhS_s}ssh_S?I4TI4_>ɳh__j}_Th_s^sT_jTIT_jjIjIJTjTjjjITjsITTjTTusjj~js__^_Ijjjusj~jjjjj~_jsujujjjujuֵֵֿuuuukuT4)?I*I4?4)>>54))*I>4)?tȝST_I*ɓjjjjjjsT_hӾӴӾH3))I_t}hshh}rS>>)_S_}<>hhrhr}ȳȳӾɾvvvvvvvȳȾȳ}}SIjӝ}ss_STrS}rrsȨȨ}rSShhs}}hS_shIhII_hsh^SS_ss_II_IIIII_Ij_hs_sjssshsssssjIj_I_Tj_T_IIjsj_jjjs_IIT_I4j~_ujsj_TI_Tjjjjjjsjujjj_jsjsjjjuߵֵֵֵߵֵߠֵ_uuu`)JI*4>*T?I*>))>I___hSIjjS4_ihII>4IUjsI޴sj__4>>)>)ITsɾɾ}h_I_I>I_h_}rS}r}}h}shȨȾȳȾԳvvvvvvvvvӾӳ}STTs^s}hshtsShs^SrshStshs}hh}h}hhhrSSIsh_j]__htjI?I?I>_TTIshɳhS__ssjh_ssjhj}^jj_jT_TjhTsjjjjjsjsI_T_TIuT_j~sjssTI`Ijjjjsujujjuj~jjjjsujjjjjsuֵֵʿֵߵuujuuuu*?jT??5>*T5I5I))))I_s__jI44>I޾jIjj_^S_Ӟ~44))5I?>I)>ITshj)))II_sSIh_h\HIhrgtrh}hghhȳӳ޾޳vvvavvvvvvvvӳhsss^_TshSIS>rrSShrs}}\h}hshh_}s_}h__IIII?III_Sj_S__j_^_IIII}shjjjsTsjjIIj_^_TITIIT_IjjjsjhjIj_jjj_jjjTIjjjjjujjjTjjjjujjsjjsjjjjjjujsIjjuʿߵֵֿʴʵusTTjshS^>34)44)4I))?_sT_I__htޝs޾js_jI4)))>3))_II_>))))5TsrhI_>I_hrShSI_ȽrS_}}h}}\hӳӾɾvvvvvvvvvvvvvvɾӾӳӨ}}Ⱦs^Ij}ȳ}h}shhsȨrshHS>ȳ}}ӒS>_I]I_hhhS4I_jS__II>>Ij_jIIUshjI_I_IIShssjh__hj_jj_Tj_T_4TjIuIjTIIIT_jTTTTjI^jhjjsTjjsj_sjj_jIju~ujjuj_jjsujsjsjsjjsjjjֵֵʵʠujjuuӾӳ}s]H)Is_IjI_jjӾsө_S_Iɿs)_?I)))>>4)_hS_SSt\>__Hr\H_Sh}}}}Ӿɾɳɴkvvvvvvvvvvv޾ӳȒӳȳȳ}h_ssȳ}rs}hȨrhhhrhs}}SsӾh_hst}SI_IIIIIjh_jsIhjjh_sI?TIjj^_jsjsjjsssI_hjhjjhTjhjjjjujjsj_II_I4IIj_jjsjjssTssjsj~jhjTjjjjjsssjsjjusjjjjֿʵֵkjk4IJuӾީө޴TI) +))))>j}rS__}h\ht}rhjhhhs}sɳvvvvvvvvvvvvvvvvvɾӳ}ӳȳȳ^jsh}hsh}r}hh}3?}ssHjӳShjh_h_jhI__jh_I_^_IT__ss}jhtTsɴrhjs_sssjs_s_h~Is^_js_jjj^_IIT4TjjsjTsj_jjs_jjTjsjjuhjjusjsjjujjjsjsujuʵuuTJjuuT_J_TTT*4?4TI*IIIIIIӾ޳ӳ޴s_j___(_=4TST_hhhhr>h^h_shhht}hhrI}}rrshvvvvvvvvvvvvvvvvvvvӾ}Ⱦȳrhr}^h_}rshSII_shhshhS>TISh_S>S_IjӒShhhshh_TI_hI_I__s_}}sɳsjshs_sIjjjjs_jI_jjsjsjjIj?j_jjI_IjjsjhjjjsTjjsjjsjjjusj~jsuujsusuֵֵu_jkT_TTJJT?T?I?4jj*4)Ujjjj__I_~޾T>II>Itsh3_>_hh_hS__jsSh_trrshIsIt}hshSsvvvvvvvvvvvvvvԾӳӳȳȨȳ}sȳrshs}hshhSIsrShh}]hI>I>_s}sHh^]jިs_h_h_}ssS>?>_IjshjsjsjjssjӳhI_TIjjs_ssjjsTITjjjjjjjjjITjjIjjjjjjIITjjssjjsjjjjsjjsjjsju~sjjjֵֵֵֵɳujjTUuvkjT?I?ItTII)_I>jjh_ӨsӾɴɩsII_TIT)*I>_I)>ISSIIII_jIhts>)ItsSS_Shsh_SS_suuvvvvvvvvȳȳȳӳȳ}}Ȩ}shjh_hhhhshs>s_>_4>SI_sthIj}SSӳtsth_I_h_IjII_hj}}h}sjӾh_htssjsjsjIII_T_jj_jjjTTjIT_sj_Ij_^U_T_jT__Ijj_sjjsjsj~sjjjjsjjujsֵֵֵʵu޳ssju_JITIsI))II)jII_jɴӾɾjjh))))>hӳӳ\Hjh>_hShhhSTts^^~uvvvvvvvvvvvɾӳӳrs}r}S4>II_shhhI>_}}h_I_3)__IIj}s}hsI_hhssshtshsjssjsjj_stTj_j_j_TjjjjTI_jhIs_jhsIjjTjj_T_jjTT4_?jjjjjTIjjjITjsujjsj_jjjsjֵʵߵuɴuujJjj_?45IIII>_hɓɳӳӳs_өӴsh_jjӳ}hhhhI}rSS]}suuuuvvvvvvvvvvvvvvvvvvvvvvӳȳȳȨrs}}}sh}shSII_>>Shȳȳr}}SH>_}}Ij޳r4_hssh_hIjS4ThӳsssIjI?__j_Ijj_Tj_jjj_sj__jT_jTjIIjIjjjs_jjjT_jTIIsjjs~jsjssujֵֵֿuuuj~juIu`ujI>>II)?I_sjsj޳ɾӴӳӾS4>>I>IIIT>>>hS}hh_hȳrhhh_vvvvvvvvvvvvvӾȳ}Ȩg}s\S_\S_ȳӳhshs}}hS_I]S_޳S_?I_III_IjɾssjsjhjjI_IjIjs~ӳsSTI_Tj_T_jssstsjhjjIT`_jjIj_jjIjjssTjsjsjujTsjsjsujֵֵֵujjsjjU_I>I5II_I_hsӾӳӾ~ԿɴTI)>I_}S>>I>_h}S4)>I_Tɳ}h}}~ijuuvvvvvvvvvvvvv}r^}ȳrh^hjȾ^SIIS>_hs}}ShhhSt}rhh}h_Ihrjh>)_hӾs_T_jI_I_III__I_ITIIj_jIӾs_jjTjsӴsIITjIjjsjjs~js_usTS_T_jjjIjjjjIjjj_jjsssujjjjsֵʠjjTuujjIIjj_jjI4_IIjjj~Ӿɾ޴ɾ޿s^III4>I_]h}H_h___II45I>))))>T}h_^hs}s~_jjuuvvvvvvvvvv}rsh}rshs}}sshrhHhhsrhSSSI_h_shs}h_hh_s}hShӾrӾsh}j}jh>II_Tjӳsj_j_ssӳh^IIjjjjj_j_jjhujhj_jjjjjj_jj_uj_jTjjjjTjsj~uj~jujjusjuֵֵֵʵujj`ujjhsI4))?54)>IhȾɴӴ~sj4))))4I__hIT4)*>4>HIh}SH>IhSh_ts^_juuvvvvvvvvvvvvrss}ss}}}gh}rhH3))_ShSI__}hI_}sh_rhhS޾^_jӴɳhhSIt^hjɒsjITjjI_hIjsj_TjjhTUjjjjjjhjs_jITjTUs_jTjjjjjsjsu~jsusʿֵֵֵ߫u?T`jjuɳI)5I4I)>}ɴɾj~ɴɒ34>II>>>)_hrhhhhh}sh}}}~juuvvvvvvvvvvvvvvvvv}}}hh}gh}\thrShjhhShII_S_]_S_h_}h}hSItsӳӳӾӾ޾ӳhhshӳhIɾssITjjjjj_us_sjhTjjIT_jT_jTjjjjjT_IT_jjjjjjjjjTjsjssjjjֵֵTj`jjIjjj)I_Դ~j޴ɴӾ~޴tj>II>SIsh_h}hhhsHIIhSShhsr^T_ujuvvvvvvvv~}r}sr}\hsS__}S}S}hȳ}s}shss__TIT_T_jjsjjӾ^Ӵjɝssj_TjjhTSIIjsj_IjIjST_T_I_jjjTjjT_TjTsjsjsjjsj~~js~jjujߵ߿uukujujTT*I5ITjjjԴӾ~޴uj_sj))4))USth_hh}h}shShth}~^Juuvvvvvvvj~~~Ȓ}r^}}}s}s}Sss}}hI_hsȳ}S4IIhhjh_shjhI_hjshj_jj_usөssjjhjjj_jSITItsj_jjII?I_Tjhjjs_sI_TI_jjjjIjjjjsjssjsusjuֵuT`juujuII_jj_4)>j޴޴ɴɴusjI) )_H_H?tSh_}h}}\]}\hijjuuvj~}}}}}rhhshShht}hjss}}ȒS_H?IIȒ\I4_s_S_It_j_j_____sjhsIIIIIjjө}jsjjsjjITjITjssjj_jTIIj_jjjjjj_T_jjsjsjjsjjjjj~jssjuuj~ֵֵuTTIv~uuTTjjjII4II_ujɳuɴhII)>5___S>IHhhSHt}}shhs_ssi_vvvvvuuuȳȨsssrh}}hhhSs}srh}}}hrH_SShhshhjs_jsS_hj_Tj_j_jI_jI_II_sSө^jjjITIjjjjjsjjSTTIIjjjIjujj_Tjjj_jjsj^jjssjj~jssuֵujuuIjIT`j_4_I?I_j__jTjɴʴu޴Ӵ}hI?4SI)jhIIIIt}SI_rs}sh}s~~tijuuuvvvvvvvujuӳ}}rs_s}hShhshsrhs}hhhSIsh^^sshshss_IsTjjIjIjjs_sjӝsjsj_T__^_sjsjj_I_jITI_jsjsjsT_IjjTjjjsjj_~~usjsjjuֵֵֵֵuuuj?jUT_I*_II)?JIӴԿujԴӳȾȩhT>I)_s_I>IS>>_ShH_hr_rs}sss~~~__vʴvuuȳ}h}}h}hshSIsts}^_shhshӾӾӾ޳ӾsS__jjjjj_ITs޾ȝjjjIjjT_jj__SjIj^__jj_j__ujsI_Tjjssssjjj~jssjj~ֵֿuuuTT_jsI?jIT))4Tɴɴs޾Ӿ~j4) +IISI>hIh_Th}g_}hhhh^s~~__juuu_u}}s}hs}hhSh}rhhh}s}^_hs}}hj}s}ssjsɳhsT}j_T_IIsӾhsht~sjjIjII`sI_jII_jsjjTj_jjjjsjss~jujuuj~Tj~jjjԴԿ޴ӴӾӾS>)>))5>?I>jsS_T_Isrhsrsshu~_jujuuvvvvʾʾvujuss}}hSh}>sh}}}rS_s}s}shjss}sshsSI_sh}}hsjhj_sjjӓsj_TITIITjj󾳓sTsjITjIsjIjIjjjjj^jjjsjjjsjjsjjj~j~ususjJjTI޴jujԴӿӴj_I>)))III_hhhHStsst}}s~^uutuuvvvvvuԾvʾʾuj~~sss}}s}}}s}Ȩ}}hsshjS_II4_S__hsjsjjssjhjss޾^IITSIjss޳usjIIjjST_sshjj_jjjjj_TI_j~ssjssjsju~~sjjjjֵ~jjjjTIUTIuɾjjjjʿʵɴɴӿ~޾ӳ~h)]sj>>s}ӳr}s~_jjjuvvvvuʾʾvvj}~s}ss}ssss}}hsh^j}}st}s_hhshs^jjj_sjIjjӳSI_TjTjsީsjtu__jI_`IIjTj_jsj_jjjsjTjjjsjsjsjsjjj~~ʵʵuuuujjjjjJuJjjSUs4)?Ij~Դԩɾ޴޾Ӿө}s~sthsShss^~ij_kuvvvvkʾʾԴvusr^j}shS}hrssshTtsI_Ij}_S_h_}hsȨsssjjjjs_jjhjӴ}II_4T_ssӾssjIj_sIIT_jsjIjjIjsjjIjjj~jsuj~sjjֵjuuTI?jITIITIIIӾ޿Ӿ޾Ӿӳ~Ӵ~I?4>5)4)>>hhS__ssss___juuvvvvvukukukuvukԿʾԴv}r}hs}ssI}g}}Ȓs_jss_}sshSI>I>_4ISITjsӳȝhj_TjsjhssTsjssjމSS_TjsjɾssT_~_jIjsjsjsjs_jj_ujsuusjֵߵuu~uj`jjjI4U^IӴԿޓ~ujɴ޴ӳ޾޾~4))IT4>S>S}}h>I_shhSjj~^_jjuvvvvvvvvuku`uukkuuuuԴԾʴʾvvu~^sӒS}sshhssӳS_IIIsIsh}hhsӳȳsjjsssshTj޳sIIjs^IjhTIjsj_jsjjjujjjjjjjsus~߿ֵjj~uujuujj^>>ɴj_juj鿴Դɾ޾ӾޝөޞsI)))))}s}}hhSI_}shs~i_jjuvvvvvvvvkukj`jKj```kkkuʴԟʾԴԴvut^h}}srIsrS}SIsSj޳SII_ӳss_sST_tssjj~jjjj~jssTԾ}jIjjss_jsshSThshIj_jsshTjju~ujuuߵʵߵkuuuujjɿ~ɞuujɾӴ޳Ӟ^I))IԾsj_j]}rSth}}s~iujjuvvvvvvvukKj@TJ_55J@``k`uuuʳԾʾu}ss}ȳhSs_s_s}SSIt^ӳ}3IIIs}ss_sI_TSS_shss~jjsjjjusjITjӝh_^jj_jjsTj_jsj_jsTjj~jjsjjs~suֿߵֿsuuuuujjutsII*)*>4I?jɓu`jӴިӈTIt޴TTI>>)>hhrhjhs~i_tjuvvvvvvvvukuj`?U?JTJ55J5@`juԾʳvvvvvhh}hhjhȝSI}IIӒH4>_IhhsISTTStshj~ssTsjjsT_jTɾ^_jsTsjjjssjj_jsjjsjusjsuuuֵߵֿjuT`jTus4)_II*TUuITjԿɾޞuuޓ޾Ӟ~j4) +)>_S_s_jI_hhshSIIIjSjs~~~juuvvvvvvvvukjU_JT?J?*545@uɾkjk`UUKUVkvvvu_j~s}s}}^jӳhSsӒSh}^_jj~susujhjjIsjhTjIɾssTjIjsjsThss_sj_jjjs~sj~~susj~ʵߵߵjuuTUsutuIIUjuI_uu_޴޾ɨ~TޞɞTI*>I_TsIsTI) +)Ishh]S]shssui_jjuvvvv`KJ@JJJT?J455kuԾԴujU5T54J??*?JJ@kuvvvu~j}}h}}Ȓss_h}hS>>^ӳshsӒsS>j}^SjhTsȾjsssjsjjjjjI_jjhjs_jɾr_TI_jstTt}jssssjjutssusujߵߵֿߵuuuJjujj~ԿԴɴ󾞊^IISj_sI_h)?*>)__IS__hrjSjutjjuvvvvvvvuuU@J55T*JI*?`vԾԴu_?4*IJTJ5T5_5JU_@kuvvujis}}sshhh_jhs>IjӾȾ]sshjhss}jjj~j}sjIjjIjjjsssӝhs^_^jIIj~sjssjs~uuuujJIjuuujjuIuuSjs޾ɾɾ޾Ɋus}ӳsS_TTsI4 >Ө3I4I}}ss_^u_jj_uvvvvvvvvuk``55??J4J?@ԩɾԾjJIJT*5TJ5JU@`jUJ5JKuvvujs}ssȒ}_ss}}sSI4_j}sShT4Ij޾rSsjhT_sӾh_j}jssjjsjjTsjsjjj~}ɾhjs_Thɒjuj~j~jjֵߵujujujTjjj_`jujIIԞu޴ɓӾ}ITt~>IɾiI)5_shjhjShSsssruuvvvvvvvʴVj555T?*?5KԳʿԟԾʾjJ*T?I*I_@J`Uuuuuuuvvu~}~s}}s}sSj_s4>II}}h>SI_s޳S__^_ShhhhssӾhshsjjsjjjjsj~s޳~hsII_}s~jjjjjs~sߵֵֵֵַuvjkujukIjuj_IjT_s޴u~hT_^^s޾Ӵ~T_~^I_޾T))I*>I_sSHȳuvvvvv``@54J?*4KʾԾԴuj5IJIT???`juuvvvuj~s^}ssȳ}s}shSIII_ISS__hhjhӾȳ}sjsɳ}jsjsj^jjjjjjssɾ~}shh_hssuss~sjsuj~ߵֿjkujIj`jjk~j_jj~ޕԴӴuIjsޞsjts4)))TӾs^4I`jjuuvvuuU5?5T5UUvɾʾujT???JI?_juvvvuu~}^Sjsshjt\IrII_Isshj_sI4>jssӝjhh}shjȳs~sjjsj~~jsjӳsjjsjssssssjujsjj~߿ʵַvTU_UuIJj~_޴ɵɴ޿޴ӾӾ^>__S)>TȳhS>I>44T_juuuvvvv`U55*IJJ`ԩuj5JTT__Jvvvvvt~}s}shIsh}_shshII)?h4I_Ӓ>I_sshh_Iӳ~~sjjss~jsTԾ}jsj_TjTssssjsjsusֵֵַֿʴuu`TTj_IjIuT?jusu޿޾Ӿ}4i}s_hSIIthhSI?utuvvvvvvvvu`U@5?*?`ʳԾuK*45_Kjkuvvju~s~}}ӳ}s^hhS>htrI_sStrI>I4_TSITɝSIIIjsӳs}sӳsusjjjjjjsIj^T}_sjhjstjssjjjus~ujֵַuj`kj`uTIuԿԫɾӴӾӾɴɾɳ}ȳȨS))4I4>hs}sSh?utUuvvvvvvuu??**JkʾɴU?55JVuvvvvv__usssIIӳsh}sI_hss_ssh}S_ȳhS_^_I^ɳS))I4UI_ӾȾӳisjjs~jjjI_I__jӝhsj_~s_hsuj~sֵֵֵֵTuJ4*uu`j`II*jԿʴɴӴȾ޳ӾsI)*>4ThTI__sII__uvvvvvuj545T@kʾ@5*?KkvvvvjjusȈ^shhIIӒsss_^HsI_ss_sr}hsIɾ\)IIjssȾȳsusjsjss_^_T^STsjsjssj~ssuʵֵַַֿujJTJ**juj`jJj)?ԨussԿuɿ޴޾޾ӾɳII)>_SS)_}S4)>I_hIT^_jjjjuuvvuK*T5T?kKU?@Kuvvvvuj_j~sӒs}hhH4IӒSIh}\hӳhhhISjjhsӒs_h>Itshssj_jȳ~jsjsI`Tjj_jjT4Ԓssjjsjj~TJIJ)*ku`jUuu4)_ԿިuJjԾ޾޾s>>U_U_j4IUI))IIII}shS_tuvvvvvvvvvuK5?55ju@JU@juvvvvvu~~s^ӝ}H>IjӝhjrsshjsSIIT}ȳhhISS_js}sSɳӾjjusjjsjjT_jTT_TjsIssjsssjssj~ߵԵֵu`T?T?j`kIT4ɴԊuuk`Դ޿޿ɩ޳Ӿ_H) +5I>>))I_s^Ijuuuuvvvvvuk`?JJjuU`J`uvvvvvjij\jӾ}hh>IӒshsssIhShj^hssӒsS_sT_ɴrS_^ӾsjssusjjjjuT_Tj_s_Ijsjssjusjss~~j߿ʿֵjk_I*4Ju_ɿuʕkjT`uʴ޳ɿԿӴ~IIj^))_hH4? +)))j_hhIhɓjvvvvvvkvk`@J@kuv`K@kuvvvvvvvvvvvuijs}STӳss_>?}Sӳ}Ijhhh4_\s}hjS_ɾs_I_sȳӝӾ~jsjsjjTj_jTj_jjjjssjjssjssjssɝ~jj~s~ԵʿַkT4_ԿuTjT`Ԟj`uu`ԿɓɾsjIsS5~3>sI)I)4_ӾiTuuvvvvv``@JUkv`jKuvvvvvvvusssT>IӳsstsSIIIIhjӒhhSIIthhI>_}>SIsӨSjɝShj_hs~өssTjjjsssjssjusjjsss~~s~uʿʵֿʿֵַַʫTjԫu_?I?4?Iujjuuޞ޾Ӿ^_j}hިs]^_TI>I4)UӳiIIji_uuvvvʾvvVuUJjuKVvvvvvvvvuj_~u}S^_޳hhII_^hӝ}_sh>jHII_SSS?UihӳӳhhhsjӒsj^jjjjsss~j}jsjsjjss߿ʿԵu~uku_*`II?uԞuɾԿɾiT_hӾ޾sjIhtsI)IӝhI>ITjsjUuvvvvԾvvv`KKkuvvVVVvvvvj_usjhItӝsjS>_jr>sӳS_SHIj_jIITI_~sS4I^)jӳ޳hsӳө޾~jjj_j_Tjjjjjsjss}s~s~ʵֵֵukT`uII`TjT?j_ԿԿԿ޴~޾ӴӨӳjI~>4_޾s^)ITIj^jtuuvvvvvkkujuuvvvvvvvvuj~_ss^hjs~޳sS)>j}hӒss)I4)IIIStsS?_SI_SI)4I޾ӳӾɳӳȾ~ӝs~jhuhsujjjjjjssj~u~ʿʿֵֵֿujuJuT?J_?UuuԨԴɿ޾޴ިɓ~޾sssS>sS))IIIITT_juvvʩvkV`kavvvvvvvvjj_i~sss}S޳^)T_S_s}ȳȨh__jITIT_s^Ijs^IIII44)4ө}sӳȳӳɾȩӾsusssjjsssssuuuI??4JuvɊjԿɈjɨ~󾉉ӈI_sӒs_S)>)>_hSTtvvvVuVavvvvvvvvvvj~sjssh}^^_ޝSI_THI_hӝ^Ӿ>>T^thSj4I)I)II޾rjSj}өӴssssӾ~usjssӉjjjjsֵֵֵjTJT?jjvuԉjuvԿ~uɩu~~ԾsӾss_j_ɾSI_3)4?TjT_jjuuvvvvkvvVkuvvvvvvvvvvuu_sssTj}h^I>>III_Ȓ\T~ӾhSs^shjs444I?jSj޾ȳɳs~ujjjjTjӳssss~ɝssjߵʵֵUjk_JujjIUujuɴɴɿԴԿɾɾޝsT^TItssS)I_>)jii__jvvvvaVkuavvvvvvvvvvsg>Issj_^ITshIII>sӒ>))IjӳsI^_hTIIIT>??sjӾөjsjjsjTjjӳ~jss~_~j~jֿߵֵֵֵvjJukuT_ujuʓujuԿɴT`޿ɿԞӨs޾޾jjST_sȾsI)5_ɾh}^___juuuvvvvvvuVvvvvvvvvvvvvuuuu~ssssIIjhT}s>IIj꾈h}I}I)43TԾsI4IIss}T^I_s_ӳӞȾӳujjjsjs^js^_Ӓsj~sjɝ~s~ߵjuuujUTUjuukɉuuɫuɓ޾Ɋި^Tj޾sӈS)>_s}^jj~i_jvvav``kvvvvv~~ssjshTIs}3I_ӓHɳSTI_III޳s_hjs>_Sj4IɳɳȾu~jjjjTjjTsj^jjsӝ~ss~ֵߵߵֵַԠvkTTukujuԨuuvkuTkk~u޾uިTԾӝs>hjӨhss))II_~__tj`vʴvvuajkvvvvvvvvvvvvutjsj_~shTS>jjӝs)44Ө\)_Ө}h)I_sSjӒ^II_4S_өSjIɾӝɾjssjjjs_sjsjs~~߿ֵuu`uuuuIjޞUjԩvjuԴɓވӨɝӝsӝsI))IIj^jutu`vvvvakV`avvvvvvvvvvvusssh}jsIs^jȒh3)>Ӿ}SjSjh^s_I^)44_ɝg)jjsI^I޾}S`ɾȾӳӳө~sjjjsjsjjjTjIjjsjߵֵvuvukj`TTkɕujuuuuuԳԿԠʿԿ޾ɨӳӾ޾ӾӾSI>I4) +4IJiUj_jt`vvkvvuVkvvvvvvvvvvvvuujjus~sss>T__s>4Ihɾ}jhjhjSI?II4ITSIhIIj޾S^Ծӳɾӝus~s~ssjssjj~Ȩ߿ַʵkTkuUjuT?TԿu`uuuԿ޿ʿʵԵިӾӴ~jɾ޾^Iө~tSjT)>>>?TtijjjjuuvvavKjuvvvvvvvvvuujj~~sjsIsssS^tII_^IITӒ\4Ihts>__^IIjӾSSIӝ}IԳԴ޾ӾsjjsssӾԿ߿ֿ_ukuITTITk޿jjvu`ɴԩuʵɾӾޓӝSޓsjSӾS))_sI4)Iusi~t_jujukvvvvakuvvvvvvvvj~ssjsIsTjs}sj}ɒ^II_jSt~ޝS4UɾhjIIjs4j>_sӳӾsssI޾ӳ~Ӿӝ޳ȾssjsjsjsӳԿߵʠ_uujJTTuԿju߿ԞkuɩިӾ޾ȾsӾjӴ}S45I)4)ISjjj_jjuvvuvvvvvvvvvʾ~s^~_Is^s}hsSTI}^)III_^I_޾}SӒhrTI_s^j޾Ӿsj޾ɨsɾӳӳɩӾɾj~susjjssss~ӳԿֵֿֿʵֵ`j`TT`ɿuԴjԞʿӾ޾޾޳ɳӳޞӴS44)IIs3_~~jtɾvvvvvvvvvvvvvvvu_~sj}ss~SIITI_}I)*I)II44󾝉ޝ}ssS4ISjis_ޝs^h޳Ӿj޳Ӿ޾Ӿӳsssusjsjusj}jsɳԿʵߵֵֵjTTIjԵʫʳ`U`ujuɕuukʵ޾ӨԳӓ^SޝӾg)II44>I޾~ITj~i_޳vvvvvvvvvvvvv~~ssSjsssh4>II4jӝS)*TjhsS޳Ӿ}jhSIj~}sIjsS_өsj޳jԾӾӾӾӴssjsj~jjjsӾԿʵ߿ֿ߿ߵ֠uTjTITʫuukju`U_ԞkʵӾӴӝ^jsޝs4)I)jޝTS_sɔuuvvvvvʟvvvvvvvvvvvvuiu~sIT_^I_sSII_Iӝ>I5jhӾӾ^I44jɾɾsS_IjsޝɾɝӾөӳȾӳsssuuusjsssjӳ߿ʵߵʵߵֵujj_TuʵuԴuuu`k_jɫuިɩ޴޾ވ>j޳~T)4IIjӾgI_^ިjjvvvvvvvvvvvujjԾiusj}^jh^Ծ^)4_TSIsS޳s3)))4ɨSI?4Tӓ~꾒SIITjs޳ɾsɾɳ޾ӾӾӾȴȳsuj~sjj~jjujsɳԿʵʵԵߵߵֵuuu_juʿuɊujjuJɴʵ޾ӿޝ޾ӳSI4>ӈS}ިi__uuvvvvvvvvvvvvvvvvvɉtjuԝgT_js}sj^TsޝSI_4IjhIӒ>4*I44Iӝ޾i_ɾ޳SISj޾ӾӾӾɴӾɾ~ussjsjsjӓԿԵֵֵߵֵֵʵߵuuuuTʵjԴu_Ԟʵ޾_u~Ծ޾~Ӿވ^I?t޾}_h}ޝ^TT_tjjuvvvvvvvvvvvvʳ_T޾}s^4I_ss_r^IIjޝ>>IjSI4_ӳS4)))ISӾɴޝ^s󳾳ӾɾӝӾӳɾɳj~ӾsjjsjujsӓuӳԿֿʿߵ߿ֵߵֿߵֵvujjuuʵԞk~uִ޾޾^޴޿ɝssɳޝsIޝs4Ij޾gTIs~~utuvvvvvvvvavvvvvvvvvvti?TӾsSjs~SSITI)Ij_^3I)}>_I4_Ӿ)t_ju޳Sɾ}ssɝԾ޾ɾԾӾԴӾ~~~s~j~sɝɾʿֵֵֿֿʿֵԵuu_juuʞu֩ɴɴ޴~޾SjӨsSӈS4__ވTjjgT_vuvvvvvvavvvvvvvvvvvvvv~SIjӾSj_ssSjsS^IӝS4)4Uɾ}3?s^4~i__~ޝ}jss޾ީɳӾӴӳӾӾɾ~jj~j~ussjsjɝɾʵԿֵֿߵֵֵֿ֠uukuuuֵɿ޿ɾ޾~IIsԾ}_IIި^ITIs~ttjuuvvvvvvvvvvvvvvvvvvvvvvvvvvvvuuԨiTI޾}SI_sg^I_jsISIIjԴS>)4Iө3IIi_^_Ts~^jӝs޳޳޳ӴӾӴӳɴӴujujujujjsɳԵԵʿʵֵuuuu~jʵɴ鿴Ԩɉuu_j޾Ӿ}ɒވ_^IөsTITT~uukvvvvvvvvvvvvvvvvvvvvvvvvvvvuut_}^4IӨ^I_sI4}>IjӝӾ^)Ijsɨg4޾ԨijssjIjg_ӒԾԾӾɴӾӴӴsuuusuujɳɳߵֵֵʿߵukvuuuʵ޴޴t~__j޴޾ޝsӳ^ITj^__uvvvvvvvvvvvvvvvvvkvvvvvvvvvvvvvvuiuɾgIS`Ӿ}j_ssj^j^jSSjӾɾ^Ht~SԾ}SӾɝԾɈjSj^IjjӒɝӝө޾Ӵӿ~uuj~jususs~~ɝʿԵ߿ֿԵʵԵԵԵuuԴߠމɞɴ޾jӨ~Ӿޝ޾ӨgTI^jtvvvvvvvvvvvvvavvvvvvvvvvvvvvvvvvjju~Tɝ^4IIӝgI_TI_SI44IHӾӝs4>j^IԾsɝԾިɾ^4*ITI޳ӝɾӳӳӴ޴Ӿޓuujususj~su~ԵԵߵֿʵʵԵԵʵߵuuuԕԴʵʵԵީ_ɨɴ~޾Ծ޳ӞsTSTiUuvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvu~~TT^)4j޾}SIhsSS_sjӝӳj>jިɨ޾Ɉ^)I4)*)ӾɾӳɳӴӾӴӾɴuj~jujj~jj~~ԿʿֿֿֿֿֿʿߵߵֵԿԵuTuʵuujuuɴԿɉuuޔԾɨ^TsӾӳӾ^hȳ}ɳ~iT__uuuvԴvvvvvvvvvvvvvavvvvvvvvvvvvvvtjTsI^h^II}SSI)_Ӿӳ޾s~~Ӿވޝ~SI*>4)ɾ޾өӾӓӴ޾ɴɴu~uuju~jsjujԿֿԵʵʿԿuvuuuuʞuɕޞԳ_i~}ɨޝu~Ԩɒԝ޾޳ӨsӾ~^jiuuvʟvvvvvvvvvvvvvvvvvvvvavvvvvvvvvԾ}ssSI^^4Ij޳IjIjshs^Ӿ~~_ɨ޾Ӿ޾}jhS)I4Jjjӝɳ޾ӾԾ޴ɴԴԴususjs~jjuj~jsԿʿʿֿʿֿԿԵԿkuuuuuuԞ鞫ɞ޾ޞuɓu_ӈ^޳ӳӾӾӾg^Tިi_vvvvvvvvvvvvvvvkvvvvvvvvvvvvvvvvvvvvvvvvvvʴuӈj^^sS4)޾}ssS4_j}^ȝ}>IjӾވި޾ӳ~SjsIIjI>Ij޾ԾӾӾӴɴԴӴɴuusjsjsssjsԵԿ߿ֿߵԵԵԿֵvuuuuɞԠɕԳu~uޓuɓ_jr>ʾӾӈSsӨ^Tuuavvvvkvvvvvvvvvvvvvvvvvvvvvvvvvvvuju_jɝ^IIɾSS޳}j_TI_T^jss4S_ӾɈusԨ޳ɉ~sIsj_I_TTTӳ޳Ӿ޾ӾɴӞɴ~ujjujujjjԵԵʵɿԵԿԿ_u~uuʞuީuԩujuޓT_ިɳި>_޾sIjj~^Iujɓtjɩkvvvvvvvvvvvvvvvvvvvvvvvvʴvvvvvvvvvvvvvvvvvvvvvvvʩu_usijӨ^Irɾ}^I޾s>4I)4)S_Sި~޾ި޾޾ԝsII_IIIT_}ӝޓӾԾɿӴɫujsjujuuԵԿֿʴԿԵԿԿֵkuɫ_TߩuɉuuuԳijɴɞ~R)4ɴӾ޳޾s^T޾^TTTjiuޞJjԊvvvvkvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvʨtuj~T^TӨg_ɨhIg>I꾝s^>II)>SIj~Sɝޓs޾ӾӾjӝ>I*IIjjȳȴԾԾ޾ɴԴu~suujusju~ssʿԿ߿ԵԿֿֿʿԵʫuuԉuU_鿕ɳɞԳ~޾Ө>4>ӝӾӾ^Ӿ^T_jɓ~ɿɊvakvvkvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvɈ~_TjT޾^gIISjޝɳshIIIj}hsɾԨ^Tu޾ޝsޓSIII~Ӵsӳ޾ɴԴɾɴsu~ussusjsjusɩԿֿʿʿʵԵԿ̵vʠuuj~uu_jԞkuuuɴ޳޾޾Ө޳ɈɾgT4Ӿ~Ɉɩkvvvvvvvvvvvvvvvvvvvvvvvvvavvvvvvvvvvvvvvvvvvvvvvjވ^T_^T޾ӝr4Iɨ\Tވh_ItsIjɓ~ԾIIӳޝS_ɓɳhsӾӳӾޓӴӴӴujsjus~su~~ɩԿ߿ԿԵߵԵԵʵuɓTɵuUT`~uɞɀԨjɝ޾ި޾ԝ޾޾ɾ޾g_ӳ}jɝɳʾkakvvvvvvvvvvvvvvvvvuvvvvvvvvvvvvvvvvvvvvvvvv~ި^jjSTӾS>)ɨ^_ӳS_hI>Ijɾ޳޾I~}޾ӾӾӳӳӾӾӾ޾ɴɴԾӴ~~sjTjjjԿֿԿɿʿʵԵߠɓjuu__JvɿԿu~^?s޳޳ӾӾӳgTɳ}_Ɉ`kvvvԩvvvvvvvvvvvvvvvvuuvvvvvvvvvvvvvvvvvvvu~_uި~^TT>jި}4>ɨgӾS)jԾɾޓ~ިST~sӈSӳӒs_ӾӾөӴԾӿʿԾ~~~jsjsjsԿʿԿԿԿԿԵʵʵuʨɞTk_jUuԵɩֿɵɩ޾޾j}TԨSɾӳ޾ӾӾɝ^ިiuޞuuvk韊vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvu_juiTuӾ~sjT4_ވɒSIɨg޾޾ӝs~ިԾ޳iɈ~^Tj^jɳӾӾsӳ޳ӾӾӾ޴ӿɴʴuԾuujj~jsjjʿԿԿԿԿ߿߿ԵԿֵʵֵޞԞuujk֠ɿʩ鿴޾ɓuuޓsӨ޳Ӿ~ituju龟vʓvvvvvvvvvuvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvuu~~u~j޾}jjITj}rSӾ\Ӿ޳ԾsިԳɓjɾs^s_޾\޾ޝȳӳӳԾɾɴɓԾԾԵj~sssjjjjjjs~ԿʿԿɿԿ߿ԿԿԵֵʿɓԩuʕɞިɩɓj__ӝӾӾިjӾ^ItjԊuuvavԓvvvvvvvvvvvvauuuvavvvvvvvvvvvvvvvvvʩʩvvvjjuj~sӾs^TTIޒs޾sӾ޾ɴޓɩޞ^_}ST^sӾޒ޾ɾӾ޾޾ɴ޴ԩɴɴɴ~~js~js~jjjʵԵԿԿԿԿԿԵԿʿʵʠԓuޓUJʳuɩu~ޝԨTuɩԾޝ޾ޝɩވ>ԓi_tj޳uԟukvvvvvvvvkvvvvavvvuvvvvvvvvvvvvvvvvvvvvvvvv_uusuT_^uӝITT_ޝh}ިޝިɉԨԨiԨjɝS4IIj޾ȳɾӳӴӴԾԾӴԾj~usʿԿԿԿԿԴԿԿԿԵֵʵֵʠʴu_ɴɳukUTɵɞɾ~Ӿވޝ^IIT޾Ӿޝ޾rԨiT}ޞikvvvvvvvvvvvuvvvvvvvvvvvvvvvvvvvvvvvvvԞjuu~uTusj^uӝjޝS޾ɝ޴ɓu}Tɝ~ɝ}T^TӝӾ}ӾȾӳӾޝɳɴɾԾ~kɴjs~jsj~~ԿʴԿԿԿԿԴԿԿԿʿԵ֠ujޞޞuk_uɿީɴɴӾɝȴg4jTވӾӨɉ^ޓ~Գt޴uVvu`akkvvaavvvvvvvvvvvvvvvvvvvvvvvvvvvkujjԓ~}~u~}sӾɾӾޝ>js^ӾӨɞtި^Ԩ}ITjԝ޳ɳӳӾɴɾޞɾɴsuujjsuԵԿԿԿԿԿԿɿԿԵʵֵֿʵuuuv__vuʳɴɵ޾ɞuɨԳs󨴨I*Ӿ޾ӾޝӈԨ~ɓԩ`kiku`ukavvvvvvuuvvvvvvvvvvvvvvvvvvvujjjuɨu~sTjgjޝɴ޾\jިިiuɈIɒ}ssS>SɾɾӳӾӾӴӴ޴޴ɿɴԴj~sjԫԿԿɿԿԿԴɿʿʿߵֵԩuԨvvu_ɾԴɉuɨuӾޝɓ]TIޒgӾ޾ޝ}ވsɓɩtujɈ``vvkvvkvvkauuvvvvvvvvvjju_ju~us^jgsӾӾި~~ɾ޳_i4ԨR޾}ISsS>IjޝԳɾӳөӴɴɾ޴ӿԵɿԵԴs~sjsujuɵԿԿԿԿɴԵʵʵʵֵʵʿuԞuuukk_kkԞɩɿuިuޞɴs^T޳^I޾ɳӨjޝ޴ɉjuԾiuavvvvvvukvvvavvvvvvԞjiuވs~jsTu^^Ө޾sިޝs_j^j~ӝSj}4jjs^I޾ɒӾӳ޾ӳԾ޴Դɴjssu~ɿԿԴԿԿԿԿԴԿߵʵʵɞkukJuuuޞɴ_ɉԞuވɈjԾ~^T^Iӳ޳Ԩ^޾޾ɓ~ɞuvkkvvvavvkvuuvvvvvvvvvvvvvvvv޳tiɝssj~TjɾgjӾruɨɨިi?`~Ծ޾S~S44}I?_ӳ޳޾ӾӳӾӾ޴޴uj~uuj~juԿԿɿԿԿԴԴԿԵʿԿֵֿu~ԿukuuJukuTɫɕ~uԩɳޓɞ~ɾޓsӾ޾^TT?sӾ޾ިԾ޾iԳɈɊukvavkvvvvvʩvʳvvvvvvvvvvvʩu}u~u޾~~Tuj~TTԨ^Tɝި~ɨޝ޾ɓST~jԾ޾Ө^^4I?ԝSIS޳ӝӾӾӾӾӿɴɵӴ~usjsu~ɿ޴ԿԿԴԴԴԿԿʵʵʠԾuvjuUjvu_`uɿީԩɞiɴ޾Ծ^T?TT޾޾ɝ޾޾޾iɉukkkvkvvvuvvvvvvvvvvvʩujԨiuiޝsjsTT_jԝ^ިɾޓɾɳޓ~i^^j޾޾s}S4IԾssޝӾӨ޾ɾԴԴԴԴ~~juuj~sԴԴԿԿԴԿԴԿʿʿɿֿʫuuuU?_vukɫ~Կ޾ިޓɩɾ^TI?TӾӾިި޾sޓiiuVuvkvkvvuuvvvvvvvvvvvvujurTjsޝԾ~sTjިsɞ޳ɿ޾^?juu^4Tjɾԝӳɾ^jjɝԾɾɾԾԴԾ޴ɩjussԾԿԿԿԴԵʿʵԵԿʵuuɕk_I__ޞkɿu޳޾ɾވ^I޾ӳ޾Ɉɾԓjɞtuɉu`kvuvvʓuvvvv֖vʓ~iɨijuɈɓި^TjuޓިޞtɩiޓhTjI44jԝ^sӾ޳ӝޝɾuuuԿuuss~~j~sԿɿԴɿɿɿԿʵԿʵʿʵuuuuuJukuukɫɞɿޞ_ިɈj޾ӨɨӈɾɈjޝiuޞtuԞukvʓvuu`uvvvvvvvvvvɓuugusu޾~ިި~ިɾɞɓɾިɳsIjjI>44IrSӝ_s^jӾ~޾ɾɴ~uuuuԾ~~~jjɿԿԴʴԵֿԵɠʵʵԩukIUujuɞޓɀޞީɉ_~޾ӾӾӾި>_ԾӾ޾޾ɴӴ޾~jɩu`Ԉu`uԩiԩuvkvvvvvkvʩtԾrjsjuj}ɝިި޳ɿiԨޝ^II?sT)*44ިS_޳~Ӿsjsj޳uuuԞ~uuu~juԴԿԴԾԾɿʿԿʿߵԩuuuuujkԨjɞԳ޾ޞԨ޾ɨ޾޾sӞ^sjӨި޾Ө޾ޓ޾޾}Utuu`iԈuu`Ԟuvvvvuuޓ~ި^^TިɨޓިɈɩɈTɨޝS4U>I)34)_ވIӈ޾ɩ~uuޓ~uuuju~sujus~ʿԿӿӿԿԿԿԵߵʴuu`ʨɕ޳޴޾~uɈuӾވTTj~Ӿsޓ^Ծ޾ިިɾɴɈʳi`Ԟ~ɿutjɔuvɿuu`vuv`kvvkvvɞ~_uʾrjޝsTɝɞިɞɾɿ鳔Ɉ>jޓsޝSIs~h޾Գɝ~~޳uԾususs~jԿԿԾԴԴԴԵԵԵɵߵvuuuԞuuԨʳԾ޿ɿԞɓ޳~r޾ɾިɨӾ^޾_޾ɉԾɨԨ^ޓɈ}ɞjɳiuUʳɞtjuukʓvuʞuʩjiu~^ԓ^ވsuި޾ިɴ޿ި^Tޝޝs_jI4)T_޳Ӵ~sޝӴԓujuujuuuujsjɿ޴ɾԴԴԿԵԫԵԿԿʿʩuuuu_UԓԞ޾Կɾɴɉj޾޾ӝɳԝɉiɝ޾Ծ޾ɈԈSuu}޳iɞɓuɳjuʓkuvkʾk`tjTԿɨԾrjɓs޾~ɞɞɾ޾ɳtjɉiTjވ޾sI4)4_s^ɳ޳Ⱦӳss~us޾ɳɴɴjӓjuuu~~j~޴Դ޴ɿԿԿֵuuu~TkԿީɞTӨӾɾɝ^?T޾rj޾޾޾ɴ޾޾ވrTuɈ޳rԳrɓ޳ɳɨuuuuԴuuuikʩuuʔuJ_k~ɨiԨi޾ɨ޾ɞ޳ɿuԨ޾}ި^_ӝsII4I?IIӾsӾӳިɾӾɩ޴ɴԴj~~ss~ɴɾ޴ɿɴԿɴʿԴֵuuuʞuuuԞʫu޴ɴɞ޴ɉjɝɾɳ^?TԝӨSި޾Ӿ޾޾ɝԾ~~ޓޓiިިӾԾ~ɾɴɨuuu޳uuʞuuuɩtjɈԨޓs޾ɞɾ޳ɩɉޞԳɾɾɾg>_޳}I4)*)IsjӾӾȳ޾ɴɴɿɴɨ~~~~usɴɴɴɾԴɿԿɴɴɿԴʿʵ~uԵujިɠɞɓӿtӴ^js޳ވ~޾޾ӾިɈި~jɓɈ޾~ɾԾޓɓtԞɉɳtj޾uuutjtJusɨ~޾Ӿ޾ɔɞɳɾ޾ވɾ^Ijɾhh_^_II޾ɝӾӾɴԴӞԾuu~~~jӴԿɿɿԴԴʿֵuuʴuɓԿ~޿ɓu~ɞ~u޴TusTӳ޾ӾӾ޾ɾ}u޳ވ~ԨӨɨɾӾɈި~ޓ~ɓԳ}_ɩutʳԳuj}j޳ɞtޝވ޳޾ɿԳ޳ɴԈuԈ^uԨ޾Өs}sjӒӳsjӳ}}޾ӳɾɾ޴ɴԴԴ~jɾjjsjuӴɾ޴ԴɴɿɿԿԫʵuuu޴uuuԴިuu޴ԓuɝԨsus޾޾޾Ӿ޾޾ɾ޳t_ɓ޾ިޓިɈԾިӾިɈ}jɴ~jɿɈjɳԞɩ^ި޾޾ɿɩ鳩ɓԳިԓ~SԾިɈޝsss^4_sɝ꾳ӳӳ~޾ɾӾ޴juɴs~u~usɴɴԿԴɿԴɿɫʿԵ~ujʵTԴԴɓɉ޳~ɳ~ޞ~޳ɳޝވ~޾޾ɾɴɓɝɨޝӾɈވ~ɾ޾ޓ޾ӨɈɈޓiɴ~ɿɞjԞԓi޳Գިɓި޳ɩɿԨɴ~T^ɝɾ}޾~_T^ɾsӳɾɾȾ~޾ɴɴɴԳujuujsӴɴ޴޿ӿɾɿɴԴʿkujɕɨuޞɴިi~ިӾӾ޾sީ޾޾ɞިޞ޾Ɉɾ޾Ӿ޾޾ވި޾ɝg޾޾޾ɴɿɈ_ԳrɝɈɝ޾޾Ԩޞɿɩ޳jɴɴ޾^I~uӨޝ޾}j>g>jӞsIISIӝsɝ^ju޾ɴuɴʳujjjuuujuujɴӴԴɾɾԿɿɾԴԵԿֵԿuɞԨuujuޞ޴~Ծ޾ɝԾޝ޾sr^uu޾ɾɾɨި޾޾ɨɾɴɩԾr޾ɾɾɾsɾɾ޾Ԩɳɓuޓɓuިޓɾɾɨިɨɿɿɿɿɿ޳jɨި^jj^sԝɝɾ}II~I}_}__j_Isjɾɾuuu޳Ծɾuusu~u~uuj~ujj~޴ɾɴԴԫ~ԵԿʿʵԵuuԫuuޞ~uɉި޴ɴ޾ɓ~ޝިs}iu~Ծީ޾ɾޓ޾ި޾޾ɓޞԨɾɴި޾ɳɳɴ~ɩި޾ިޓiޓ~}u޾ި~ɞ޳ɳɨԳiɿɴɓ޴ވs>uɾ޾gj4_sԾɝSIj_s_s^Iȝ~u޾ɴԾ~ujsjuusujɴ޴ɴɾԿɵʵʿuu_uɳJ޳޾ި~uޝԾӞɓsވ޳ޝI`^ޓԾީɳԴɨɓިɓ~ޓɴɞɾި~ɝɾ޾Ӿs޾ɓӾӾ~ިiԓ~ވsԾɾވ޾ɿޞ޳޳ɓsԨɳԾވjjSɝɝވ)_}sS>Issӝsީɴsuu~uuuɞsuj~jsujjss~~ɿɴԿԿԵԴʿޞuiu_u޳u޳Ծ~ިޞ~rӾjިiuiTTɈɳɳtɿɿ޳ɨ޾uɨԳԾ޾ި޾޾ɾɴɾɴ}Tɨsިޞi޾޾ɞɩɿ鳿޳޳ɴ^Ծ޾Ө^TT^ӨԈhjIsӾshshɳ޾޾ɾ~uju~~j~js~usjj~ujusj~ɿԾԴɿԿɿԴԵʿu_iTԳ_ީɩ~Ɉޞޓj޾~sɾii?_޾ިɩu޳ɾɳɴɿɾɨԾ޾ިɨɾ޾ɴި޾ӿވɓjޓ~ިɈɾɾɞɳɾ޴ޞ޳ɾiT޾jII4I^_ވԨh}jsӳȾs޳޾u~j~uj~j~jj~sj~ɿӴԿԾԴԵʫuj_i~jɞ_ɞ޴ވ󾾝Ɉu~T^TIިɩɞ޳ɞɞިɾɨ޾ި޾޾ԨɉɳɨԾ޳ɓɾԳԳԞԨɨɓި~^j޾r44I*r>j޾hhI?޾}Tsӝɾɳuޞuusjusjju~ssuɴӴɴɴԴԵuuu~TިTɞɞ_޴ɓɓ޳ӈ~ɝ^T^޾޾Ԩɿɔɔɾɨɨɾɾɾ޿޳ԞɳԨ}޳ɿ޳ԊɿԞu޳޳ɳޓiޝguި^I4I`s>*ޝވ_^44Uԓӝsshjssɨɾ޴~u~uɞ~s_~suj~jss~jjj~sssӾɴɳԿԕuuuuj}_Ԩi_uɠԨuɉިӾޓuޝTTjTɝ޾i_uɾ޿ɟ޿ɩԞɿjɔ~ɿɨɾɴɳԾ޳ɿɞԳ鳿ɳީuuԓިrjiިiTgIT44g>޾ө޾hH4Uh~Գ޳өɴ޾ɴjjujԴ~uuusjuj~sssjssɴӴɾɳԿɿɴʵʵʴʴuuuuuk_TijɞɳɴԳɞޞrԾTuTTɉԾr?Tkԟu޳ɔԿԳɳɿ޳ɾԔ޳ԳԈ޳Կʩ޾Կޞ޾ɨ~TވsTrI*II`^)jޒޒh>>`hӾ޾ɾԾuuuus~uuj~s~sjsȴɾɴԴɴԵʵʫʴuuu??tuTިɉ_uԳuɨ޴Ԟ޾ɾӾ޾ޓԨ}Tɾ޾ɓ^?ɩԔuɿɳɾɳɓԞɿޓɩԳʾɞԳ鈋ԩ޳Ծɩ߳ԓɓiޝ޴^uTjɈ^jԾ^TIII>Iި޾rsh_i}^Ⱦɳ޾ӴӴԴu~u~u~sjjsus~ssjԴɾɿɿʵԴʴuuu_Ju~ޓ~iT_uɉԴɴԴ޾ɴ޾޾Ӿ~jޝs޾Өs~鳿Ɋuu޿޳ԩuɔɞԩɞ߳޾ɩԞԳɩԔԩuʩԳtޞrވTTJTԨިS?T?Ii>Iޝ}]jjhhssԨ޾޴޾ɾɴ޴jujj~usu~jssuus~jusssɾɾɿɴɴɴɴʵʩԴuuukTU>sԾި~uuɟި޴ޓޝ~ޝ޳޾޾jɾ߿޾uɳ޾Գjʿɔ޿ɳɞԊԞɴԓuԩɾʩ޳}ujɿ޳iuruԾɓ~T_T_ɝިSII)}3uԨӝSsɒhӨsɾ޾ԳԾɝjjuӞuuuujjjujusuujjjuujuss~uss~jsuɴɿɴɴʿʴԴɴuuuuj?iIuޓިuu_k_tԴި޴ԾިӾԾ޾ވ޾޾޾ɨԞ޳Գju޾ɿʞɩԞuԞ鳴u߳Գjɴԓtus}~~_TT_^jSIIIssI޳Ծӝ}Sj~ɳ޳޾ӨԾӾ޴ɾԴ~suujusujjuju~sujjjsuj~~jsssssԴɴɴԕkuuj@Uisԓu_u`ԳTޞӴӾ޾ި޾ɾ޾ޝ~Tިɿ޳jɳuuɩuɿuԓԳߩʩԔɞjjjިԳ~_~~ވ^j~^jiި^j޾^IIjSTjgӝssӝ~jԾɾԳɴɾӾԾɴuuu~~jss~~jTusjjsssӴɴʵ~uu_jTUɞިiTjT_Ԟ_TɾԞɴ޾޾Ӿɝ޾}u޾޾Ӿ~޾ިtuɿ޿uuʞʩɾԳԾʾʞ޳Ԟt_urrTur~޳^T~~ju}~j޾ST>^>޾ӾsssjsjӾ޴ӾɾɩɿӿӴӿԴɴu~uu~ujuusjjjsjsj~j~s~~~sjuӴɴӴԴjjUuTޓj?TjuiTuި޾ިӾ޳~޾ɾӾ~ި_j_TɔuʩԿʞʟʳԩԾʞuԳt_t޳ޓ^T_ur?TjԾr?}}Ij>4*ɳɨɳ}}~~ɝӾɾԾujuj~jjuu~juusjus~usju~ss~sssɾɴɴʿjuuuɴ~ju~Ծj^T~޾ӴԞɴ޾ɩɾ޳ɝɓ޾u~ɓ~ɿjuuvuʩԿԩԟߩ驋Դukjj鳞~~uި޾iT^TԨ^TTrjޝ^jԾӾss>4j}^_ɾɝ޳ɾɞɨuujjujujju~jusuj~~susss~ssӴɴӴԴԿuuuuԓɓT_Tɞujjɞɿɴ޾޳ӝɨ޾Ӿ޾ӈs޾Ծ޳jjjkʳuʾɟʾԩިɉ__u޾޾TT~TuވTTTugވS޳޾~gI?}4ӳsɳsɨɳөɨɴu~uusuj~jjssuj~jj~jjssssɾɾɴөԴʴuujuԨ_iTuuԿu~uԩɴԨɞ޾޾޾Ӿ޾Ӿ޾ɨ޾~ިi~޳tjjuuԴʩԊԾԾuuutɳɨ~^TԾ޾ޓɓ^jij~_ɈTjju}Ӿr޾ɝIIɾ>ӾuԾɴɾ~jsjTjjjj~~susuusj~ӴӴԴɴuuuuu_Ԟ~uuuޞuu~ԫޞ޾ɓ޾޾ɾ޴Ӿިɾޝ~ɳɴ޳jɿԳuʔʞʿkʩu`jjtɴԨ~i_u޾^`iTu^ިrTjTjވɳ}}}^IӾ}I~Ӿ~uޞɨɾuuju_u~jsujjujjuj~~jjjuss~jsjsӴ޴ɾɴ~uukuu`u~_uTɉ_juޞɾ޾޾޾Ө޾ިӴ޾~iި޳ɉ޳ttjʟԟuԩuީԔuuvޞ~j_޾޾ӾgT_TTuujӝ^TTTjs޾ɝhSɈhӝsɾ~~ԾɴԴuuu~~jjTjjuuu~jjsTjjujujjuju~jsj~ss~sԴӴӴɩuujuԝu~jTuԨuj_kjԳɞ޴ɴԾ޾޾޾Ծ޳޾޾Ӿ޾ɓ_ɨɞjujjʟuvuvkkvʿԾߩʊukujuɞɨ~ij޾ިr~~^Tjj^TT޳}_j^ӝ}Ⱦɝ^ԾɊuuujuujuujuuuuujuujujjTjjsususu~jjjj~~jssԾɾӴӴөʴjuu~`~juuޞu_juԉ޴Ծӿɴި޾Ӿ޾ިɾ~uɴtKukuuu߳ʊuuuԿu`jji_ɴɝ~TɈޓ~T~ITsɾ~~TTTޝ޳ɈI4jjssuӾӾԾ~ɾsɴ_j_jjuuujjuuuuuu~~jjujjjsusjjjj~sj~j~s~ӾɴԞɩɩuuuu~jj_uu~ԩujTuuuɴԿԴɾɴި޾޾ިɾӾ~uɾɴjjukʴkԩԊ߳ʩuʔujut`j`_ijި~sވ^Ɉ?TjiIrjs~Tjj鳴sI_Tsɾu޾ɾ~ވԴjuuuujjusjTjjususujsjsujuusujssssssu~~ss~sjs~ssɾɾɳɩɾɴu_uusuTju~juuuuvkިԿɳɾ޾޾ިɾԾިɾɴtU`ɩuvkuukukuuʩʾuɩtujjj___uu~uɨ~ɾSIԨ^T_juIj^Ԩ^s_^ɾ޾޾ɝ^^j޾ɾԾu~jjjj~uujjjjjujsusj~jjuj~j~~sjsssssssȾȾɩɴujju~jj_jkuT~uuuuuu޴ԿԞʠԞɾި޾޾Ӿuɳ~}_uuuuuuuvuuuuԾvʴԔԔjjvɿuuuuiɨ޾~~^rTӾ}TTs}j~^TjӳɒӒsjsjsɾԨjuɓuɴɴ~uuujjuju~~uju~~jj~sjj~jjussɾȴɩɾɾɴuT_ujuuTJ_uu_juuukjuިԿʴԾ޾Ӿ޾޾޾޾Ӿ޾ɾޓɓɨju`ujukʴuvuuuvԞtjjԾ~iuuu~ɨɓ~gTj޾^Tss~uiTuޝԝ~jӾijuijuޝuuu~ujuuuuusjsjuj~usjjujjj~s~~sj~ss~~sӴөӴɾuuujju~jTTju~Tusuuu__Jމ_jԿ޾ɴ޾޾޾޾ިɉɨީjjvtujkuuVkkuuvuuʳutu_~u___~~޾޾r^jijrTTӝijԾ޾sjӾɝujjɨj_juujjju~ujj~jujjj~sujsu~jjujjjsss~jssssssɴɴӴөɾ~uujj~uTj`uujujkjuujԨuԿuޝ޾ԾԾɴ޾޾޾޾ӿuɿjuujkkkuukukk龊߿ԓjjԞj_jiuiTu~ޝԾsTӴ}^TɈ^uԾgjӾӝ^ӾӴӓ޾suuuTuɓsuuԴujujjusjsju~~j~jsjjuujusjusj~~sujus~~~sjj~ss~ɾɳjuujuuuɝTJjukuujTjuuuuɞʳ_Կʞɴ޾޾޾޾޴uɉԨjujjjʊuuvuukuuuvɩuuuvԿ޳jj_iujɓi~T_~Ɉ~ɾԾrTɈ^ԝ~suӾ^޳ɾޝӾԾuujޓjjuujuuuujusujjuuujT~jssjusu~jj~jsusssshs~}ɴӴȴӳusuu_ju~~_J_uu~j_uu_TjԿjikuʠuʞɴԾԴɿ޾ɴ޾޴ި~޳޳_jʔj`kuvvuʟuvԞuuuuʩu޾ɩ_u__ɨru_j_~ɓijި~TԾsssjӾ}޾޾ԾӾޝuuTuuujjujujjjujussjjTjjjsTj~jsusu~ssss~sɾsuujs*T`uusjjuTԿ~*^k޴ɴԴ޿޴޾޾ӿuިɞtjʔkuukuuukʿuuuu޳ɉ_ju~juԓiu~u~~~TɝԾ~^_~~ӳɝӾӾ~ӾɾԾuuu?u~ujjjjjjjjujjjj~jsjTjjju~jjsju~^s~j~s~sssu~s~s~sɾɾȴuujTTJuuuuTIjujԿuT*޾Դ޿ɿӿ޴޾޴޾ӾӨɞɞɉɩt_vԔuuuuuuuʩt铫tT_~u_ɉTɓiTrij޾Ө~~Өs^jޝӨ޾Ӿɾ~޾ӴԾԳjujj~juju~~jj~jjj~jsj_jsj~~~TT~jusj~j~j~sussjssu~sujȾөujS_jujj_jTTT?5~޾ɴԿԴԾɿ޾ɴӴɞɴɞɳjuuukvuujuujuuߴjuɓɉiu~iɓԓiu~Ӿgsu_jɾӾ޳޾޴Ӵj~ɴujujujuujuujjTj~ujsju~Tjujjjs~~jssu~~jsjssis~jsjssjss^jssɾɴɴӴɴȴujju_T`uuujTTIԴ~TjJJ4?uޞިɿʴԾޞԿ޾Ծ޾޾ޞɩɩ_tjjԩutujuuu騿}uԳ~ʾ~iuɈ~Ծɾԝj~~^jӝ޾ӳӞӴ޾ɴɾ~j`uuu~ssujjjsjsjj_ujIjIjuujusjj~u^jjs~js~ssjjsjsjsɳɴӴӳ~~ujujsuu~u^_Ԟj?5IT4U`ԞjuӿޞԿʴ޾޴ީԿ޾ɴ޾ɞԾɾɾɩɩtjjvɩjvtߟuu`uujɞɴɨjԓ~uɾ~~TԨ^~޾ԝs~sTu޾ӨӾӾ޾ɴ޾޴Ⱦjjjsujuuj~js~jj~jjjsTITjTTs~j~j~sssss~sjjujss^_jsT_^jjsjȾȳɴɴӴ~jujsjujuujuT_u?TjT`TuޞɞԿɠ޿޾޾޾޾޾ɿɴɩɉtjɞjɊjuuɴiuɨuiԨ~޾Ӿ^uӾ޾Ӿ޾Ӿɴɞɨӿɾ~uuޓujujuujjsuusjjjjsjjjjuhTjuTTTjTIjujs~sss~~jjjjsjj~js~ssj~~TTjST_TsjssssȩӳɴөӴȾөjjuS`ujTusjT??TTJT`TkԴԞɿӾʴԿԴ޿ԴԾɿ޾ɿɴɩɩɔ_ԳjujjɔujԳɞިɉ~u޴^_uɞޝ~sɾӾ޾޾Ӟɴ~ɾjUujjjujujujjujjujj~jjjT~T_ITjjjuu~s~susjsjsjjstjjssss_TTIITjTjjӳ~ɾȴӴө~jjjujjTTjuujuTI*jJTuJtsԾԿɿ޴ɿޓ޴Ӵɴިɩɿɔɞ޳Գ߳uԾɉʞtɿɿɩɞɾޓ~ɓT~Ԩɝu}~޳޾ɴ޾ɴԴuɿӓuTjju~~uu_juujjjjTujsjsusuTjuj_TTITjssu~sjss_s~jsjsjusjsssjhT_SITI_ThIjsȴɴӾ~uuuujsjTTTuujjuuj4_JjuTԓuuɾɞԞԴ޴޿ɾɞɾ޾޾ɿɨԨɿɩɩɉʾɩԉԿtuɞԳɳjɩԿɞԨԾiuu޾޳ԾԾ޴޾uӿӓujJuj`jujjjuujjusjjjjjjujsjjjsT_T_jjjjsjjjsjj_jjIjsujsjj^jjs^jTj_TIIIITj^_ȳӳɾuuTjj_T_jTjuTJTTjuU_gjuuԞԨuԿ޾޴޾޾ɿɞɞɿɿɩɳɩɞԳԳʩɩɩɳިɴԾiɾɒɾɾ޾޿޾ӫɓuԴuuɾ~jjuTTjujjjjjsj~sjjsjsjsjjjsuT_Tjjj~jju~~s~jIj^j^Tjjj~jTITs^ss^TjTSjj_TjIɳsjjjujj_j~uTjjuTIJjvuj_I~jk~ԞԴ޿ɴ޿޾ɴɩ޴ɿɿɔɩԳɳʨ޳ԿԳɩɿԿɿɩɿ޳ɴɴ޾uިɉӿӴ޾ɴӿʴuɾ~jjjjjujjj~jjjjsTIju~sujTjTjTTjuTjssjsTjTjI^jsss}sjsjjjjsjjhTIITITI^_ȳȩɳȴjjjuTj__uu^jJjuTU_JsuԴԾɴԴɴ޾ɿԾԿɞ޴ԨɴɿԿɔ鳿޳ɿɿ޾ɿjɩɳɿԳɴɩʩɩɿ޿ɨɴɩɾ~ɴɾɳ޴ԾɴԿԾuɿujuuujjjjuujjsusjjjjjjTsjs_TT_jThjsuusjusTTs_TsjjsjsIT_sjsjjIITITIIjSI~~uT_jTjjsuuuTUju`jT`svu`Կuuʿ޿޾޿޿޾ɿɴԾɿɴɳɩԿɳԳɿʩɩɿɿɿ޿ɿɿɾ޾ԨɞԾ޾ɾɴɴɴɫɫuuuuujuujjjjjjjjjjjj_Tjsjjjjsj_hTjsTjusjjsjjsjSjTjhTjjT_sjssjs^j^_TTITjIӳ~jjj_T`uu~ujjk`uTTUuuuukԞTɴԿ޴Ծ޿޿޴޿ɿɴɾɿɿɿɿ޿޳ɿԾɟԿɳɩɿԿԿɩɿ޿ɿ޿ɴɴɾɿɓɴ޴޴Կ޿Ծ޴uuɴujj?jujjj~jjjujusjjjjjjj_jj_jjjjusjusjT_jj_jj~j~sjTjj~jjT_jss~ssjTIjT_Tj_TjIjTIj>jȴujj_ujjjjɓjjuTjujjTI??~jkuuuuT޿Դɴ޾ɿɿɾ޾ɿ޿ɿɩɿɳʩɿɩɩɿɩԳɴɩԩɿɿɾɞ޴ɴ޴޾ɿ޿Կ޿Ӵ޾ԴԫjjJj`jjjjujujIjujTjjsjjjjjTITjjjjjus~jjss^TTTsT~jjjsj^sjj^sTjjsssjsIsjsjj^T?TjTjI_jIɳɳjTIsuTjjjuju~_`ujJTT_?uTuuuuTk޴ʴӿ޿Դ޾ɴɿɴɳԞɩɿɿɿɿɿ޾ɩɿɿɿʿɿɿ޿ɿɿɿ޾ԾԿԨɴ޾Դ޴޾޴ɫԾԴԞ~uTku_jjjujuTjTjjjjujjjTjjj~jj~jujjjujjuTjTjjjjsjjsjj~jjjIjj_sjs~sIjjjjsjIs~sj}us_jj^jIIjS_ThITIjȩjj~TujjjjjjjjjujTjjuT?Iuu`~uu_TjԿԿ޿޿޿޿ɿ޾ɴɿɾɿɾ޳ɳɔɩɩ޿ɿɿɿɿɩɿɿɩɴɿɴɿԿ޿ԿԾԾԴuuujuJ`uIj`_TT`jjjjjJujjTjtujjj_ujjj_`j_ujsj^IjjjITjjjssusjssIjjjjjsjjTjjsssjsTjj^_jjjjujsjThTIӾs~~ujujjjjujjjTuTj`uuT4?uu~juujɫԿɴɴɴɾɴɿ޾ɴɴԳɩԿɿɿɿɴɩɿԿʿԿԿɿԿɩ޿ɿɴɿɴ޴޿Ծ޴޴޿ʿʿu~jujkuj`jjujjjjj_jjjjj_jTIjjjjj_TjujsTUjT_jjjjjjjTussTjssjjsussuuhTssshsjsjsju_Tjjsjs_~jj^_sjsjs^_TjTȾsuuujjjjjTT_jTj`uTI*~uuu^`u~TɵʿԿɿɿ޿ɵ޿ɿɿɿɿɳ޳ɿɿɿɩɳɿʿɿ޿ɳɿʿɿԿɿɿɞɾ޿޿Կ޿Դӿ޴ԫԿʴuuuT`T`jj`TUTjjjjjujTjjT`_jTjjujjjjjjjT_jTjTu_juj^jjjTjjjjuusjsjj^jIjjTjjusjsj^sIjsjjsTs_jjjsshTjIIȾ~~~~uu~jjjjjujjjuusITuuuuT*Tuk~~kT?4kuu޴ԿԿɿ޾޴޿ɴ޴޾޿ɴ޾ɿ޿޳ɿɳɩ޾޿ɿɿɩԿɿɿԿʿ޿޿鿿ɿɿ޿Դ޿޿޿޿ԿԾ޿ԿީԿ޾ԿʴuuTuuuju_jTju`_j`ujuUuJ_TJ_ujjjjjTjj~jjTI_j_jjTjsjjjsjuj^_ITsjsTjjssjjIjjs_sj_j^_jIIT^ssjhTjsj_sjsj_sT_ɳ~ssuuuujjj~uuIjj__uTTTkuu`^T`uuԿʿԿԿԾӿ޿޿ɞɩ޾Գɿɿɿʿɿ޿޿Ծ޿޿޿޿޿鿫ԿԴɴԞʿԕujukujjjjuuuT_`TjJTjTjT`jjI?I?j?j`jjTjujsT_jTUjsj_jj_Tjj^TjSjjjjjjjT_hjsjsjjsjITTT_j_usjssjshjss_ssjT_4jӳȾȳujjuujjjj~jTujjjTuujuuj~u^5JjԾʿԴ޿޿޾޿Դ޿ɿɿɿɿɿɿɞ޿ɿ޿ɿ޿ɿ޿ɿɿԿԿɿ޿ɿ޿޿ԴԿ޿ԿɴԿԿɿԿuukuuuujjj``jjj_T?_u__k_`jjUjjIJII`II`j_jjjjjT_jTIIjjIsj^jjsjsjIjsjsj^s~sjIj_jjs_Tj^ITT_^jTsjusjTjT_jjs^sTjjȳөuȾjjjujjjTujjuT_Tuuuuuuujj44?u_޾ʿߵԿ޿޿ӿԿ޿޿ɴɿɿԨɿԿɿ޿߿޿ɿɿ޿ɿʿ޾޿ɿ޿޿޿ԿʿԿɿɵuujuujkjjT`jj`_TUjjUIjJ_uj`TI?TJIT`IjjjjjjT_IJITj_jjjjjTjsj^jTjjjjTjjjssjs^js~t~j_jTjTIjjThsjhsTj^IjhT_sj_sT_j~ȩȾȾȳ~juuujjjuujjju~j__juuuuuu^~4`Tu_ޞuԵԿԿԾ޿޿޿Դ޿ɿ޿ԨɿɞʨԨ޿ɩɿɿɿɿ޿޿޿޿Կɿߴ޿޿ԿʿԿԴɿu`uuuuju_jjIj`jjujTjUITJjTujT`TI?I?ITu_TujujjTTIIjjjjjsjhjujIjjj~jST_jjsjj^_jssTsTSIIjIsjIjjjjjITIIT_IjjjjTjӾȳs~u~jusj_juTTjjuTjus~4TJ?ިuuʿԵ޿ԫ޾޿Կ޿ɞɿ޿Կ޿ɿԿ޿޳ʿԿԿ޿ɴԿԿԿʿߵ޴޴Եuuju`jjI`TT?jT?jIUjT?j?I`j`jI?J4?I??jjjTTujjTIT?IjIssjjssjIj_ujjTjIjjjj~_sjjjjs_TjIIT_IT_hTjTjT_TT_?j_sjshjhȳȩ~~jjsjjsujujTITkujIuuuS4*jޞjjʿԿ޿ԿԿɴԿ޿ɿɿԳɿԿɿ޿ɿ޿޿޿޴޿ԿԿԿԿɿ߿޿鿿ʿ߿ԩ޿ԴjuuuTujuujjjT__TIjj_jJI_T_IJjTjj_JIIJ4*j`jj__jjj_TIIIjIjjjjsjjjj^Ijs_jS_TjjjjjsTjsjussj_?ITITIjT_TT_^T_sITITjjT__jIsȾȳ~sTjjujuju^IITjujTjuuuuuu`^T4?~ޕuTԿԿԿԴ޿޿ԿԾ޳ɿɿ޿޿޿ɿɿ޿ɿԴԿ޿Կʿ߿ԿԵԩԿʵɫʴjʴjuujuuuujj_I?jjUT_?jU4`j_JUjjI?I?IIjjjjJuujJjTJI`T_jjusjj_jjjTTjTTjTj^jjsjujjj_jTjjjsjsIITITTUTIIT_TITjITIIjTsITT  + + +  + + ) + + + +)  + + + + +) + + + +  + +) + + + + + + + + + + + + + + + + + + + + + +) + + + +) +) + + + + + + +) + + + + +  + + + + +) +) + + + + + + \ No newline at end of file diff --git a/Java/M3-code/manmem.c b/Java/M3-code/manmem.c new file mode 100644 index 0000000..863716c --- /dev/null +++ b/Java/M3-code/manmem.c @@ -0,0 +1,36 @@ +#include +#include + +int main(int argc, char** argv) { + + // allocate an array of 100 integers + int* array = (int*)malloc(100 * sizeof(int)); + + for(int i=0; i<100; i++) { + array[i] = i * i; + } + for(int i=0; i<100; i++) { + printf("array[%d] = %d\n", i, array[i]); + } + + // explicitly free the array + free(array); + + // allocate a second array of 100 integers + int* array2 = (int*)malloc(100 * sizeof(int)); + + // no error for accessing the freed array + array[3] = 120; + + // print the (uninitialized) values of array2 + for(int i=0; i<100; i++) { + printf("array2[%d] = %d\n", i, array2[i]); + } + + // print the (should have been freed) values of array1 + for(int i=0; i<100; i++) { + printf("array[%d] = %d\n", i, array[i]); + } + + return 0; +} diff --git a/Java/M3-code/paint/LineShape.java b/Java/M3-code/paint/LineShape.java new file mode 100644 index 0000000..a4c90f7 --- /dev/null +++ b/Java/M3-code/paint/LineShape.java @@ -0,0 +1,44 @@ +package paint; + +import java.awt.Color; +import java.awt.Graphics; +import java.awt.Graphics2D; +import java.awt.Stroke; +import java.awt.Point; + + +/** A line that may be drawn on the canvas. */ +public class LineShape implements Shape { + + private Color color; + private Stroke stroke; + private Point start; + private Point end; + + /** Construct a line, given its color, line thickness, and the two + end points. + + The constructor assumes that all parameters are nonnull. + */ + public LineShape(Color c, Stroke s, Point s0, Point e0) { + color = c; + stroke = s; + start = s0; + end = e0; + } + + /* The dynamic class of gc is actually as subclass of + * Graphics called Graphics2D that supports more functionality. However, + * due to backwards compatibility, the argument to paintComponent has + * the static type of "Graphics". Therefore, we must do a dynamic + * cast before we can use some drawing routines. + */ + public void draw(Graphics gc0) { + Graphics2D gc = (Graphics2D)gc0; + gc.setColor(color); + gc.setStroke(stroke); + gc.drawLine(start.x, start.y, end.x, end.y); + } + + +} diff --git a/Java/M3-code/paint/PaintA.java b/Java/M3-code/paint/PaintA.java new file mode 100644 index 0000000..19e8584 --- /dev/null +++ b/Java/M3-code/paint/PaintA.java @@ -0,0 +1,143 @@ +package paint; + +import java.awt.*; +import java.awt.event.*; +import java.util.LinkedList; +import java.util.List; +import javax.swing.*; + +// Basic User interface and state of the application +// Only the quit button works so far. + +/** + * The main class of the Java Paint application. + * + * This class stores the state of the application, and creates the user + * interface. + */ +public class PaintA { + + /** The list of shapes that will be drawn on the canvas. */ + private List shapes = new LinkedList(); + + /** Preview shape for drag and drop */ + private Shape preview = null; + + /** Area of the screen used for drawing */ + private Canvas canvas = new Canvas(); + + /** + * A Canvas is a section of the screen that can be drawn on. + * + * Just like in the OCaml Paint assignment, we draw with a repainting + * function that uses some local state to determine what to draw. In Swing, + * the drawing method of a widget is called "paintComponent" + * + * The canvas is an *inner* class so that it can access the private 'shapes' + * and 'preview' fields. + */ + @SuppressWarnings("serial") + private class Canvas extends JPanel { + + /** + * Display the canvas on the screen using the Graphics Context. + * + * This method overrides the analogous method in its superclass. + * Therefore the first action it does is to call the superclass version + * of the method. Then it goes through each shape and invokes its draw + * method. + */ + @Override + public void paintComponent(Graphics gc) { + super.paintComponent(gc); + if (shapes != null) { + for (Shape s : shapes) { + s.draw(gc); + } + } + if (preview != null) { + preview.draw(gc); + } + } + + @Override + public Dimension getPreferredSize() { + return new Dimension(600, 400); + } + + public Canvas() { + super(); + setBackground(Color.WHITE); + } + + } + + /* + * A helper method for creating radio buttons (i.e. line and point.) Each + * one needs to be created, added to the button group, added to the panel + * and have an action listener installed. To avoid code duplication, we do + * that all here. + */ + private JRadioButton makeShapeButton(ButtonGroup group, JPanel toolbar, final String name) { + JRadioButton b = new JRadioButton(name); + group.add(b); + toolbar.add(b); + b.addActionListener(new ActionListener() { + public void actionPerformed(ActionEvent e) { + // does nothing for now + } + }); + return b; + } + + private JPanel createToolbar() { + + JPanel toolbar = new JPanel(); + + // Create the group of buttons that select the mode + ButtonGroup group = new ButtonGroup(); + + // create buttons for points and lines, and add them to the list + JRadioButton point = makeShapeButton(group, toolbar, "Point"); + makeShapeButton(group, toolbar, "Line"); + // add more shapes here + + // start by selecting the buttons for points + point.doClick(); + + // the checkbox for thin/thick lines + JCheckBox thick = new JCheckBox("Thick Lines"); + toolbar.add(thick); + + // exiting the program + JButton quit = new JButton("Quit"); + toolbar.add(quit); + quit.addActionListener(new ActionListener() { + public void actionPerformed(ActionEvent e) { + System.exit(0); + } + }); + return toolbar; + } + + public PaintA() { + final JFrame frame = new JFrame(); + frame.setLayout(new BorderLayout()); + + frame.add(canvas, BorderLayout.CENTER); + frame.add(createToolbar(), BorderLayout.PAGE_END); + + frame.pack(); + frame.setVisible(true); + frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); + } + + public static void main(String[] args) { + SwingUtilities.invokeLater(new Runnable() { + public void run() { + new PaintA(); + } + }); + } + +} diff --git a/Java/M3-code/paint/PaintB.java b/Java/M3-code/paint/PaintB.java new file mode 100644 index 0000000..8f11b20 --- /dev/null +++ b/Java/M3-code/paint/PaintB.java @@ -0,0 +1,166 @@ +package paint; + +import java.awt.BasicStroke; +import java.awt.Color; +import java.awt.Dimension; +import java.awt.Graphics; +import java.awt.Graphics2D; +import java.awt.Stroke; +import java.awt.event.ActionEvent; +import java.awt.event.ActionListener; +import java.util.LinkedList; +import java.util.List; +import java.awt.BorderLayout; + +import javax.swing.ButtonGroup; +import javax.swing.JButton; +import javax.swing.JCheckBox; +import javax.swing.JFrame; +import javax.swing.JPanel; +import javax.swing.JRadioButton; +import javax.swing.SwingUtilities; + +// Adding MODES for user interaction +// Radio buttons select the modes + +// Application still does not support support any painting + +/** + * The main class of the Java Paint application. + * + * This class stores the state of the application, creates the user interface, + * and is a mouse listener for the canvas object. + */ +public class PaintB { + + /** Area of the screen used for drawing */ + private Canvas canvas; + + /** Current drawing mode */ + public enum Mode { + PointMode, LineStartMode + } + + private Mode mode = Mode.PointMode; + + /** The list of shapes that will be drawn on the canvas. */ + private List shapes = new LinkedList(); + /** Preview shape for drag and drop */ + private Shape preview = null; + + /** + * A Canvas is a section of the screen that can be drawn on. + * + * Just like in the OCaml Paint assignment, we draw with a repainting + * function that uses some local state to determine what to draw. In Swing, + * the drawing method of a widget is called "paintComponent" + * + * The canvas is an *inner* class so that it can access the private + * 'actions' and 'preview' fields of the Paint. + */ + @SuppressWarnings("serial") + private class Canvas extends JPanel { + + /** + * Display the canvas on the screen using the Graphics Context. + * + * This method overrides the analogous method in its superclass. + * Therefore the first action it does is to call the superclass version + * of the method. Then it goes through each shape and invokes its draw + * method. + */ + @Override + public void paintComponent(Graphics gc) { + super.paintComponent(gc); + if (shapes != null) { + for (Shape s : shapes) { + s.draw(gc); + } + } + if (preview != null) { + preview.draw(gc); + } + } + + @Override + public Dimension getPreferredSize() { + return new Dimension(600, 400); + } + + public Canvas() { + super(); + setBackground(Color.WHITE); + } + + } + + // add an action listener that specifies the code to run when + // the button is selected + private JRadioButton makeShapeButton(ButtonGroup group, JPanel modeToolbar, + String name, final Mode buttonMode) { + JRadioButton b = new JRadioButton(name); + group.add(b); + modeToolbar.add(b); + b.addActionListener(new ActionListener() { + public void actionPerformed(ActionEvent e) { + mode = buttonMode; + } + }); + return b; + } + + private JPanel createModeToolbar() { + + JPanel modeToolbar = new JPanel(); + + // Create the group of buttons that select the mode + ButtonGroup group = new ButtonGroup(); + + // create buttons for points and lines, and add them to the list + JRadioButton point = makeShapeButton(group, modeToolbar, "Point", Mode.PointMode); + makeShapeButton(group, modeToolbar, "Line", Mode.LineStartMode); + // add more shapes here + + // start by selecting the buttons for points + point.doClick(); + + // the checkbox for thin/thick lines + JCheckBox thick = new JCheckBox("Thick Lines"); + modeToolbar.add(thick); + + // exiting the program + JButton quit = new JButton("Quit"); + modeToolbar.add(quit); + quit.addActionListener(new ActionListener() { + public void actionPerformed(ActionEvent e) { + System.exit(0); + } + }); + return modeToolbar; + } + + public PaintB() { + + final JFrame frame = new JFrame(); + frame.setLayout(new BorderLayout()); + + canvas = this.new Canvas(); + + frame.add(canvas, BorderLayout.CENTER); + + frame.add(createModeToolbar(), BorderLayout.PAGE_END); + + frame.pack(); + frame.setVisible(true); + frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); + } + + public static void main(String[] args) { + SwingUtilities.invokeLater(new Runnable() { + public void run() { + new PaintB(); + } + }); + } + +} diff --git a/Java/M3-code/paint/PaintC.java b/Java/M3-code/paint/PaintC.java new file mode 100644 index 0000000..50d7c8e --- /dev/null +++ b/Java/M3-code/paint/PaintC.java @@ -0,0 +1,218 @@ +package paint; + +import java.awt.BasicStroke; +import java.awt.Color; +import java.awt.Dimension; +import java.awt.Graphics; +import java.awt.Point; +import java.awt.Stroke; +import java.awt.event.ActionEvent; +import java.awt.event.ActionListener; +import java.awt.event.ItemEvent; +import java.awt.event.ItemListener; +import java.awt.event.MouseEvent; +import java.awt.event.MouseAdapter; +import java.util.LinkedList; +import java.util.List; +import java.awt.BorderLayout; + +import javax.swing.ButtonGroup; +import javax.swing.JButton; +import javax.swing.JCheckBox; +import javax.swing.JFrame; +import javax.swing.JPanel; +import javax.swing.JRadioButton; +import javax.swing.SwingUtilities; + +// Adding a mouse listener to support +// mouse interaction without preview + +// Add an ItemListener for the thickness checkbox + +/** The main class of the Java Paint application. + + This class stores the state of the application, + creates the user interface, and is a mouse listener for + the canvas object. + */ +public class PaintC { + + /** Area of the screen used for drawing */ + private Canvas canvas; + + /** Current drawing color */ + private Color color = Color.BLACK; + + /** Stroke for drawing shapes with thin lines */ + private final static Stroke thinStroke = new BasicStroke(1); + + /** Stroke for drawing shapes with thick lines */ + private final static Stroke thickStroke = new BasicStroke(3); + + /** Current drawing thickness */ + private Stroke stroke = thickStroke; + + /** Current drawing mode */ + public enum Mode { + PointMode, + LineStartMode, + LineEndMode + } + + private Mode mode = null; + + + /** The list of shapes that will be drawn on the canvas. */ + private List shapes = new LinkedList(); + + + /** A Canvas is a section of the screen that can be drawn on. + * + * Just like in the OCaml Paint assignment, we draw with a repainting + * function that uses some local state to determine what to draw. + * In Swing, the drawing method of a widget is called "paintComponent" + * + * The canvas is an *inner* class so that it can access the + * private 'actions' and 'preview' fields of the Paint. + */ + @SuppressWarnings("serial") + private class Canvas extends JPanel { + + /** Display the canvas on the screen using the Graphics Context. + * + * This method overrides the analogous method in its superclass. + * Therefore the first action it does is to call the superclass version + * of the method. Then it goes through each shape and invokes its + */ + @Override + public void paintComponent(Graphics gc) { + super.paintComponent(gc); + if (shapes != null){ + for (Shape s : shapes) { + s.draw(gc); + } + } + + } + @Override + public Dimension getPreferredSize() { + return new Dimension(600,400); + } + + public Canvas(){ + super(); + setBackground(Color.WHITE); + } + + } + + private class Mouse extends MouseAdapter { + /** Location of the mouse when it was last pressed. */ + private Point modePoint; + + @Override + public void mouseClicked(MouseEvent arg0) { + Point p = arg0.getPoint(); + switch (mode) { + case PointMode: + shapes.add(new PointShape(color,stroke,p)); + break; + case LineStartMode: + mode = Mode.LineEndMode; + modePoint = p; + break; + case LineEndMode: + shapes.add(new LineShape(color,stroke,p,modePoint)); + mode = Mode.LineStartMode; + break; + } + canvas.repaint(); + } + + } + + + // add an action listener that specifies the code to run when + // the button is selected + private JRadioButton makeShapeButton(ButtonGroup group, + JPanel modeToolbar, String name, final Mode buttonMode) { + JRadioButton b = new JRadioButton(name); + group.add(b); + modeToolbar.add(b); + b.addActionListener(new ActionListener() { + public void actionPerformed(ActionEvent e) { + mode = buttonMode; + } + }); + return b; + } + + private JPanel createModeToolbar() { + + JPanel modeToolbar = new JPanel(); + + // Create the group of buttons that select the mode + ButtonGroup group = new ButtonGroup(); + + // create buttons for points and lines, and add them to the list + JRadioButton point = + makeShapeButton(group, modeToolbar, "Point", Mode.PointMode); + makeShapeButton(group, modeToolbar, "Line", Mode.LineStartMode); + // add more shapes here + + // start by selecting the buttons for points + point.doClick(); + + // the checkbox for thin/thick lines + JCheckBox thick = new JCheckBox("Thick Lines"); + modeToolbar.add(thick); + thick.addItemListener(new ItemListener() { + public void itemStateChanged(ItemEvent e){ + if (e.getStateChange() == ItemEvent.SELECTED) { + stroke = thickStroke; + } else { + stroke = thinStroke; + } + } + }); + // start with thick lines + thick.doClick(); + + + // exiting the program + JButton quit = new JButton("Quit"); + modeToolbar.add(quit); + quit.addActionListener(new ActionListener() { + public void actionPerformed(ActionEvent e) { + System.exit(0); + } + }); + return modeToolbar; + } + + public PaintC () { + + JFrame frame = new JFrame(); + frame.setLayout(new BorderLayout()); + + canvas = this.new Canvas(); + canvas.addMouseListener(new Mouse()); // mouse clicked events + frame.add(canvas, BorderLayout.CENTER); + + frame.add(createModeToolbar(), BorderLayout.PAGE_END); + + frame.pack(); + frame.setVisible(true); + frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); + } + + + public static void main(String[] args){ + SwingUtilities.invokeLater(new Runnable() { + public void run() { + new PaintC(); + } + }); + } + +} diff --git a/Java/M3-code/paint/PaintD.java b/Java/M3-code/paint/PaintD.java new file mode 100644 index 0000000..d2d61fb --- /dev/null +++ b/Java/M3-code/paint/PaintD.java @@ -0,0 +1,265 @@ +package paint; + +import java.awt.BasicStroke; +import java.awt.Color; +import java.awt.Dimension; +import java.awt.Graphics; +import java.awt.Graphics2D; +import java.awt.Point; +import java.awt.Stroke; +import java.awt.event.ActionEvent; +import java.awt.event.ActionListener; +import java.awt.event.ItemEvent; +import java.awt.event.ItemListener; +import java.awt.event.MouseEvent; +import java.awt.event.MouseAdapter; +import java.util.LinkedList; +import java.util.List; +import java.awt.BorderLayout; + +import javax.swing.ButtonGroup; +import javax.swing.JButton; +import javax.swing.JCheckBox; +import javax.swing.JFrame; +import javax.swing.JPanel; +import javax.swing.JRadioButton; +import javax.swing.SwingUtilities; + +// Drag and Drop previewing for lines using +// an enumeration for modes +// Reaction from a MouseListener and MouseMotionListener + +/** + * The main class of the Java Paint application. + * + * This class stores the state of the application, and creates the user + * interface. + */ +public class PaintD { + + /** Area of the screen used for drawing */ + private Canvas canvas; + + /** Current drawing color */ + private Color color = Color.BLACK; + + /** Stroke for drawing shapes with thin lines */ + public final static Stroke thinStroke = new BasicStroke(1); + + /** Stroke for drawing shapes with thick lines */ + public final static Stroke thickStroke = new BasicStroke(3); + + /** Current drawing thickness */ + private Stroke stroke = thickStroke; + + /** Current drawing mode */ + public enum Mode { + PointMode, LineStartMode, LineEndMode, + } + + private Mode mode = null; + + /** The list of shapes that will be drawn on the canvas. */ + private List shapes = new LinkedList(); + + /** an optional shape for preview mode */ + private Shape preview; + + /** + * A Canvas is a section of the screen that can be drawn on. + * + * Just like in the OCaml Paint assignment, we draw with a repainting + * function that uses some local state to determine what to draw. In Swing, + * the drawing method of a widget is called "paintComponent" + * + * The canvas is an *inner* class so that it can access the private + * 'actions' and 'preview' fields of the Paint. + */ + @SuppressWarnings("serial") + private class Canvas extends JPanel { + + /** + * Display the canvas on the screen using the Graphics Context. + * + * This method overrides the analogous method in its superclass. + * Therefore the first action it does is to call the superclass version + * of the method. Then it goes through each shape and invokes its draw + * method. + */ + @Override + public void paintComponent(Graphics gc) { + super.paintComponent(gc); + if (shapes != null) { + for (Shape s : shapes) { + s.draw(gc); + } + } + if (preview != null) { + preview.draw(gc); + } + } + + @Override + public Dimension getPreferredSize() { + return new Dimension(600, 400); + } + + public Canvas() { + super(); + setBackground(Color.WHITE); + } + + } + + private class Mouse extends MouseAdapter { + /** Location of the mouse when it was last pressed. */ + private Point lineStart; + + /** + * Code to execute when the button is pressed while the mouse is in the + * canvas. + * + * This method is in the Paint class so that it can access and update + * the state of the paint application. + */ + @Override + public void mousePressed(MouseEvent arg0) { + Point p = arg0.getPoint(); + switch (mode) { + case LineStartMode: + mode = Mode.LineEndMode; + lineStart = p; + preview = new LineShape(color, stroke, lineStart, p); + break; + default: + break; + } + canvas.repaint(); + } + + /** + * Code to execute when the button is pressed while the mouse is moved + * with the button down in the canvas. + */ + public void mouseDragged(MouseEvent arg0) { + Point p = arg0.getPoint(); + switch (mode) { + case LineEndMode: + preview = new LineShape(color, stroke, lineStart, p); + break; + default: + break; + + } + canvas.repaint(); + } + + /** + * Code to execute when the button is released while the mouse is in the + * canvas. + */ + @Override + public void mouseReleased(MouseEvent arg0) { + Point p = arg0.getPoint(); + switch (mode) { + case PointMode: + shapes.add(new PointShape(color, stroke, p)); + break; + case LineEndMode: + mode = Mode.LineStartMode; + shapes.add(new LineShape(color, stroke, lineStart, p)); + lineStart = null; + preview = null; + break; + default: + break; + + } + canvas.repaint(); + } + } + + // add an action listener that specifies the code to run when + // the button is selected + private JRadioButton makeShapeButton(ButtonGroup group, JPanel modeToolbar, String name, final Mode buttonMode) { + JRadioButton b = new JRadioButton(name); + group.add(b); + modeToolbar.add(b); + b.addActionListener(new ActionListener() { + public void actionPerformed(ActionEvent e) { + mode = buttonMode; + preview = null; + } + }); + return b; + } + + private JPanel createModeToolbar() { + + JPanel modeToolbar = new JPanel(); + + // Create the group of buttons that select the mode + ButtonGroup group = new ButtonGroup(); + + // create buttons for points and lines, and add them to the list + JRadioButton point = makeShapeButton(group, modeToolbar, "Point", Mode.PointMode); + makeShapeButton(group, modeToolbar, "Line", Mode.LineStartMode); + // add more shapes here + + // start by selecting the buttons for points + point.doClick(); + + // the checkbox for thin/thick lines + JCheckBox thick = new JCheckBox("Thick Lines"); + modeToolbar.add(thick); + thick.addItemListener(new ItemListener() { + public void itemStateChanged(ItemEvent e) { + if (e.getStateChange() == ItemEvent.SELECTED) { + stroke = thickStroke; + } else { + stroke = thinStroke; + } + } + }); + // start with thick lines + thick.doClick(); + + // exiting the program + JButton quit = new JButton("Quit"); + modeToolbar.add(quit); + quit.addActionListener(new ActionListener() { + public void actionPerformed(ActionEvent e) { + System.exit(0); + } + }); + return modeToolbar; + } + + public PaintD() { + + JFrame frame = new JFrame(); + frame.setLayout(new BorderLayout()); + + canvas = this.new Canvas(); + + Mouse mouseListener = new Mouse(); + canvas.addMouseMotionListener(mouseListener); // dragged events + canvas.addMouseListener(mouseListener); // press/release events + + frame.add(canvas, BorderLayout.CENTER); + frame.add(createModeToolbar(), BorderLayout.PAGE_END); + + frame.pack(); + frame.setVisible(true); + frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); + } + + public static void main(String[] args) { + SwingUtilities.invokeLater(new Runnable() { + public void run() { + new PaintD(); + } + }); + } + +} diff --git a/Java/M3-code/paint/PaintE.java b/Java/M3-code/paint/PaintE.java new file mode 100644 index 0000000..b029f5a --- /dev/null +++ b/Java/M3-code/paint/PaintE.java @@ -0,0 +1,272 @@ +package paint; + +import java.awt.BasicStroke; +import java.awt.Color; +import java.awt.Dimension; +import java.awt.Graphics; +import java.awt.Graphics2D; +import java.awt.Point; +import java.awt.Stroke; +import java.awt.event.ActionEvent; +import java.awt.event.ActionListener; +import java.awt.event.ItemEvent; +import java.awt.event.ItemListener; +import java.awt.event.MouseEvent; +import java.awt.event.MouseAdapter; +import java.awt.event.MouseListener; +import java.util.LinkedList; +import java.util.List; +import java.awt.BorderLayout; + +import javax.swing.ButtonGroup; +import javax.swing.JButton; +import javax.swing.JCheckBox; +import javax.swing.JFrame; +import javax.swing.JPanel; +import javax.swing.JRadioButton; + +import java.awt.event.MouseMotionListener; + +import javax.swing.SwingUtilities; + +// Refactor to use objects instead of Enums +// for the mouse listener + +/** + * The main class of the Java Paint application. + * + * This class stores the state of the application, and creates the user + * interface. + */ +public class PaintE { + + /** Area of the screen used for drawing */ + private Canvas canvas; + + /** Current drawing color */ + private Color color = Color.BLACK; + + /** Stroke for drawing shapes with thin lines */ + public final static Stroke thinStroke = new BasicStroke(1); + + /** Stroke for drawing shapes with thick lines */ + public final static Stroke thickStroke = new BasicStroke(3); + + /** Current drawing thickness */ + private Stroke stroke = thickStroke; + + interface Mode extends MouseListener, MouseMotionListener { + } + + class PointMode extends MouseAdapter implements Mode { + public void mouseReleased(MouseEvent e) { + Point p = e.getPoint(); + shapes.add(new PointShape(color, stroke, p)); + } + + } + + class LineStartMode extends MouseAdapter implements Mode { + public void mousePressed(MouseEvent e) { + mode = new LineEndMode(e.getPoint()); + } + + } + + class LineEndMode extends MouseAdapter implements Mode { + Point modePoint; + + LineEndMode(Point p) { + modePoint = p; + } + + public void mouseDragged(MouseEvent arg0) { + Point p = arg0.getPoint(); + preview = new LineShape(color, stroke, modePoint, p); + } + + public void mouseReleased(MouseEvent arg0) { + mode = new LineStartMode(); + Point p = arg0.getPoint(); + shapes.add(new LineShape(color, stroke, modePoint, p)); + modePoint = null; + preview = null; + + } + + } + + private Mode mode = null; + + /** The list of shapes that will be drawn on the canvas. */ + private final List shapes = new LinkedList(); + + /** an optional shape for preview mode */ + private Shape preview; + + /** + * A Canvas is a section of the screen that can be drawn on. + * + * Just like in the OCaml Paint assignment, we draw with a repainting + * function that uses some local state to determine what to draw. In Swing, + * the drawing method of a widget is called "paintComponent" + * + * The canvas is an *inner* class so that it can access the private + * 'actions' and 'preview' fields of the Paint. + */ + @SuppressWarnings("serial") + private class Canvas extends JPanel { + + /** + * Display the canvas on the screen using the Graphics Context. + * + * This method overrides the analogous method in its superclass. + * Therefore the first action it does is to call the superclass version + * of the method. Then it goes through each shape and invokes its draw + * method. + */ + @Override + public void paintComponent(Graphics gc) { + super.paintComponent(gc); + if (shapes != null) { + for (Shape s : shapes) { + s.draw(gc); + } + } + if (preview != null) { + preview.draw(gc); + } + } + + @Override + public Dimension getPreferredSize() { + return new Dimension(600, 400); + } + + public Canvas() { + super(); + setBackground(Color.WHITE); + } + + } + + private class Mouse extends MouseAdapter { + + /** + * Code to execute when the button is pressed while the mouse is in the + * canvas. + * + * This method is in the Paint class so that it can access and update + * the state of the paint application. + */ + @Override + public void mousePressed(MouseEvent arg0) { + + mode.mousePressed(arg0); + canvas.repaint(); + } + + /** + * Code to execute when the button is pressed while the mouse is moved + * with the button down in the canvas. + */ + public void mouseDragged(MouseEvent arg0) { + mode.mouseDragged(arg0); + canvas.repaint(); + } + + /** + * Code to execute when the button is released while the mouse is in the + * canvas. + */ + @Override + public void mouseReleased(MouseEvent arg0) { + mode.mouseReleased(arg0); + canvas.repaint(); + } + } + + // add an action listener that specifies the code to run when + // the button is selected + private JRadioButton makeShapeButton(ButtonGroup group, JPanel modeToolbar, String name, final Mode buttonMode) { + JRadioButton b = new JRadioButton(name); + group.add(b); + modeToolbar.add(b); + b.addActionListener(new ActionListener() { + public void actionPerformed(ActionEvent e) { + mode = buttonMode; + preview = null; + } + }); + return b; + } + + private JPanel createModeToolbar() { + + JPanel modeToolbar = new JPanel(); + + // Create the group of buttons that select the mode + ButtonGroup group = new ButtonGroup(); + + // create buttons for points and lines, and add them to the list + JRadioButton point = makeShapeButton(group, modeToolbar, "Point", new PointMode()); + makeShapeButton(group, modeToolbar, "Line", new LineStartMode()); + // add more shapes here + + // start by selecting the buttons for points + point.doClick(); + + // the checkbox for thin/thick lines + JCheckBox thick = new JCheckBox("Thick Lines"); + modeToolbar.add(thick); + thick.addItemListener(new ItemListener() { + public void itemStateChanged(ItemEvent e) { + if (e.getStateChange() == ItemEvent.SELECTED) { + stroke = thickStroke; + } else { + stroke = thinStroke; + } + } + }); + // start with thick lines + thick.doClick(); + + // exiting the program + JButton quit = new JButton("Quit"); + modeToolbar.add(quit); + quit.addActionListener(new ActionListener() { + public void actionPerformed(ActionEvent e) { + System.exit(0); + } + }); + return modeToolbar; + } + + public PaintE() { + + JFrame frame = new JFrame(); + frame.setLayout(new BorderLayout()); + + canvas = this.new Canvas(); + + Mouse mouseListener = new Mouse(); + canvas.addMouseMotionListener(mouseListener); // dragged events + canvas.addMouseListener(mouseListener); // press/release events + + frame.add(canvas, BorderLayout.CENTER); + frame.add(createModeToolbar(), BorderLayout.PAGE_END); + + frame.pack(); + frame.setVisible(true); + frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); + } + + public static void main(String[] args) { + SwingUtilities.invokeLater(new Runnable() { + public void run() { + new PaintE(); + } + }); + } + +} diff --git a/Java/M3-code/paint/PointShape.java b/Java/M3-code/paint/PointShape.java new file mode 100644 index 0000000..bd2a944 --- /dev/null +++ b/Java/M3-code/paint/PointShape.java @@ -0,0 +1,41 @@ +package paint; + + +import java.awt.Color; +import java.awt.Graphics; +import java.awt.Graphics2D; +import java.awt.Stroke; +import java.awt.Point; + + +/** A point that may be drawn on the canvas. */ +public class PointShape implements Shape { + private Point point; + private Color color; + private Stroke stroke; + + /** Construct a point given its color, stroke and location. + + The constructor assumes that all parameters are nonnull. + */ + public PointShape (Color c, Stroke s, Point p) { + color = c; + stroke = s; + point = p; + } + + /* The dynamic class of gc is actually as subclass of + * Graphics called Graphics2D that supports more functionality. However, + * due to backwards compatibility, the argument to paintComponent has + * the static type of "Graphics". Therefore, we must do a dynamic + * cast before we can use some drawing routines. + */ + public void draw(Graphics gc0) { + Graphics2D gc = (Graphics2D)gc0; + gc.setColor(color); + gc.setStroke(stroke); + gc.drawLine(point.x, point.y, point.x, point.y); + + } + +} diff --git a/Java/M3-code/paint/Shape.java b/Java/M3-code/paint/Shape.java new file mode 100644 index 0000000..909b4e6 --- /dev/null +++ b/Java/M3-code/paint/Shape.java @@ -0,0 +1,13 @@ +package paint; + +import java.awt.Graphics; + + +/** An interface for shapes that can be drawn on the screen */ +public interface Shape { + + /** Display the shape on the screen */ + public void draw(Graphics gc); + + +} diff --git a/Java/M3-code/problem.txt b/Java/M3-code/problem.txt new file mode 100644 index 0000000..1aadb2d --- /dev/null +++ b/Java/M3-code/problem.txt @@ -0,0 +1,5 @@ +Write a command-line program that, given a filename for a text file +as input, calculates the frequencies (i.e. number of occurrences) of +each distinct word of the file. The program should then print the +frequency distribution to the console as a sequence of "word: freq" +pairs (one per line).