diff --git a/src/skidl/circuit.py b/src/skidl/circuit.py index e61d96aa..a1e9947d 100644 --- a/src/skidl/circuit.py +++ b/src/skidl/circuit.py @@ -702,123 +702,123 @@ def generate_netlistsvg_skin(self, net_stubs): part_svg = list(part_svg.values()) # Just keep the SVG for the part symbols. head_svg = [ - '' - " ' - " ' - " " - "" - "" - "" - '' - ' input' - ' ' - ' ' - ' ' - "" - "" - '' - ' output' - ' ' - ' ' - ' ' - "" - "" - "" - "" - '' - ' generic' - ' ' - ' ' - ' out0' - " " - ' ' - ' out1' - " " - ' ' - ' in0' - " " - ' ' - ' in1' - " " - "" - "" + '', + " ', + " ', + " ", + "", + "", + "", + '', + ' input', + ' ', + ' ', + ' ', + "", + "", + '', + ' output', + ' ', + ' ', + ' ', + "", + "", + "", + "", + '', + ' generic', + ' ', + ' ', + ' out0', + " ", + ' ', + ' out1', + " ", + ' ', + ' in0', + " ", + ' ', + ' in1', + " ", + "", + "", ] tail_svg = [ diff --git a/src/skidl/tools/kicad/v6.py b/src/skidl/tools/kicad/v6.py index f9680f1c..f84632fe 100644 --- a/src/skidl/tools/kicad/v6.py +++ b/src/skidl/tools/kicad/v6.py @@ -15,12 +15,18 @@ from builtins import int from collections import OrderedDict +from collections import namedtuple +import math import sexpdata from future import standard_library from ...logger import active_logger from ...utilities import export_to_all, num_to_chars, to_list +from ...schematics.geometry import ( + BBox, + Point, +) standard_library.install_aliases() @@ -118,6 +124,369 @@ def load_sch_lib(self, f, filename, lib_search_paths_): ) +def symbol_to_dict(symbol): + """ + Convert a list of symbols from a KICAD part definition into a + dictionary for easier access to properties. + """ + d = {} + name = symbol[0].value() + items = symbol[1:] + d = {} + is_named_present = False + item_names = [] + for item in items: + # If the object is a list, recursively convert to dict + if isinstance(item, list): + item_name, item_dict = symbol_to_dict(item) + is_named_present = True + # If the object is unnamed, put it in the "misc" list + # ["key", item1, item2, ["xy", 0, 0]] -> "key": {"misc":[item1, item2], "xy":[0,0] + else: + item_name = "misc" + item_dict = item + + # Multiple items with the same key (e.g. ("xy" 0 0) ("xy" 1 0)) + # get put into a list {"xy": [[0,0],[1,0]]} + if item_name not in item_names: + item_names.append(item_name) + if item_name not in d: + d[item_name] = [item_dict] + else: + d[item_name].append(item_dict) + + # if a list has only one item, remove it from the list + for item_name in item_names: + if len(d[item_name]) == 1: + d[item_name] = d[item_name][0] + + if not is_named_present: + d = d["misc"] + + return name, d + + +def get_pin_info(x, y, rotation, length): + quadrant = (rotation+45)//90 + side = { + 0: "right", + 1: "top", + 2: "left", + 3: "bottom", + }[quadrant] + + dx = math.cos( math.radians(rotation)) + dy = -math.sin( math.radians(rotation)) + endx = x+dx*length + endy = y+dy*length + + # Sometimes the pins are drawn from the tip towards the part + # and sometimes from the part towards the tip. Assuming the + # part center is close to the origin, we can flip this by + # considering the point farthest from the origin to be the tip + if math.dist([endx,endy], [0,0]) > math.dist([x,y], [0,0]): + return [x,y], [endx, endy], side + else: + side = { + "right":"left", + "top":"bottom", + "left":"right", + "bottom":"top", + }[side] + return [endx, endy], [x,y], side + +def symbol_to_svg(symbol): + shape_type, shape = symbol_to_dict(symbol) + + shape_bbox = BBox() + + default_stroke_width = "1" + default_stroke = "#000" + + if not "stroke" in shape: + shape["stroke"] = {} + if not "type" in shape["stroke"]: + shape["stroke"]["type"] = "default" + if not "width" in shape["stroke"]: + shape["stroke"]["width"] = 0 + + if not "fill" in shape: + shape["fill"] = {} + if not "type" in shape["fill"]: + shape["fill"]["type"] = "none" + if not "justify" in shape: + shape["justify"] = "right" + + if shape["stroke"]["type"] == "default": + shape["stroke"]["type"] = "#000" + if shape["stroke"]["width"] == 0: + shape["stroke"]["width"] = 0.1 + + + if shape_type == "polyline": + points = [] + for pt in shape["pts"]["xy"]: + x = pt[0] + y = -pt[1] + shape_bbox.add(Point(x,y)) + points.append(x) + points.append(y) + points_str=" ".join( [str(pt) for pt in points] ) + stroke= shape["stroke"]["type"], + stroke_width= shape["stroke"]["width"] + fill= shape["fill"]["type"] + + shape_svg = " ".join( + [ + "", + ] + ).format(**locals()) + elif shape_type == "circle": + cx = shape["center"][0] + cy = -shape["center"][1] + r = shape["radius"] + shape_bbox.add(Point(cx,cy) + Point(r,r)) + shape_bbox.add(Point(cx,cy) - Point(r,r)) + stroke= shape["stroke"]["type"] + stroke_width= shape["stroke"]["width"] + fill= shape["fill"]["type"] + shape_svg = " ".join( + [ + "", + ] + ).format(**locals()) + elif shape_type == "rectangle": + x = shape["start"][0] + y = -shape["start"][1] + endx = shape["end"][0] + endy = -shape["end"][1] + newx = min(x, endx) + newy = min(y, endy) + width = abs(endx-x) + height = abs(endy-y) + shape_bbox.add(Point(x,y)) + shape_bbox.add(Point(endx, endy)) + stroke= shape["stroke"]["type"] + stroke_width= shape["stroke"]["width"] + fill= shape["fill"]["type"] + shape_svg = " ".join( + [ + "", + ] + ).format(**locals()) + elif shape_type == "arc": + a = [shape["start"][0], -shape["start"][1]] + b = [shape["end"][0], -shape["end"][1]] + c = [shape["mid"][0], -shape["mid"][1]] + shape_bbox.add(Point(*a)) + shape_bbox.add(Point(*b)) + shape_bbox.add(Point(*c)) + + A = math.dist(b,c) + B = math.dist(a,c) + C = math.dist(a,b) + + angle = math.acos( (A*A + B*B - C*C)/(2*A*B) ) + K = .5*A*B*math.sin(angle) + r = A*B*C/4/K + + large_arc = int(math.pi/2 > angle) + sweep = int((b[0] - a[0])*(c[1] - a[1]) - (b[1] - a[1])*(c[0] - a[0]) < 0) + stroke= shape["stroke"]["type"] + stroke_width= shape["stroke"]["width"] + fill= shape["fill"]["type"] + shape_svg = " ".join( + [ + "", + ] + ).format(**locals()) + elif shape_type == "property": + if shape["misc"][0].lower() == "reference": + class_ = "part_ref_text" + extra = 's:attribute="ref"' + elif shape["misc"][0].lower() == "value": + class_ = "part_name_text" + extra = 's:attribute="value"' + elif "hide" not in shape["effects"]["misc"]: + raise RuntimeError(f"Unknown property {symbol[1]} is not hidden") + x = shape["at"][0] + y = -shape["at"][1] + rotation = shape["at"][2] + font_size = shape["effects"]["font"]["size"][0] + justify = shape["justify"] + stroke= shape["stroke"]["type"] + stroke_width= shape["stroke"]["width"] + fill= shape["fill"]["type"] + class_ = class_ + extra = extra + shape_text=shape["misc"][1] + + char_width = font_size*0.6 + rect_start_x=x + rect_start_y=y + + text_width=len(shape_text)*char_width + text_height=font_size + + dx = math.cos( math.radians(rotation)) + dy = math.sin( math.radians(rotation)) + + rect_end_x=x+dx*text_width+dy*text_height + rect_end_y=y-dx*text_height+dy*text_width + + rect_width=abs(rect_end_x-rect_start_x) + rect_height=abs(rect_end_y-rect_start_y) + rect_start_x = min(rect_start_x, rect_end_x) + rect_start_y = min(rect_start_y, rect_end_y) + + pivotx = x + pivoty = y + #x -= rect_width/2 + #y += rect_height/2 + + shape_svg = " ".join( + [ + "", + "{shape_text}", + "", + ] + ).format(**locals()) + + # Should the text be considered when computing the bounding box + extend_bbox_by_text = True + if extend_bbox_by_text: + shape_bbox.add(Point(rect_start_x, rect_start_y)) + shape_bbox.add(Point(rect_start_x+rect_width, rect_start_y+rect_height)) + + # Add the following to visualize the rectangle enclosing the text. + # Note that the text is modified later to include the reference number + # of the element and the value (e.g. R -> R1, V -> 10K) so the box may + # not correctly enclose the modified labels. + #shape_svg += " ".join( + # [ + # "\n", + # ] + #).format(**locals()) + pass + + elif shape_type == "pin": + x=shape["at"][0] + y=-shape["at"][1] + rotation=shape["at"][2] + length=shape["length"] + start, end, side = get_pin_info(x,y,rotation,length) + points_str = f"{start[0]}, {start[1]}, {end[0]}, {end[1]}" + name = shape["name"]["misc"] + number = shape["number"]["misc"] + stroke= shape["stroke"]["type"] + stroke_width= shape["stroke"]["width"] + fill= shape["fill"]["type"] + circle_stroke_width = 2*stroke_width + shape_bbox.add(Point(*start)) + shape_bbox.add(Point(*end)) + shape_svg = " ".join( + [ + # Draw a dot at the tip of the pin + "", + # Draw the pin + "\n", + ] + ).format(**locals()) + elif shape_type == "text": + x = shape["at"][0] + y = -shape["at"][1] + rotation = shape["at"][2] + font_size = shape["effects"]["font"]["size"][0] + justify = shape["justify"] + stroke= shape["stroke"]["type"] + stroke_width= shape["stroke"]["width"] + fill= shape["fill"]["type"] + shape_text=shape["misc"][0] + + char_width = font_size*0.6 + rect_start_x=x + rect_start_y=y + + text_width=len(shape_text)*char_width + text_height=font_size + + dx = math.cos( math.radians(rotation)) + dy = math.sin( math.radians(rotation)) + + rect_end_x=x+dx*text_width+dy*text_height + rect_end_y=y-dx*text_height+dy*text_width + + rect_width=abs(rect_end_x-rect_start_x) + rect_height=abs(rect_end_y-rect_start_y) + rect_start_x = min(rect_start_x, rect_end_x) + rect_start_y = min(rect_start_y, rect_end_y) + + pivotx = x + pivoty = y + + shape_svg = " ".join( + [ + "", + "{shape_text}", + "", + ] + ).format(**locals()) + + # Should the text be considered when computing the bounding box + extend_bbox_by_text = True + if extend_bbox_by_text: + shape_bbox.add(Point(rect_start_x, rect_start_y)) + shape_bbox.add(Point(rect_start_x+rect_width, rect_start_y+rect_height)) + + else: + raise RuntimeError(f"Unrecognized shape type: {shape_type}") + #print(shape_svg) + return shape_svg, shape_bbox + +PinInfo = namedtuple("PinInfo", "x y side pid") + @export_to_all def parse_lib_part(self, partial_parse): """ @@ -147,7 +516,10 @@ def parse_lib_part(self, partial_parse): self.aliases = [] # Part aliases. self.fplist = [] # Footprint list. - self.draw = [] # Drawing commands for symbol, including pins. + unit_nums = [] # Stores unit numbers for units with pins. + self.unit_pin_info = [[]] + self.unit_bboxes = [BBox()] + self.unit_svgs = [[]] for item in self.part_defn: if item[0].value().lower() == "extends": @@ -198,6 +570,13 @@ def parse_lib_part(self, partial_parse): pass break + properties = [item for item in self.part_defn if item[0].value().lower() == "property"] + props_to_draw = ["reference", "value"] + for prop_symbol in properties: + if prop_symbol[1].lower() in props_to_draw: + prop_svg, prop_bbox = symbol_to_svg(prop_symbol) + self.unit_bboxes[0].add(prop_bbox) + self.unit_svgs[0].append(prop_svg) # Populate part fields from symbol properties. properties = { @@ -213,7 +592,7 @@ def parse_lib_part(self, partial_parse): break self.fields[name] = value - self.ref_prefix = self.fields["F0"] # Part ref prefix (e.g., 'R'). + self.ref_prefix = self.fields["Reference"] # Part ref prefix (e.g., 'R'). # Association between KiCad and SKiDL pin types. pin_io_type_translation = { @@ -240,7 +619,6 @@ def parse_lib_part(self, partial_parse): self.num_units = len(units) # Get pins and assign them to each unit as well as the entire part. - unit_nums = [] # Stores unit numbers for units with pins. for unit_name, unit_data in units.items(): # Extract the part name, unit number, and conversion flag. @@ -250,10 +628,28 @@ def parse_lib_part(self, partial_parse): unit_num = int(unit_name_pieces[-2]) conversion_flag = int(unit_name_pieces[-1]) + if unit_num != 0: + self.unit_pin_info.append([]) + self.unit_bboxes.append(BBox()) + self.unit_svgs.append([]) + + unit_pin_info = self.unit_pin_info[-1] + unit_bbox = self.unit_bboxes[-1] + unit_svgs = self.unit_svgs[-1] + # Don't add this unit to the part if the conversion flag is 0. if not conversion_flag: continue + + unit_shapes = [item for item in unit_data if item[0].value().lower() != "pin"] + + + for shape in unit_shapes: + shape_svg, shape_bbox = symbol_to_svg(shape) + unit_bbox.add(shape_bbox) + unit_svgs.append(shape_svg) + # Get the pins for this unit. unit_pins = [item for item in unit_data if item[0].value().lower() == "pin"] @@ -264,25 +660,32 @@ def parse_lib_part(self, partial_parse): # Process the pins for the current unit. for pin in unit_pins: + pin_name, pin_dict = symbol_to_dict(pin) # Pin electrical type immediately follows the "pin" tag. - pin_func = pin_io_type_translation[pin[1].value().lower()] + pin_func = pin_io_type_translation[pin_dict["misc"][0].lower()] # Find the pin name and number starting somewhere after the pin function and shape. - pin_name = "" - pin_number = None - for item in pin[3:]: - item = to_list(item) - if item[0].value().lower() == "name": - pin_name = item[1] - elif item[0].value().lower() == "number": - pin_number = item[1] + pin_name = pin_dict["name"]["misc"] + pin_number = pin_dict["number"]["misc"] # Add the pins that were found to the total part. Include the unit identifier # in the pin so we can find it later when the part unit is created. + x = pin_dict["at"][0] + y = -pin_dict["at"][1] self.add_pins( - Pin(name=pin_name, num=pin_number, func=pin_func, unit=unit_num) + Pin(name=pin_name, num=pin_number, func=pin_func, unit=unit_num, x=x, y=y) ) + pin_svg, pin_bbox = symbol_to_svg(pin) + unit_bbox.add(pin_bbox) + unit_svgs.append(pin_svg) + + #print("pin orientation", pin_dict["at"][2]) + rotation = pin_dict["at"][2] + length = pin_dict["length"] + pin_start, pin_end, pin_side = get_pin_info(x, y, rotation, length) + pin_num = pin_dict["number"]["misc"] + unit_pin_info.append(PinInfo(x=pin_end[0], y=pin_end[1], side=pin_side, pid=pin_num)) # Clear the part reference field directly. Don't use the setter function # since it will try to generate and assign a unique part reference if @@ -316,4 +719,254 @@ def gen_svg_comp(part, symtx, net_stubs=None): Returns: SVG for the part symbol. """ - raise NotImplementedError + + scale = 10 # Scale of KiCad units to SVG units. + + # Named tuple for storing component pin information. + PinInfo = namedtuple("PinInfo", "x y side pid") + + # Get maximum length of net stub name if any are needed for this part symbol. + net_stubs = net_stubs or [] # Empty list of stub nets if argument is None. + max_stub_len = 0 # If no net stubs are needed, this stays at zero. + for pin in part: + for net in pin.nets: + # Don't let names for no-connect nets affect maximum stub length. + if net in [NC, None]: + continue + if net in net_stubs: + max_stub_len = max(len(net.name), max_stub_len) + + # Assemble and name the SVGs for all the part units. + svg = [] + for unit in range(1, part.num_units): + bbox = part.unit_bboxes[unit] + bbox.add(part.unit_bboxes[0]) + + # Assign part unit name. + if max_stub_len: + # If net stubs are attached to symbol, then it's only to be used + # for a specific part. Therefore, tag the symbol name with the unique + # part reference so it will only be used by this part. + symbol_name = "{part.name}_{part.ref}_{unit}_{symtx}".format(**locals()) + else: + # No net stubs means this symbol can be used for any part that + # also has no net stubs, so don't tag it with a specific part reference. + symbol_name = "{part.name}_{unit}_{symtx}".format(**locals()) + + + class TxBBox: + x=0 + y=0 + w=0 + h=0 + + tx_bbox = TxBBox() + tx_bbox.x = bbox.min.x + tx_bbox.y = bbox.min.y + tx_bbox.w = bbox.w + tx_bbox.h = bbox.h + if "H" in symtx: + tx_bbox.x = -(bbox.min.x+bbox.w) + tx_bbox.y = bbox.min.y + tx_bbox.w = bbox.w + tx_bbox.h = bbox.h + elif "V" in symtx: + tx_bbox.x = bbox.min.x + tx_bbox.y = -(bbox.min.y+bbox.h) + tx_bbox.w = bbox.w + tx_bbox.h = bbox.h + + if "R" in symtx: + newx = -(tx_bbox.y + tx_bbox.h) + newy = tx_bbox.x + neww = tx_bbox.h + newh = tx_bbox.w + tx_bbox.x = newx + tx_bbox.y = newy + tx_bbox.w = neww + tx_bbox.h = newh + elif "L" in symtx: + newx = tx_bbox.y + newy = -(tx_bbox.x + tx_bbox.w) + neww = tx_bbox.h + newh = tx_bbox.w + tx_bbox.x = newx + tx_bbox.y = newy + tx_bbox.w = neww + tx_bbox.h = newh + + tx_bbox.x *= scale + tx_bbox.y *= scale + tx_bbox.w *= scale + tx_bbox.h *= scale + + bbox_scale = 1.0 + w_diff = tx_bbox.w*(1-bbox_scale) + h_diff = tx_bbox.h*(1-bbox_scale) + tx_bbox.x += w_diff/2.0 + tx_bbox.y += h_diff/2.0 + tx_bbox.w *= bbox_scale + tx_bbox.h *= bbox_scale + + + # Begin SVG for part unit. Translate it so the bbox.min is at (0,0). + translate = bbox.min * -1 + translate = Point(tx_bbox.x, tx_bbox.y) * -1 + svg.append( + " ".join( + [ + "", + ] + ).format(**locals()) + ) + + # Add part alias. + svg.append(''.format(**locals())) + + # Add part unit text and graphics. + + if "H" in symtx: + scale_x = -1 + scale_y = 1 + elif "V" in symtx: + scale_x = 1 + scale_y = -1 + else: + scale_x = 1 + scale_y = 1 + + if "R" in symtx: + rotation = 90 + elif "L" in symtx: + rotation = 270 + else: + rotation = 0 + + svg.append( + " ".join( + [ + "", + ] + ).format(**locals()) + ) + + svg.append( + " ".join( + [ + "", + ] + ).format(**locals()) + ) + # Everything from unit 0 gets added to all units + for item in part.unit_svgs[0]: + if "text" not in item: + svg.append(item) + for item in part.unit_svgs[unit]: + if "text" not in item: + svg.append(item) + svg.append("") + + for item in part.unit_svgs[0]: + if "text" in item: + svg.append(item) + for item in part.unit_svgs[unit]: + if "text" in item: + svg.append(item) + svg.append("") + + # Place a visible bounding-box around symbol for trouble-shooting. + show_bbox = False + bbox_stroke_width = scale * 0.1 + if show_bbox: + svg.append( + " ".join( + [ + "", + ] + ).format(**locals()) + ) + + # Keep the pins out of the grouped text & graphics but adjust their coords + # to account for moving the bbox. + for pin_info in part.unit_pin_info[unit]: + pin_pt = Point(pin_info.x, pin_info.y) + + #print("pin_pt", pin_pt) + #print("symtx", symtx) + side = pin_info.side + if "H" in symtx: + pin_pt.x = -pin_pt.x + side = { + "right":"left", + "top":"top", + "left":"right", + "bottom":"bottom", + }[side] + elif "V" in symtx: + side = { + "right":"right", + "top":"bottom", + "left":"left", + "bottom":"top", + }[side] + pin_pt.y = -pin_pt.y + + if "L" in symtx: + side = { + "right":"top", + "top":"left", + "left":"bottom", + "bottom":"right", + }[side] + newx = pin_pt.y + pin_pt.y = -pin_pt.x + pin_pt.x = newx + elif "R" in symtx: + side = { + "right":"bottom", + "top":"right", + "left":"top", + "bottom":"left", + }[side] + newx = -pin_pt.y + pin_pt.y = pin_pt.x + pin_pt.x = newx + + pin_pt *= scale + + pid = pin_info.pid + font_size = 12 + justify="left" + pin_svg = " ".join([ + "", + "{pid}", + #"{side}", # Uncomment this to visualize/verify which side the pin is on + "", + '', + '']).format( + **locals() + ) + svg.append(pin_svg) + + # Finish SVG for part unit. + svg.append("\n") + + return "\n".join(svg) diff --git a/tests/examples/spice-sim-intro/spice-sim-intro.ipynb b/tests/examples/spice-sim-intro/spice-sim-intro.ipynb index 9aa704c1..c683b748 100644 --- a/tests/examples/spice-sim-intro/spice-sim-intro.ipynb +++ b/tests/examples/spice-sim-intro/spice-sim-intro.ipynb @@ -412,18 +412,11 @@ } }, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING: KICAD_SYMBOL_DIR environment variable is missing, so the default KiCad symbol libraries won't be searched.\n" - ] - }, { "name": "stdout", "output_type": "stream", "text": [ - "{'kicad': ['.'], 'skidl': ['.', '/media/devb/Main/xesscorp/KiCad/tools/skidl/skidl/libs'], 'spice': ['.']}\n" + "{'skidl': ['.', '/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/skidl/libs'], 'spice': ['.'], 'kicad': ['.', '/usr/share/kicad/symbols']}\n" ] } ], @@ -446,7 +439,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "{'kicad': ['.'], 'skidl': ['.', '/media/devb/Main/xesscorp/KiCad/tools/skidl/skidl/libs'], 'spice': ['.']}\n" + "{'skidl': ['.', '/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/skidl/libs'], 'spice': ['.'], 'kicad': ['.', '/usr/share/kicad/symbols']}\n" ] } ], @@ -483,9 +476,24 @@ "ExecuteTime": { "end_time": "2021-04-29T13:33:00.491941Z", "start_time": "2021-04-29T13:33:00.207877Z" - } + }, + "scrolled": false }, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "ERROR: No footprint for V/VS. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/3290265050.py:10]\n", + "ERROR: No footprint for R/R1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/3290265050.py:10]\n", + "INFO: 0 warnings found while generating netlist.\n", + "INFO: 2 errors found while generating netlist.\n", + "\n", + "ERROR: No footprint for V/VS. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/3290265050.py:10]\n", + "ERROR: No footprint for R/R1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/3290265050.py:10]\n", + "Unsupported Ngspice version 36\n" + ] + }, { "name": "stdout", "output_type": "stream", @@ -505,25 +513,14 @@ " 1.00 1.00\n" ] }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "No errors or warnings found during netlist generation.\n", - "\n" - ] - }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -588,21 +585,25 @@ "name": "stderr", "output_type": "stream", "text": [ + "ERROR: No footprint for PULSEV/V1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/4074105237.py:11]\n", + "ERROR: No footprint for R/R1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/4074105237.py:11]\n", + "ERROR: No footprint for C/C1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/4074105237.py:11]\n", + "INFO: 0 warnings found while generating netlist.\n", + "INFO: 3 errors found while generating netlist.\n", "\n", - "No errors or warnings found during netlist generation.\n", - "\n" + "ERROR: No footprint for PULSEV/V1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/4074105237.py:11]\n", + "ERROR: No footprint for R/R1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/4074105237.py:11]\n", + "ERROR: No footprint for C/C1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/4074105237.py:11]\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -661,6 +662,23 @@ } }, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "ERROR: No footprint for SINEV/V1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/2100732967.py:15]\n", + "ERROR: No footprint for E/E1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/2100732967.py:15]\n", + "ERROR: No footprint for R/R1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/2100732967.py:15]\n", + "ERROR: No footprint for R/R2. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/2100732967.py:15]\n", + "INFO: 0 warnings found while generating netlist.\n", + "INFO: 4 errors found while generating netlist.\n", + "\n", + "ERROR: No footprint for SINEV/V1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/2100732967.py:15]\n", + "ERROR: No footprint for E/E1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/2100732967.py:15]\n", + "ERROR: No footprint for R/R1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/2100732967.py:15]\n", + "ERROR: No footprint for R/R2. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/2100732967.py:15]\n" + ] + }, { "name": "stdout", "output_type": "stream", @@ -673,25 +691,14 @@ "\n" ] }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "No errors or warnings found during netlist generation.\n", - "\n" - ] - }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -760,21 +767,27 @@ "name": "stderr", "output_type": "stream", "text": [ + "ERROR: No footprint for SINEV/V1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/2415946275.py:14]\n", + "ERROR: No footprint for R/R1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/2415946275.py:14]\n", + "ERROR: No footprint for F/F1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/2415946275.py:14]\n", + "ERROR: No footprint for R/R2. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/2415946275.py:14]\n", + "INFO: 0 warnings found while generating netlist.\n", + "INFO: 4 errors found while generating netlist.\n", "\n", - "No errors or warnings found during netlist generation.\n", - "\n" + "ERROR: No footprint for SINEV/V1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/2415946275.py:14]\n", + "ERROR: No footprint for R/R1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/2415946275.py:14]\n", + "ERROR: No footprint for F/F1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/2415946275.py:14]\n", + "ERROR: No footprint for R/R2. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/2415946275.py:14]\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAyMAAAHHCAYAAACsmYd4AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAC3lElEQVR4nOzdd3hT5dvA8W+6B91000UZZY+ypyhShspScQOiuBVRcP5AVMQFKi5UXgUHiogDAYssZe8NZZTVAl1Q2tKWzpz3j9MEKgU6kpykvT/X1aunyck5d9KkPfcz7kenKIqCEEIIIYQQQliYndYBCCGEEEIIIeomSUaEEEIIIYQQmpBkRAghhBBCCKEJSUaEEEIIIYQQmpBkRAghhBBCCKEJSUaEEEIIIYQQmpBkRAghhBBCCKEJSUaEEEIIIYQQmpBkRAghhBBCCKEJSUaEqCNOnDiBTqdjzpw5WocihBBCCAFIMiJEhY4ePcojjzxCw4YNcXFxwdPTk+7du/PRRx9x8eJFs533wIEDvPbaa5w4ccJs56istLQ0nn/+eWJiYnBzc8Pd3Z3Y2FjefPNNsrKytA6v2jZs2MBrr71mE89h/fr1DB06lMDAQJydnYmMjOSRRx4hKSmp2sfMz8/ntdde459//jFdoNewdOlSXnvttSo/7rfffmPAgAHUr18fJycnQkJCuPPOO1m1apXpg7Sgt956i99//13rMIQQwmpIMiLEfyxZsoRWrVrx888/c+utt/Lxxx8zbdo0wsPDmTBhAs8884zZzn3gwAGmTJmieTKydetWWrZsyaeffkrPnj2ZMWMG06dPp127drz99tvceeedmsZXExs2bGDKlClWn4x8/PHH9OzZk7179/LUU0/x2WefcfvttzN//nxat27Nhg0bqnXc/Px8pkyZYtFkZMqUKZXeX1EURo8ezbBhw0hLS2P8+PHMmjWLJ554gmPHjnHTTTdV+7lbA0lGhBCiPAetAxDCmhw/fpy77rqLiIgIVq1aRXBwsPG+J554gsTERJYsWaJhhJcoikJBQQGurq4mPW5WVhZDhw7F3t6enTt3EhMTU+7+qVOn8tVXX5nkXHl5ebi7u1d4X35+Pm5ubiY5j61Zv34948aNo0ePHsTHx5d7HR577DG6d+/O7bffzv79+/Hx8dEwUtObPn06c+bMYdy4ccyYMQOdTme875VXXuG7777DwaHm/7qu9fkpKCjAyckJOztprxNCCLNThBBGjz76qAIo69evr9T+xcXFyuuvv640bNhQcXJyUiIiIpSXXnpJKSgoKLdfRESEMmjQIGXt2rVKx44dFWdnZyUqKkqZO3eucZ9vvvlGAa74Wr16dbljxMfHK7GxsYqzs7PywQcfKIqiKEePHlVuv/12xcfHR3F1dVU6d+6sLF68uFwMx48fVwDlm2++ueZzevvttxVA+eGHHyr1GgDK5MmTr7g9IiJCGTly5BXP759//lEee+wxxd/fX/H29lYURVF69+6ttGjRQtm2bZvSs2dPxdXVVXnmmWcURVGUgoICZdKkSUp0dLTi5OSkNGjQQJkwYcIVrzGgPPHEE8pvv/2mtGjRQnFyclKaN2+u/PXXX8Z9Jk+eXOFrfPz48Qqf2xNPPKG4u7sreXl5V9x31113KYGBgUpJSYmiKIqydetWpV+/foqfn5/i4uKiREZGKqNHj67Ua/hfcXFxir29vXLs2LEK7587d64CKNOmTTPe1rt3b6V3795X7Dty5EglIiJCUZRL74H/fhl+fyNHjlTc3d2Vo0ePKv369VPc3NyU4OBgZcqUKYperzcec/Xq1eXemwb/fY+NHDmywvNdTX5+vuLr66vExMQYX9drMfw+/8vwXrv893q1z4/hufz444/KK6+8ooSEhCg6nU45f/68oiiKsmnTJiUuLk7x9PRUXF1dlV69einr1q2rMI4jR44oI0eOVLy8vBRPT09l1KhR5d47Fb0Wl39GhBCiLpKeESEu8+eff9KwYUO6detWqf0feugh5s6dy+23385zzz3H5s2bmTZtGgkJCfz222/l9k1MTOT2229nzJgxjBw5kq+//ppRo0YRGxtLixYt6NWrF08//TQzZ87k5ZdfplmzZgDG7wCHDh3i7rvv5pFHHuHhhx+madOmpKWl0a1bN/Lz83n66afx8/Nj7ty53Hbbbfzyyy8MHTq0Sq/BokWLcHV15fbbb6/S4yrr8ccfx9/fn0mTJpGXl2e8/dy5cwwYMIC77rqL++67j8DAQPR6Pbfddhvr1q1j7NixNGvWjL179/LBBx9w+PDhK4a7rFu3jl9//ZXHH38cDw8PZs6cyfDhw0lKSsLPz49hw4Zx+PBhfvzxRz744APq168PgL+/f4Wxjhgxgk8//ZQlS5Zwxx13GG/Pz8/nzz//ZNSoUdjb25Oenk6/fv3w9/fnxRdfxNvbmxMnTvDrr79W+fXJz89n5cqV9OzZk6ioqKvGNXbsWBYvXsyLL75Y6WP7+/vz+eef89hjjzF06FCGDRsGQOvWrY37lJaW0r9/f7p06cK7775LfHw8kydPpqSkhNdff71Kz+WRRx7hzJkzLF++nO++++66+69bt47MzEzGjRuHvb19lc5VGRV9fgzeeOMNnJyceP755yksLMTJyYlVq1YxYMAAYmNjmTx5MnZ2dnzzzTfceOONrF27lk6dOpU7/p133klUVBTTpk1jx44dzJ49m4CAAN555x0AvvvuOx566CE6derE2LFjAYiOjjb58xRCCJuidTYkhLXIzs5WAGXw4MGV2n/Xrl0KoDz00EPlbn/++ecVQFm1apXxtoiICAVQ1qxZY7wtPT1dcXZ2Vp577jnjbQsWLKiwxfnyY8THx5e7fdy4cQqgrF271njbhQsXlKioKCUyMlIpLS1VFKXyPSM+Pj5KmzZtrvf0jahiz0iPHj2uaPXu3bu3AiizZs0qd/t3332n2NnZlXtuiqIos2bNuqIHC1CcnJyUxMRE4227d+9WAOXjjz823vbee+9dszfkcnq9XgkNDVWGDx9e7vaff/653O/zt99+UwBl69at1z3m9RjeV4aeoatp3bq14uvra/y5Mj0jiqIoGRkZV/2dGXoynnrqKeNter1eGTRokOLk5KRkZGQoilL5nhFFUXuXKvuv5qOPPlIA5bfffqvU/lXtGano82N4Lg0bNlTy8/ONt+v1eqVx48ZKXFxcuV6h/Px8JSoqSrn55puviOPBBx8sd+yhQ4cqfn5+5W5zd3eX3hAhhLiMDIgVokxOTg4AHh4eldp/6dKlAIwfP77c7c899xzAFXNLmjdvTs+ePY0/+/v707RpU44dO1bpGKOiooiLi7sijk6dOtGjRw/jbfXq1WPs2LGcOHGCAwcOVPr4oL4OlX0NquPhhx+usNXb2dmZ0aNHl7ttwYIFNGvWjJiYGM6ePWv8uvHGGwFYvXp1uf379u1brqW5devWeHp6Vuk1vpxOp+OOO+5g6dKl5ObmGm+fP38+oaGhxtfc29sbgMWLF1NcXFytcxlcuHABuP770MPDw/ieNbUnn3zSuK3T6XjyyScpKipixYoVZjmfQVU/g1VV0efHYOTIkeXmj+zatYsjR45wzz33cO7cOeN7Ly8vj5tuuok1a9ag1+vLHePRRx8t93PPnj05d+6c2X5PQghRG0gyIkQZT09P4NLF4PWcPHkSOzs7GjVqVO72oKAgvL29OXnyZLnbw8PDrziGj48P58+fr3SMFQ3bOXnyZLnhJgaG4V3/jeN6PD09K/0aVMfVhh6Fhobi5ORU7rYjR46wf/9+/P39y301adIEgPT09HL7m+I1/q8RI0Zw8eJFFi1aBEBubi5Lly7ljjvuME6u7t27N8OHD2fKlCnUr1+fwYMH880331BYWFjl8xkuxK/3O7hw4YJZLtrt7Oxo2LBhudsMr7e5q7xV9TNYVVd771V035EjRwA1Sfnv+2/27NkUFhaSnZ1d7jH/ff8ZigvU5P0nhBC1ncwZEaKMp6cnISEh7Nu3r0qPu7zaz7VcbQy8oiiVPpepK2dVJCYmhl27dlFUVHRFclAVpaWlFd5+tedQ0e16vZ5WrVoxY8aMCh8TFhZW7mdTvMb/1aVLFyIjI/n555+55557+PPPP7l48SIjRoww7qPT6fjll1/YtGkTf/75J8uWLePBBx9k+vTpbNq0iXr16lX6fI0aNcLBwYE9e/ZcdZ/CwkIOHTpEhw4dysVQ0fO82u+hJq72nq/puQyV2/bu3cuQIUNMHse1Pj//vc/Q6/Hee+/Rtm3bCh/z39+rOd5/QghR20nPiBCXueWWWzh69CgbN2687r4RERHo9XpjC6pBWloaWVlZREREVPn8lU1s/hvHoUOHrrj94MGDxvur4tZbb+XixYssXLiwUvv7+PhcsWZHUVERKSkpVTpvRaKjo8nMzOSmm26ib9++V3xV1CN0PdV5je+8807i4+PJyclh/vz5REZG0qVLlyv269KlC1OnTmXbtm388MMP7N+/n59++qlK53J3d6dPnz6sWbPmqr1aP//8M4WFhdxyyy3G2yr6PcCVPWPXe/56vf6KYW2HDx8GIDIy0ngu4IrzVRRvVV7vHj164OPjw48//lipxKYqcVSVYbifp6dnhe+9vn374ujoWOXjVuf9J4QQtZkkI0JcZuLEibi7u/PQQw+RlpZ2xf1Hjx7lo48+AmDgwIEAfPjhh+X2MbTiDxo0qMrnN6y5UZUF+QYOHMiWLVvKJVB5eXl8+eWXREZG0rx58yrF8OijjxIcHMxzzz1nvAi9XHp6Om+++abx5+joaNasWVNuny+//NIkLfJ33nknp0+frnBdk4sXL5arxlVZ1XmNR4wYQWFhIXPnziU+Pv6KRR/Pnz9/Reu3oTX98qFaR48e5ejRo9c936uvvoqiKIwaNYqLFy+Wu+/48eNMnDiR4OBgHnnkEePt0dHRHDx4kIyMDONtu3fvZv369eUeb1iz5FrP/5NPPjFuK4rCJ598gqOjIzfddBOgJrj29vZX/N4/++yzK45Vldfbzc2NF154gYSEBF544YUKexS+//57tmzZAlxKGC6PIy8vj7lz5173XNcTGxtLdHQ077//frn5QgaXv85V4e7ubvULbgohhCXJMC0hLhMdHc28efMYMWIEzZo144EHHqBly5YUFRWxYcMGFixYwKhRowBo06YNI0eO5MsvvyQrK4vevXuzZcsW5s6dy5AhQ+jTp0+Vz9+2bVvs7e155513yM7OxtnZmRtvvJGAgICrPubFF1/kxx9/ZMCAATz99NP4+voyd+5cjh8/zsKFC6u8cJuPjw+//fYbAwcOpG3bttx3333ExsYCsGPHDn788Ue6du1q3P+hhx7i0UcfZfjw4dx8883s3r2bZcuWGcvm1sT999/Pzz//zKOPPsrq1avp3r07paWlHDx4kJ9//plly5aVG6pUGYbn8sorr3DXXXfh6OjIrbfeetXFFwHat29Po0aNeOWVVygsLCw3RAtg7ty5fPbZZwwdOpTo6GguXLjAV199haenpzFpBYwX89ebe9GrVy/ef/99xo8fT+vWrRk1ahTBwcEcPHiQr776Cr1ez9KlS8stePjggw8yY8YM4uLiGDNmDOnp6cyaNYsWLVqUm0Dt6upK8+bNmT9/Pk2aNMHX15eWLVvSsmVLAFxcXIiPj2fkyJF07tyZv/76iyVLlvDyyy8bSyB7eXlxxx138PHHH6PT6YiOjmbx4sVXzOG5/PV++umniYuLw97enrvuuuuqz33ChAns37+f6dOns3r1am6//XaCgoJITU3l999/Z8uWLcYV2Pv160d4eDhjxoxhwoQJ2Nvb8/XXX+Pv709SUtI1X+PrsbOzY/bs2QwYMIAWLVowevRoQkNDOX36NKtXr8bT05M///yzyseNjY1lxYoVzJgxg5CQEKKioujcuXONYhVCCJumXSEvIazX4cOHlYcffliJjIxUnJycFA8PD6V79+7Kxx9/XG6xveLiYmXKlClKVFSU4ujoqISFhV1z0cP/qqgc61dffaU0bNhQsbe3r3DRw4oYFj309vZWXFxclE6dOlV70UODM2fOKM8++6zSpEkTxcXFRXFzc1NiY2OVqVOnKtnZ2cb9SktLlRdeeEGpX7++4ubmpsTFxSmJiYlXLe1bUflbw6KHFSkqKlLeeecdpUWLFoqzs7Pi4+OjxMbGKlOmTCkXB2WLHv7Xf+NQFEV54403lNDQUMXOzq7SZX5feeUVBVAaNWp0xX07duxQ7r77biU8PFxxdnZWAgIClFtuuUXZtm3bFbFcXmb3etasWaMMHjxYqV+/vuLo6KiEh4crDz/8sHLixIkK9//++++NC3C2bdtWWbZs2RWlfRVFUTZs2KDExsYqTk5O1130MDAwUJk8ebKxRLRBRkaGMnz4cMXNzU3x8fFRHnnkEWXfvn1XvMdKSkqUp556SvH391d0Ol2ly/z+8ssvSr9+/RRfX1/FwcFBCQ4OVkaMGKH8888/5fbbvn270rlzZ8XJyUkJDw9XZsyYcc1FD//LUNp3wYIFFcaxc+dOZdiwYYqfn5/i7OysREREKHfeeaeycuVK4z6G0r6G0scGFcVx8OBBpVevXoqrq6sseiiEEIqi6BRFZtYJIYSAUaNG8csvv1Q4LEkIIYQwB5kzIoQQQgghhNCEJCNCCCGEEEIITUgyIoQQQgghhNCEzBkRQgghhBBCaEJ6RoQQQgghhBCakGRECCGEEEIIoQlZ9NAC9Ho9Z86cwcPDA51Op3U4QgghhKgERVG4cOECISEhVV5AVghROZKMWMCZM2cICwvTOgwhhBBCVENycjINGjTQOgwhaiVJRizAw8MDUP+YeXp6ahyNEEIIISojJyeHsLAw4/9xIYTpSTJiAYahWZ6enpKMCCGEEDZGhlgLYT4yAFIIIYQQQgihCUlGhBBCCCGEEJqQZEQIIYQQQgihCUlGhBBCCCGEEJqQZEQIIYQQQgihCUlGhBBCCCGEEJqQZEQIIYQQQgihCUlGhBBCCCGEEJqQZEQIIYQQQgihCUlGhBBCCCGEEJqQZEQIIYQQQgihCUlGhBBCCCGEEJpw0DoAIa5KUaAgC0oKwdUHHJy1jkiIuqekEAqywc5B/RzqdFpHJIQQohaRZERYF0WBY//Arh/g2L+Ql67errOD+k2h2S0QOwq8GmgZpRC124U02PkdHPgD0g+AvkS93dUHonpDm7uhSZwkJkIIIWpMpyiKonUQtV1OTg5eXl5kZ2fj6empdTjWK+0ALH0eTq7/zx064LK3qb0TdBoLN74Kjq6WjFCI2q2kCNbNgPUfQXH+tfcNbgO3fAih7S0SmhBakP/fQpifJCMWIH/MKmHbNxD/IpQUgIMLtL0XWt2uXvA4ukFuGhxfC9u/uZSs1G8Cd82D+o21jV2I2uD8SfhlNJzerv4cGgsdHoSGN4BnqPrZTNsP+3+D7XOgKBd09nDTJOj+jPSSiFpJ/n8LYX6SjFiA/DG7BkWBFa/B+g/VnxvdDLd+ePVhWIoCh5fBn89Abqo6bOSuHyGiq4UCFqIWSjsA3w1Rk34XLxg0A1oOv3qCkXcW/poI+xaqP8eOgoHTwV5G/oraRf5/C2F+Uk1LaEdRYNnLlxKRG/8H9/x87fkgOh007Q+ProPQDnDxPHw/HE5ts0jIQtQ6afthzkA1EQlooX62Wt1+7Z4O9/pw+9cw4D1Ap/aULH5G/UwLIYQQVSDJiNDOxk9g02fq9i0fQq/nwa6Sb8l6/jDyT3UISXGempBkHDJXpELUTtmn4fvb1aQ+tAOMXgLe4ZV/fOexcMcctcDEzu9h+SSzhSqEEKJ2kmREaONQPPz9qrrdbyp0GF31Yzi5wYgfoEFHtQTwT/dCQY5JwxSi1iougB/vggtn1Ep19/2iDnusqhZD4LZP1O0NM2HPApOGKYQQonaTZERYXvYp+P1RdbvjQ9D1ieofy7meOmfEMxTOHYE/HpehIkJUxt+vQuoecPODexdULxExaHcv9HxO3V70lDr0SwghhKgESUaEZelLYeHD6rCQ4LYQ91bNq/DU84c7v1VL/ib8CbvmmSRUIWqthMWw9St1e+iX4BNR82P2eQWib4SSi/DrI2qZYCGEEOI6JBkRlrXlS0jaAE4e6gRYU62q3qAD9HlZ3Y5/Ue19EUJcKT8TFo9Tt7s9DY37mua4dvYw9Atw9YW0vbDmPdMcVwghRK0myYiwnKwkWPmGut3vDfCLNu3xuz6lTsItzIE/x8lwLSEqsvx/kJcB/jFqBTtTqhcAg95Xt9dOh9S9pj2+EEKIWkeSEWE5Syeola/Cu0L7kaY/vr0DDPlcHa6VuBwOx5v+HELYshPr1KpXALfOBAcn05+j5XBodhsopbB0ojQKCCGEuCZJRoRlJK5UkwM7R7j1o8qX8K0q/yaXJsTHv6hWDBJCgF6vfiZAXVk9vLP5zhX3Fji4qkMyDQsjCiGEEBWQZESYn7700voDnR4G/6bmPV/P58EjGM6fgE2fmvdcQtiKPfPVYVPOntDnVfOeyzsMeo5Xt//+HxTlm/d8QgghbJYkI8L8dv8EafvA2Qt6TTD/+ZzrQd8p6va6j9TKXULUZcUXYVXZfK2ez4G7n/nP2e1p8ApX1zHZ9n/mP58QQgibJMmIMK/iAlj1prrd6zlw87XMeVvdDv7NoDAbNkrviKjjNn8BOafBKww6P2qZczq6QO+J6va6D6DwgmXOK4QQwqZIMiLMa9cPasuoRwh0esRy57WzhxtfUbc3fQ55Zy13biGsSVGeujI6qOWvHV0sd+42d4NvNOSfg02zLHdeIYQQNkOSEWE+pcWw7kN1u8c4y14EAcTcAsFtoCgX1n9k2XMLYS22z1GTAZ9IaHWnZc9t73Bp/Z8NH0NBtmXPL4QQwupJMiLMZ8/PkJ0E7v7Q/gHLn1+nU1eFBtj2DVzMsnwMQmipuADWl/WK9BivJgeW1mKYuqZJYbb6ORRCCCEuI8mIMA99KayboW53ewocXbWJo3E/CGgORRdgu1wIiTpm53eQm6rOFWlztzYx2Nmpk9lBHTJZUqhNHEIIIaySJCPCPA4ugXOJ4OKtrmmgFZ1OLoRE3aTXq+95UD8D5ljgsLJa3aGW285NVXtMhRBCiDKSjAjz2PyF+r3jGHD20DaWlsPBMxRy09S1FoSoCxKXQ+ZRtaR223u0jcXBCbo8rm5vmKkmSkIIIQSSjAhzSN0LJ9eBzh46jNE6mvIXQptmgaJoG48QlrDpM/V7+/vVtXe0FjtKXXDx7GE4tkrraIQQQlgJSUaE6W0uK+HZfDB4hWobi0G7+8DBFdL3Q9ImraMRwrzSE+DYP6Czg05jtY5G5eJ5qYdmqyyCKIQQQiXJiDCtvHOwZ4G6banF1SrD1Rta36Fub52taShCmJ1hrkjTgeAToW0slzP0lB6Oh6wkbWMRQghhFSQZEaa181soLYTgthDWSetoyjNcCB34A3LTtY1FCHMpyIG9VtggAODfBKJ6gaJX1z8RQghR50kyIkxHUWDHd+p2x4fUSlbWJKQtNOgI+mLY8a3W0QhhHvt/heJ88GsMkT20juZKHR9Sv+/4VqrbCSGEkGREmNDJDWr1Hqd60GKo1tFUzHAhtH2OVPQRtZMh0W7/gPU1CIA6dMwjGPIyIOFPraMRQgihMUlGhOnsLOsVaTHUOqr3VKT5EHDxguxkOLFG62iEMK3UfXB6O9g5aLfI4fXYO0K7+9XtXfO0jUUIIYTmJBkRplGQDft/V7fbP6BpKNfk6KKuOwJyISRqH0ODQNOBUM9f21iupc1d6vdjqyHnjLaxCCGE0JTNJSOffvopkZGRuLi40LlzZ7Zs2XLN/RcsWEBMTAwuLi60atWKpUuXlrtfURQmTZpEcHAwrq6u9O3blyNHjhjvP3HiBGPGjCEqKgpXV1eio6OZPHkyRUVFZnl+NmvfQii5CPWbqvMyrFnbe9XvBxapk32FqA2KCy4t6tl+pLaxXI9fNIR3VSeyy0KkQghRp9lUMjJ//nzGjx/P5MmT2bFjB23atCEuLo709IorI23YsIG7776bMWPGsHPnToYMGcKQIUPYt2+fcZ93332XmTNnMmvWLDZv3oy7uztxcXEUFBQAcPDgQfR6PV988QX79+/ngw8+YNasWbz88ssWec42Y+f36vf291vnOPXLhcZC/SZq8nTgD62jEcI0Di2Fi+fBswFE99E6muszrDmya54sRCqEEHWYTlFs579A586d6dixI5988gkAer2esLAwnnrqKV588cUr9h8xYgR5eXksXrzYeFuXLl1o27Yts2bNQlEUQkJCeO6553j++ecByM7OJjAwkDlz5nDXXXdVGMd7773H559/zrFjxyoVd05ODl5eXmRnZ+Pp6VnVp239zibCJ7HqOPXxB617eIjBug9gxWsQ3g0e/EvraISouR/vgUNLoMd46DtZ62iuryAH3i9rFHhoJTTooHVEQlyh1v//FsIK2EzPSFFREdu3b6dv377G2+zs7Ojbty8bN26s8DEbN24stz9AXFyccf/jx4+Tmppabh8vLy86d+581WOCmrD4+vrW5OnULvt+Ub9H32gbiQhA6xHq6tRJGyCzckmlEFYrPxOO/K1ut75T21gqy8UTmt2qbu/6QdtYhBBCaMZmkpGzZ89SWlpKYGBgudsDAwNJTU2t8DGpqanX3N/wvSrHTExM5OOPP+aRRx65aqyFhYXk5OSU+6q1FOXSAmstb9c2lqrwDIGGZUNZDCvGC2GrEhap6+cEtoSAZlpHU3mGoVr7foUSmYcnhBB1kc0kI9bg9OnT9O/fnzvuuIOHH374qvtNmzYNLy8v41dYWJgFo7SwlN1wLhEcXCFmoNbRVE2rsuRp30IZsy5smyGhbnWHtnFUVVQvcA+Agiw49o/W0QghhNCAzSQj9evXx97enrS0tHK3p6WlERQUVOFjgoKCrrm/4XtljnnmzBn69OlDt27d+PLLL68Z60svvUR2drbxKzk5+fpP0FYZekWa9gdnD21jqaqYQWDvBGcPQfoBraMRonqyT8HJ9eq2oWy1rbCzhxZD1O19CzUNRQghhDZsJhlxcnIiNjaWlStXGm/T6/WsXLmSrl27VviYrl27ltsfYPny5cb9o6KiCAoKKrdPTk4OmzdvLnfM06dPc8MNNxAbG8s333yDnd21XzZnZ2c8PT3LfdVKer06vAJsa4iWgYsXNLpZ3TY8DyFszb6FgAIR3cHbBnthWwxTvx9copYnFkIIUafYTDICMH78eL766ivmzp1LQkICjz32GHl5eYwePRqABx54gJdeesm4/zPPPEN8fDzTp0/n4MGDvPbaa2zbto0nn3wSAJ1Ox7hx43jzzTdZtGgRe/fu5YEHHiAkJIQhQ4YAlxKR8PBw3n//fTIyMkhNTb3qnJI6JWkDXDgDzl7Q+Gato6melmUXQvt/laFawjYZehRa2WCDAEBYZ/AIgaILkLhC62iEEEJYmIPWAVTFiBEjyMjIYNKkSaSmptK2bVvi4+ONE9CTkpLK9Vp069aNefPm8eqrr/Lyyy/TuHFjfv/9d1q2bGncZ+LEieTl5TF27FiysrLo0aMH8fHxuLi4AGpPSmJiIomJiTRo0KBcPDZUFdk8DBdBzW8FB2dtY6muJv3V+S6Zx9T5LyFttY5IiMrLPK6+b3V20Ow2raOpHjs7tVFg4ydqo0CzW7SOSAghhAXZ1DojtqpW1inXl8L0ppCXAff9Co1u0jqi6vv5AXXxw25PQ783tI5GiMpbPxOW/w8ie8Koxdff31qd2g6zbwRHN5iQCE7uWkckBFBL/38LYWVsapiWsCLJW9RExMVLrYhjywxj1vf/LkO1hG1J+FP93nywtnHUVGh78I6A4vxL66UIIYSoEyQZEdVjuAhqOhDsHbWNpaYa91OHamUnQeperaMRonJyzsCpLep2jI0PbdLpLiVUB5doG4sQQgiLkmREVJ2iXEpGbP0iCMDJ7dIws4M2PNRF1C0JZe/VsM7gGaxtLKZg+Fty+G9ZAFEIIeoQSUZE1aXsVnsRHN0g+katozGNmEHqd2mVFbYiYZH63VYnrv9Xg47qAoiF2XByndbRCCGEsBBJRkTVGXoPGvVVexVqgyb9QWcPafvUCkVCWLO8s5cWOmx2q7axmIqdHcQMVLcTpIdSCCHqCklGRNUZhmjVlosgADdfiOimbkvviLB2B5eAoofgtuAToXU0pmMYqnVoqbqoqhBCiFpPkhFRNRmHIeMg2DmqE79rE8OFkCQjwtod+kv9XtvW5IjqBU4ecCEFzuzUOhohhBAWIMmIqJpDS9XvUb3A1VvTUEzOMG8keRPkZmgbixBXU3wRjv2jbjcZoGkoJufgDI1vVrelmIQQQtQJkoyIqjm8TP3etJZdBAF4h0FwG3X4y+G/tI5GiIodXwMlF8GzAQS20Doa0zMWk5BkRAgh6gJJRkTl5WdC8mZ1u7YN0TIwjlmXZERYqcPx6vcmcer6HLVN45vVYaBnD8O5o1pHI4QQwswkGRGVd3QVKKXg36x2TZq9nCHJOvYvlBRqG4sQ/6Uotbt3EsDFCyK6qttHlmsbixBCCLOTZERUnuEiqEmctnGYU3AbqBcExXmXSqcKYS1S90LOaXWNn8ieWkdjPo3L/sYcWaZtHEIIIcxOkhFROfpSSCxrpazNyYhOB437qtvSKiusjaFBoOEN4OiiaShmZeihPLEOivK0jUUIIYRZSTIiKufUVrh4Hly8oUEnraMxL8OF0JG/tY1DiP+6fL5IbVa/MXhHQGmROmFfCCFErSXJiKgcQ4tso75g76BtLObWsA/YOcC5RJlAK6xHbjqc3q5uN67lyYhOd6lR4LAM1RJCiNpMkhFROXVhvoiBiyeEywRaYWWOLAcUddV1z2CtozE/Yw/lcnXivhBCiFpJkhFxfVnJkL4fdHZqz0hdIEO1hLVJXKF+NywKWNtF9gAHF8g5BekJWkcjhBDCTCQZEddnuAhq0BHcfLWNxVJkAq2wJvpSOLZa3Y6+SdtYLMXJDaJ6qdvSKCCEELWWJCPi+o6uUr/XlV4RAP+m4B0OpYUygVZoL2WXWkDC2RMadNA6GsuRHkohhKj1JBkR16YvheP/qtvRN2obiyVdPoFW5o0IrSWWNQhE9QJ7R21jsSTDkLSkTVCQrW0sQgghzEKSEXFtZ3aqFwEuXhDSTutoLMuQfBmGxwihlaMr1e91qUEAwCcSfBuCUqoOmRRCCFHrSDIirs0wRCuqN9jZaxuLpUX2AJ09ZB6D8ye1jkbUVQU5kLxF3W5UR+aLXK5hH/X7UWkUEEKI2kiSEXFthmSkrrXIgtobZBifL70jQivH16g9A77Rak9BXRNdlozIZ1AIIWolSUbE1V3eImu4IKhrpFVWaM0wRKsu9ooARPZUy4qfS1TLjAshhKhVJBkRV3dibd1ukYVLSdjxf9XJ/EJYWl3unQRw9YbQWHVbekeEEKLWkWREXJ3xIqiO9oqAehHk7KmWVU3ZrXU0oq45dxTOnwA7R7WHoK4yJGLSQymEELWOJCPi6gz/+OtqiyyoZVQNF4HSKisszdAgEN4FnOtpG4uWGl7eQ6nXNhYhhBAmJcmIqNj5E5B5VK0mVZdbZOFSz5C0ygpLO/aP+r0u906CWkjCyQPyz0HqHq2jEUIIYUKSjIiKGS68wzqBi6e2sWjN0CqbvBmK8rWNRdQd+lJ13hZA1A1aRqI9e0e11DZID6UQQtQykoyIitX1SbOX84sGrzAoLYKTG7SORtQVqXvVBUedPSG4jdbRaE96KIUQolaSZERcSa+/rEW2t7axWAOdDhreoG4bkjQhzO34GvV7RHewd9A2Fmtg6KFM2ig9lEIIUYtIMiKulL5frR7l6A6h7bWOxjoYS/yu0TYOUXcY3mtRvbSNw1rUbwyeoWoPZfJmraMRQghhIpKMiCsdL+sVCe+ijtUWlybxp+2D/ExtYxG1X2nxpSGBkoyodLpLn0NDz60QQgibJ8mIuJJxiJZcBBnVC4D6TQEFTq7XOhpR253eAcV54OoLAc21jsZ6GCaxn1inbRxCCCFMRpIRUZ6+FE6UXWxH1fGSvv9leD2OS6usMDPjEK2eYCd/po0Mn8HT26EwV9tYhBBCmIT8lxPlpe6BwrIKPkFSwaccGSIiLOX4v+p36Z0szycSvMJBXwLJm7SORgghhAlIMiLKM7T6R3STCj7/ZRgikn4A8s5qG4uovYovQvIWdVuq2V1JeiiFEKJWkWRElGcYHlLXV12viHv9S+P3Zcy6MJfkLVBaCB7B4NdI62isj8wbEUKIWkWSEXFJabFawx9kvsjVyFAtYW6Xl/TV6bSNxRoZPoNndkLhBW1jEUIIUWOSjIhLzuyColxw8YbAVlpHY52kVVaYm6wvcm3eYercEaUUTm7UOhohhBA1JMmIuOSEYYhWD6ngczWRPQAdZByE3HStoxG1TeEFtVIUSDJyLcYeSlmEVAghbJ1ccYpLjsv6Itfl5guBLdVtGaolTC1ps9ri7x0B3uFaR2O9jMmI9FAKIYStk2REqEqKIHmzui2T168tSi6EhJkYFtQ0DAcUFTN8BlN2Q0G2trEIIYSoEUlGhOr0dijOB7f6ENBM62ism+FCUUqLClM7uUH9Ht5V2zisnWcI+EaDor/0mgkhhLBJkowIlbFFtrtU8LmeiG6ADs4dgZwUraMRtUXxxUvzRSK6aRuLLZD1RoQQolaQZESojC2ychF0Xa4+ENxa3TYkcULU1OntoC+GekHg21DraKyfYTjpSRkuKYQQtkySEQH60ksrPkuLbOUYkrYkKS0qTMTQIBDRTXonK8Pwtyp1LxTkaBuLEEKIapNkRKj/zIsugLMnBLbQOhrbEFE2pl/WORCmYuhlkwaByvEMUauOKXo4tUXraIQQQlSTJCPiUut+WGews9c2FlthmGCcfgAuntc2FmH7Sosv653srm0stsSQuEmjgBBC2CxJRsRlw0Okgk+l1QsAv0aAoq4NIURNpOxWq9m5+oB/jNbR2A5Do4AMlxRCCJslyUhdpyiX/pHL5PWqMV4ISWlRUUOGIVrhXcFO/ixXmqFn5NQ2KCnUNhYhhBDVIv/16rpzRyEvA+ydIbS91tHYFhkiIkzl8snrovL8GoG7P5QWwpmdWkcjhBCiGiQZqesMLbINOoCDs7ax2BpDz8iZneoaEUJUh15/qXdSkpGq0ekgvIu6LYsfCiGETZJkpK4zDtGS+SJV5hMJHsHq2hCntmkdjbBV6QegIBsc3SGojdbR2B4psy2EEDZNkpG6TiavV59OJxNoRc0ZFxztDPYO2sZiiwx/u5I2q71MQgghbIokI3VZzhnIOgk6O2jQSetobJMhGZEhIqK6ZH2RmglsBU71oDBb7WUSQghhU2wuGfn000+JjIzExcWFzp07s2XLtRe7WrBgATExMbi4uNCqVSuWLl1a7n5FUZg0aRLBwcG4urrSt29fjhw5Um6fqVOn0q1bN9zc3PD29jb1U9KO4QI6qBW4eGobi60ytMqe2gqlJdrGImyPolzWMyLJSLXYO0CDjuq29FAKIYTNsalkZP78+YwfP57JkyezY8cO2rRpQ1xcHOnp6RXuv2HDBu6++27GjBnDzp07GTJkCEOGDGHfvn3Gfd59911mzpzJrFmz2Lx5M+7u7sTFxVFQUGDcp6ioiDvuuIPHHnvM7M/RoqSkb80FNAdnLyjKhdQ9WkcjbM25o5CXDvZOEBqrdTS2y1jZTnoohRDC1thUMjJjxgwefvhhRo8eTfPmzZk1axZubm58/fXXFe7/0Ucf0b9/fyZMmECzZs144403aN++PZ988gmg9op8+OGHvPrqqwwePJjWrVvz7bffcubMGX7//XfjcaZMmcKzzz5Lq1atLPE0LeekVPCpMTt7daw/SKusqDrDeyY0FhxdtI3Fll0+d0tRtI1FCCFEldhMMlJUVMT27dvp27ev8TY7Ozv69u3Lxo0VXwRu3Lix3P4AcXFxxv2PHz9OampquX28vLzo3LnzVY9Za+RnQvp+dVsqadWMzBu5QkmpnmMZuWw5nsmKA2msOpjGxqPnSEzPpahEJhkbJW9Wv4d11jYOW9egA9g5woUUOH9C62isRmZeEbuSs1hzOIO/96ey9kgGu5KzOJ9XpHVoQghhZDOlW86ePUtpaSmBgYHlbg8MDOTgwYMVPiY1NbXC/VNTU433G2672j7VUVhYSGHhpdWAc3Jyqn0sszFcBPk1hnr+2sZi6ww9S0mb1FZZnU7beDSg1ytsOn6Ofw9nsD7xLIdTcykqrTjpsLfT0STQgy4NfbmhaQDdo/1wsLeZdhHTkmTENBxdIaQdnNqi9o74RmkdkSZSswtYfiCVNUfOsjPpPGdzr550+Lk70THSl26N/OjfIogAT+mZE0Jow2aSEVsybdo0pkyZonUY1yYlfU0npJ26gn3+WTh7BPybaB2RxaRfKOD7TUks3H6K01nlF350dbQn2MsFDxcHFCCvsISU7ALyi0pJSMkhISWHb9afoH49Z4a3D2V09yiCvOrQBVF+Jpw9rG5LMlJzEV3VZOTkBmh7j9bRWIxer7A8IY0ftySx5nAG+v+MUgv2csHL1REXR3sKiks5n19EWk4h5/KKiN+fSvz+VF5btJ/ujeozunskfZoGoKuDDSpCCO3YTDJSv3597O3tSUtLK3d7WloaQUFBFT4mKCjomvsbvqelpREcHFxun7Zt21Y71pdeeonx48cbf87JySEsLKzaxzOL5LIqZDJEq+YcnNVhIifXq62ydSAZOZtbyOf/HOWHzScpKFZ7QDxdHOjbPJDeTfxpH+5DqLcrdnblL2oURSElu4AdSedZn3iWZfvTOJtbyBdrjvH1+uMMa9eAZ29uUjeSEsNn0K8xuPtpG0ttEN4N1n+k9lDWAYqi8Ne+VGauPMLB1AvG2ztE+NAnJoCu0X40DfTA3fnKf/P5RSUkpFxg07FzrExIY0dSFmuPnGXtkbPEBHkwrm8T4loESlIihLAIm0lGnJyciI2NZeXKlQwZMgQAvV7PypUrefLJJyt8TNeuXVm5ciXjxo0z3rZ8+XK6dlUvwKOioggKCmLlypXG5CMnJ4fNmzfXqHKWs7Mzzs7O1X682ZUUwpmd6ra0yJpGWGc1GTm1BWJHah2N2ZTqFX7YfJL3lh3iQoFayrhtmDcP9oiiX/NAXBztr/l4nU5HiLcrId6u3NI6hNcH61l9MJ3Z646z5Xgm87cl8+eeMzzRpxEP9YzC2eHax7NpMkTLtMLK1ko6d0TtdXLz1TYeMzqSdoFXf9/H5uOZAHg4O3Bf1whGdAgjsr77dR/v5uRAbIQPsRE+PNGnESfP5fHD5iR+2HSSg6kXePT77XSL9uO121rQJNDD3E9HCFHH2UwyAjB+/HhGjhxJhw4d6NSpEx9++CF5eXmMHj0agAceeIDQ0FCmTZsGwDPPPEPv3r2ZPn06gwYN4qeffmLbtm18+eWXgHphNG7cON58800aN25MVFQU//vf/wgJCTEmPABJSUlkZmaSlJREaWkpu3btAqBRo0bUq1fPoq+BSaTsgdJCcPMD34ZaR1M7GC4ok6+97o0tO342j3Hzd7E7OQuAlqGeTIyLoWfj+tVuQXW0t6NfiyD6tQhi24lM3lqawI6kLN5bdog/d5/hgxFtaRZcS9fAMSQj4ZKMmISbL9Rvog59O7UVmsRpHZHJleoVPludyEcrj1CiV3BxtGNsr2jGdI/Cy82x2seN8HPn5YHNeOKGRny19hhfrj3GhqPnGDRzLeNvbsrYXg2xt5NeEiGEedhUMjJixAgyMjKYNGkSqamptG3blvj4eOME9KSkJOzsLk2E7datG/PmzePVV1/l5ZdfpnHjxvz++++0bNnSuM/EiRPJy8tj7NixZGVl0aNHD+Lj43FxuTRMZNKkScydO9f4c7t27QBYvXo1N9xwg5mftRlc3iIr3fCmYVh07ezhWtcqqygKC3ecZtIf+8gvKsXDxYGJcU25p3OESS9QOkT6svCxbvyx6wxvLD7AwdQLDP5kPS8OiGF098jaNWSktBhOb1e3pWfEdMI6qZ/B5M21Lhk5k3WRZ+fvMvaG9G0WyORbmxPm62ayc3i5OfJ8XFNGdAxjyp/7WZGQzjvxB1l1MI2P725fN4ZPCiEsTqcoUpTd3HJycvDy8iI7OxtPTyto5Z1/PyQsgr6vQY9ntY6m9vi4gzpE5J6fa82FUHGpnkl/7OfHLUkAdI7y5cO72hLs5WrW82ZcKOSlX/ewIkFd0HRou1CmDWt13WFgNuPUdph9I7j6wIRjYFdHq4mZ2o5vYdFTENkTRi3WOhqT2XI8k0e+28b5/GLcnex5Y0hLhrVvYNZzKorCgu2neP3PA+QWluDv4cys+9oTG1F7Gloqw+r+fwtRC8l/wLpGUS4NJZIWWdMyDtXarG0cJpKdX8zIr7fw45YkdDoYf3MT5j3cxeyJCIC/hzNfPdCBybc2x95Ox287T3P7rA2k5xSY/dwWYXiPNOgkiYgpGT6Dp7ervU+1wIJtydw7exPn84tpGerJkqd7mj0RAXUY850dwljydA+aBnqQcaGQu77cxIJtyWY/txCibpH/gnVNdjLkpoKdg1qSVpiOYQJtLZg3kppdwLDP17Ph6DncnOz56v4OPH1TY4uOG9fpdIzuHsX3Yzrj6+7EvtM53D5rIyfP5VksBrNJLqv4JPNFTMuvMbh4QXE+pO3TOpoaURSFmSuPMOGXPRSXKgxsFcSCR7pVaoK6KUX4ufPr490Y0DKI4lKFCb/s4Yt/j1o0BiFE7SbJSF1juFAObqMuFCZMp5a0yiZn5nPnFxs5mpFHsJcLvzzajb7NA6//QDPpGu3H7493J8LPjaTMfIZ/vpGEFCtcSLSypHfSfOzs1N4msOlGAUVReCf+EDOWq+vQPNEnmk/ubo+rkzbDFN2dHfjs3vY80lsteDLtr4NM+ysBGeUthDAFSUbqGiknaj71m9h8q+yJs3mM+GIjSZn5hPu6seDRrjQP0X6cdLifGkuzYE/O5hZyz1ebOHTZ2go2JSsJLqSU9U621zqa2sfGh0sqisKUPw8wq6z34dVBzZgQF3PFmj2WptPpeGlAM14aEAPAF/8eY9pfByUhEULUmCQjdY0xGemkbRy1kY23yp7Jusg9X23iTHYB0f7u/PxIVxr4mK5ST00FeLjw09gutGngxfn8Yu6dvZljGblah1V1l/dOOlnP61tr2PhwybfjDzJnwwkA3hzSkod6Wlf59Ud6R/PW0FYAfLnmGB+U9d4IIUR1STJSlxTmQmpZi30DSUbMwkZbZTPzirj//zZzJruAhv7u/DS2q1WW8fRydWTug50u6yHZTHJmvtZhVY1hvoj0TppHaCzo7NT5cdmntY6mSmb9e5Qv/j0GwDvDW3FflwiNI6rYPZ3DmXJbCwBmrkrks38SNY5ICGHLJBmpS87sAKUUvMLAK1TraGonG2yVzS0sYfQ3W4xzRL4b0xl/D2etw7oqbzcnvh/TicYB9UjNKWDUN1vIzrehOToyVNK8nOtBYNlaUqds53M4f2sSb/91EICXB8YwomO4xhFd28hukcYhW+/GH+K3nac0jkgIYaskGalLZIiW+dlYq2ypXuGpeTvYfSobHzdHvhvTiVBv6y9s4FfPme/GdCbYy4WjGXk88v02CktKtQ7r+govQNp+dVuSEfMx9lDaRjLy7+EMXvp1LwCP9o5mbK9ojSOqnEd6R/NobzXWib/sYePRcxpHJISwRZKM1CVSwcf8nOtBoDp8wRZaZd/+K4HVhzJwdrDjm9GdaBTgoXVIlRbk5cLXozpSz9mBTccyeXHhXuufTHtqGyh68A4Hz2Cto6m9bGi4ZGJ6Lk/O24FegdtjG/BC/6Zah1QlE+OaMqh1MMWlCo98t43EdBstLCGE0IwkI3WFXn9ZMiI9I2ZlI62yP29L5qu1xwGYfmcb2oZ5axtQNTQL9uSze9sbF0b87B8rX/9AhmhZhuFvXMpuKL6obSzXkJVfxENzt3KhoISOkT5MHdoSnU7bqllVZWenY/odbYiN8CGnoIQH52yzrWGTQgjNSTJSV5w7AgVZ4Oh2aTy1MA8baJXddiKTV35Th4U8fVNjbmkdonFE1deriT+vD1Z7o6b/fYg1hzM0jugaJBmxDO9wqBcE+hI4s1PraCpUUqrn8R92cOJcPqHernx+XyzODtqsI1JTLo72fPVABxr4uJKUmc+4+TvR6628l1IIYTUkGakrDBdBobFg76htLLWdlbfKns0t5Il5O4yrOo+7qbHWIdXYvZ0jGNEhDL0CT/+00zorbOlL1WFaIMmIuel0lxWTsM5GgRnLD7Ph6DncnOz5v1EdqF/PeotGVIavuxOz7ovF2cGO1Ycy+GjlEa1DEkLYCElG6grDP+QGHbWNoy7wjoB6gVbZKluqV3h2/i7ScgqJ9nfnvdvbaL6YmqlMGdyC1g28yMov5rEftlNQbGUT2s8ehsIccHS/NK9ImI8VV7ZbfSjdOKTwneGtiQnSfmFRU2gZ6sXUsjVIPlp5hJUJaRpHJISwBZKM1BUyed1yrLhV9tPViaw9chYXRzs+vy8Wd2cHrUMyGRdHez6/LxZfdyf2nc5h6pIErUMqz9ArEtoe7GxzOI5NuXy4pBUVNjiTdZFn5+8C4IGuEdzaxnaHSFbk9tgG3F+2PspzC3aTkm19vcNCCOtSe65ExNXlZ6qtsiA9I5YS1hkS/oTkrVpHYrQh8SwfrFDfB28OaUWTQNupnFVZod6ufDCiLSO/3sJ3m07Ss3F9+rUI0jos1amy90JorLZx1BXBbcDeCfLPQeYx8NO+XG5xqZ4n5+0gK7+YVqFevDKomdYhmcX/bmnOruQs9p7OZtxPu5j3cBfsa0kPbG1QWlpKcbEUGRDm4+joiL195RvdJBmpCwwtsn6Nwd1P21jqiv+2ympcIScrv4hnf96FosCdHRpwe2wDTeMxp95N/HmoRxSz1x1n4sI9tG7gbR2ryZ/ern5v0EHbOOoKB2cIaad+BpO3WEUy8vHKI+xIysLDxYHP7m1vsxPWr8fJwY6Zd7dj0My1bD6eyef/JPLkjbY/N83WKYpCamoqWVlZWoci6gBvb2+CgoIqVSFQkpG6QCr4WJ6xVfas5q2yiqLwyu/7SMsppGF9d6bcVvurqU3o35SNx86x/0wOz87fxfcPdda2ZbYwF9IPqNuhkoxYTFinsmRkM7S9W9NQdiSd55PViQBMG9aKMF83TeMxt6j67ky5rQUTftnDByuO0DW6PrERPlqHVacZEpGAgADc3Nxsroy0sA2KopCfn096ejoAwcHXX1OrWslIUlISJ0+eJD8/H39/f1q0aIGzs21XAqnVDMNDpEXWchyc1YTk1Fa1RVzDZGTR7jMs2ZOCvZ2OD0a0xdWpdrbGXs7ZwZ6Zd7fjlpnr2HjsHLPXHuOR3hq2jJ/ZqS526NlAFju0JMOw1NPbNA0jv6iE8fN3oVdgSNsQmy6lXRW3xzZgzZGz/Ln7DOPm7yT+mV61ap6aLSktLTUmIn5+MkJCmJerqysA6enpBAQEXHfIVqUnsJ84cYIXXniBiIgIoqKi6N27NwMGDKBDhw54eXlx8803s2DBAvR6fc2egTAtfSmc3qFuy3wRyzK0gJ/Sbt7ImayL/O/3fQA8fWNj2tjgwobVFe1fj9duaw7A9OWHtV0Z2nAx3EDmi1iU4TOYth+K8jQLY+qSBE6cyyfYy4Upg2t/z6SBTqdj6tCWhHq7kpx5kbf/Oqh1SHWWYY6Im1vt7pET1sPwXqvM/KRKJSNPP/00bdq04fjx47z55pscOHCA7OxsioqKSE1NZenSpfTo0YNJkybRunVrtm61nkm7dd7Zw1B0QS0nGlA7J0tarQbaJiN6vcKEX3aTU1BCmzBvnuij/Zh5S7uzQxg3NPWnqETPcwv2UFKqUWOJYd6WNAhYllcoeISovVIaldlefSidHzYnAfD+HW3wcq1b6zx5ujjyzvDWAHy36SQbEs9qHFHdJkOzhKVU5b1WqWTE3d2dY8eO8fPPP3P//ffTtGlTPDw8cHBwICAggBtvvJHJkyeTkJDA+++/T3JycrWDFyYm5US1Y7jwTN2ryeKHP2xJYn3iOVwc7fjgzjY42Ne9St46nY63h7XGw8WB3clZfLn2mOWDUJTLPocyVNLijI0Clh+qlVNQzIsL9wDwYPcoujeqb/EYrEGPxvW5t3M4ABN+2UNuYYnGEQkhrEmlrk6mTZtW6TGG/fv3Z9iwYTUKSpiQlBPVjnc4uPurix+m7LHoqVOyL/JO2ZCIF/rH0NC/nkXPb02CvFyYfKu6yOCHy49wOM3Cw7VyTkNuKujs1XlEwrI07KGctvSgsXDExP5NLX5+a/LSwGY08HHldNZF3lpqZWsACWFi//zzDzqdTiqXVZJJmkpzcnL4/PPP6dBBWv2sjpQT1Y5Od6l3xIIXQoqi8Opv+8gtLKF9uDcPdI202Lmt1fD2odwUE0BRqZ4JC3ZTqrfgIniGFvmgluAk47UtzvgZ3GbRxQ83HTvHj1vU4VnThrXCxbFu90zXc3bg3dvV4VrzNiexXoZriUpKTU3lqaeeomHDhjg7OxMWFsatt97KypUrTXqeG264gXHjxpn0mNezc+dO7rjjDgIDA3FxcaFx48Y8/PDDHD582KJxVIU5Eq0aJSOrV6/m/vvvJzg4mDfeeIPOnaV0rFWRcqLaMySBFqzms3hPCisPpuNor+Pt4a1lsTHU4VpvDWulDtc6lc13G09Y7uTG3kn5DGoiuK3aK5WbqvZSWUBBcSkv/boXgHs6h9O5oVQvAugWXd+4Ovsrv+2loLhU44iEtTtx4gSxsbGsWrWK9957j7179xIfH0+fPn144oknLB6PoiiUlJhmmOHixYvp0qULhYWF/PDDDyQkJPD999/j5eXF//73v2oft6ioqMLbrXmhyyonI6dPn2bq1Kk0atSIO+64g3nz5vH1119z+vRpPv30U3PEKKpLyolq7/JWWQs4n1fEa4v2A/BEn0a1cpX16gr0dOGF/jEAvP/3YVKyLTSPR3onteXkpvZKgcV6KD9aeYTjZ/MI9HTmxQExFjmnrZjQvykBHs6cOJfPZ2XrrghxNY8//jg6nY4tW7YwfPhwmjRpQosWLRg/fjybNm0y7peUlMTgwYOpV68enp6e3HnnnaSlpRnvf+2112jbti3fffcdkZGReHl5cdddd3Hhgjpsd9SoUfz777989NFH6HQ6dDodJ06cMPYC/PXXX8TGxuLs7My6desoLCzk6aefJiAgABcXF3r06FGl4k35+fmMHj2agQMHsmjRIvr27UtUVBSdO3fm/fff54svvgBgzpw5eHt7l3vs77//Xm5yuOG5zZ49m6ioKFxc1EV+dTodn3/+Obfddhvu7u5MnToVgD/++IP27dvj4uJCw4YNmTJlSrkES6fTMXv2bIYOHYqbmxuNGzdm0aJFgJoc9unTBwAfHx90Oh2jRo2q9PO+mkonIwsXLmTgwIE0bdqUXbt2MX36dM6cOYOdnR2tWrWSCg3WSMqJai+kHaCD7GS4kGr20725JIFzeUU0DqjHYzfUvepZ13NPp3Dah3uTW1hiTNrMqrQYzuxSt6VnRDuhlpvEvv9MNl+uUQslvDG4JZ4udat61vV4ujjy2m3qHK7P/z2qbcntOk5RFPKLSiz+pVRyuGRmZibx8fE88cQTuLu7X3G/4SJdr9czePBgMjMz+ffff1m+fDnHjh1jxIgR5fY/evQov//+O4sXL2bx4sX8+++/vP322wB89NFHdO3alYcffpiUlBRSUlIICwszPvbFF1/k7bffJiEhgdatWzNx4kQWLlzI3Llz2bFjB40aNSIuLo7MzMxKPbdly5Zx9uxZJk6cWOH9/01AricxMZGFCxfy66+/smvXLuPtr732GkOHDmXv3r08+OCDrF27lgceeIBnnnmGAwcO8MUXXzBnzhxjomIwZcoU7rzzTvbs2cPAgQO59957yczMJCwsjIULFwJw6NAhUlJS+Oijj6oUa0UqvfrQiBEjeOGFF5g/fz4eHtLaahOknKj2nD0goDmk71d/H81uMdupNhw9y8Idp9Dp4O3hrXF2qNtj1CtiZ6cO17pl5jqW7U/j7/2p9GsRZL4Tpu2Hkovg4gV+jcx3HnFtDTrCtv8ze8+IXq/w8m/7KNUrDGwVZN73lg0b0DKIm2ICWHkwnZd/3cdPY7tgJ8NJLe5icSnNJy2z+HkPvB6Hm9P1Lz8TExNRFIWYmGv3Lq5cuZK9e/dy/PhxYwLx7bff0qJFC7Zu3UrHjuo1kF6vZ86cOcZr2Pvvv5+VK1cydepUvLy8cHJyws3NjaCgKz+3r7/+OjfffDMAeXl5fP7558yZM4cBAwYA8NVXX7F8+XL+7//+jwkTJlz3uR05cgTgus+tsoqKivj222/x9/cvd/s999zD6NGjjT8/+OCDvPjii4wcORKAhg0b8sYbbzBx4kQmT55s3G/UqFHcfffdALz11lvMnDmTLVu20L9/f3x9fQEICAioctJ0NZXuGRkzZgyffvop/fv3Z9asWZw/f94kAQgzkXKi1sMC1XyKS/VM/kNt6b+3czixET5mO5etiwny5OFeDQGYvGi/ecuMGnonQ2PBru6VVrYahgaZlN1QUvF4alOYvy2Z3clZ1HN24LWyCm7iSjqdjimDW+DqaM+WE5ks2C7LAYgrVbYHJSEhgbCwsHI9Gc2bN8fb25uEhEuV2yIjI8s1pgcHB5Oenl6pc1xeoOno0aMUFxfTvXt3422Ojo506tSp3PmupbLPrbIiIiKuSESAKwpL7d69m9dff5169eoZvwy9Qfn5+cb9Wrdubdx2d3fH09Oz0q9VdVS6Z+SLL77gww8/5Oeff+brr79m3LhxxMXFoSiKrLpujaScqPVo0AF2zL00d8AM5qw/wZH0XHzdnZjQT8aoX8/TNzZm8Z4zJGde5IPlh/nfLc3Nc6JTZb9zaRDQll80uHhDQRak7VPXXTKx83lFvBOvltN+9uYmBHi6mPwctUkDHzfG39yEqUsTeGvpQfo2C8SvnrPWYdUpro72HHg9TpPzVkbjxo3R6XQcPHjQJOd1dCw/ZFKn01X6+rWiYWI10aRJEwAOHjxI165dr7qfnZ3dFYlLRRPRrxbff2/Pzc1lypQpFS7BYZhrAjV7raqjSk11rq6ujBw5kn///Ze9e/fSokULAgMD6d69O/fccw+//vqrueIUVWXoFQlsIeVEtWZolT29A0pN3wqfml3AhyvUMoAvDojBy03GqF+Pq5M9bwxWJzXP2XDCfGuPGHrDZKiktnQ6sy9++O6yQ2TlFxMT5MHIrhFmOUdtM7p7JM2CPcm+WMz7fx/SOpw6R6fT4ebkYPGvys4x9vX1JS4ujk8//ZS8vLwr7jeUlm3WrBnJycnlFtw+cOAAWVlZNG9e+YYmJycnSkuvX+EtOjoaJycn1q9fb7ytuLiYrVu3Vvp8/fr1o379+rz77rsV3m94bv7+/ly4cKHc8798TkhVtW/fnkOHDtGoUaMrvuwq2Xvv5OQEUKnXqrKqPW6gcePGvPXWWyQnJ/P999+Tn59vHF8mrMBpmS9iNeo3BWdPKM6DDNMv9jV1aQJ5RaW0C/fm9vYNTH782uqGpgHc3DyQUr3Ca4v2m7zbnIvn4Zw6LlgWHbUCxkYB0ycju5Kz+GmruqbI64Nb4mAvQ/Iqw8Hejillk9l/2prMnlNZ2gYkrM6nn35KaWkpnTp1YuHChRw5coSEhARmzpxp7FHo27cvrVq14t5772XHjh1s2bKFBx54gN69e1dp/bvIyEg2b97MiRMnOHv27FV7Atzd3XnssceYMGEC8fHxHDhwgIcffpj8/HzGjBlTqXO5u7sze/ZslixZwm233caKFSs4ceIE27ZtY+LEiTz66KMAdO7cGTc3N15++WWOHj3KvHnzmDNnTqWf039NmjSJb7/9lilTprB//34SEhL46aefePXVVyt9jIiICHQ6HYsXLyYjI4Pc3Nxqx2NQ47+YdnZ23Hrrrfz+++/lslKhMePkdRkeojk7u7KqWpi8VXZD4ln+3H0GO51auUcmgVbN/wY1x8nBjg1HzxG/z8TVzk7vUL/7RIG7rDOhuVDzzN0q1StM+mMfigLD2oXSKcrXpMev7TpF+TK4bQiKAq8t2o/ekguSCqvXsGFDduzYQZ8+fXjuuedo2bIlN998MytXruTzzz8H1B6eP/74Ax8fH3r16kXfvn1p2LAh8+fPr9K5nn/+eezt7WnevDn+/v4kJSVddd+3336b4cOHc//999O+fXsSExNZtmwZPj6Vn685ePBgNmzYgKOjI/fccw8xMTHcfffdZGdn8+abbwJq79D333/P0qVLadWqFT/++COvvfZalZ7X5eLi4li8eDF///03HTt2pEuXLnzwwQdERFS+Nzc0NJQpU6bw4osvEhgYyJNPPlnteAx0SjWaA8+cOcO6detIT08vlznqdDqeeuqpGgdV2+Tk5ODl5UV2djaenp7mP2FpMUwLU6v4PLEV/JuY/5zi2la+AWvfh7b3wRDTrMdTVKJn4My1JKbn8kDXCF4vG3YkqmbG34eYuSqRUG9XVozvjauTiaqQ/fsurJ4Kre6E4V+Z5pii+vIz4d0odXvCMZMliPM2J/Hyb3vxcHZg5fO9CfCQuSJVlZpdwI3T/yG/qJTpd7RheKz19PBa/P+3mRQUFHD8+PFy61AIYU5Vec9VegK7wZw5c3jkkUdwcnLCz8+v3Ng/SUasRPoBKSdqbYyLH5quVfbbjSdITM/Fz92J525uarLj1jWP3dCIX7af4nTWRT7/9yjjbzZR8m6cLyK9k1bBzRf8GqtD505vhyb9anzIrPwi3l2mTq4d36+JJCLVFOTlwlM3Nuad+INM++sg/VoE4iHrswhRZ1R5mNb//vc/Jk2aRHZ2NidOnOD48ePGr2PHjpkjRlFVhosgKSdqPQwXpGcPwcWsGh/uXG4hH61U5yNMiGsqk9ZrwNXJnlcGqZMOZ/17lOTM/Os8ohKktLZ1MnGZ7Y9WHiErv5gmgfW4v4tMWq+JB3tEElXfnbO5hcws+9smhKgbqnylmp+fz1133VXpWfdCA1JO1Pq41wefSHX7zI4aH+7DFUe4UFBC82BP7ugQdv0HiGsa2CqIrg39KCrR88biAzU/4PnjcDET7J0hqFXNjydMw4TJyNGMXL7beBKAVwc1l0nrNeTsYM+kshLb36xXe32FEHVDlf96jhkzhgULFpgjFmEqUknLOhmHatVsEvvhtAvM26JOrPvfLc2xl0nrNWZYhM3eTsffB9LYePRczQ5o+B0HtwYHp5oHKEzj8jLbNayZP21pAiV6hRtjAujV5MrFxkTV9YkJ4KaYAEr0Cm8tNX3lQSGEdarynJFp06Zxyy23EB8fT6tWra5YGGXGjBkmC05Uw8XzcFZdc0LKiVqZ0A6wd0GNk5E3lyRQqlfo1zyQrtFSpclUmgR6cE+ncL7bdJKpSw+w6Ike1a9OJkO0rFNAC3BwhcJsde6If/XmWq07cpYVCek42Ol4eWAzEwdZt708qBn/Hs5g1cF01h05S4/G9bUOSQhhZlXuGZk2bRrLli0jLS2NvXv3snPnTuNXTRZiESYi5USt1+WT2Ku5psXqQ+msOZyBo71cBJnDuL6N8XB2YN/pHH7bebr6BzotpbWtkr3DZWW2qzdUq1Sv8OYSdSjffV0iaBRQz1TRCSDavx73lc2/eXPJAUql1K8QtV6Vk5Hp06fz9ddfk5CQwD///MPq1auNX6tWrTJHjKIqTpfNF5EhWtYnqJU6h+BiJmRWvdhDcameqUvUoQujukUSWd/d1BHWeX71nHm8j1qB7r1lh7hYVI0VZosLIGWPui3JiPWp4Urs87cmczD1Al6ujjxzU2MTBiYMnr6pMR4uDhxMvcDC7ae0DkcIYWZVTkacnZ3p3r27OWIRpiDlRK2Xg5M6hwAuJY1VMG9zEonpufi6O/HkjXIRZC6ju0cS6u1Kak4BX62tRoXA1L2gLwa3+uAtFZasTg2SkZyCYqb/fQiAZ25qjI+7zAcyB193J54u+xv3/t+HyCss0TgiIYQ5VTkZeeaZZ/j444/NEYuoKSknav2qud5Idn4xH6xQ5wI9e3MTvFyllK+5uDja88KAGEAt9ZueU1C1A1xeQEInxQWsjuEzmL4fCqtWsenT1YmcyyuiYX137u8qiaY5PdAtgnBfN9IvFPLlGlk2QIjarMrJyJYtW5g7dy4NGzbk1ltvZdiwYeW+hIaknKj1q2Zp0Y9XXVrP4O6OUsrX3G5tHUzbMG/yi0qZsfxw1R5s7J2UAhJWyTMEPENB0cOZnZV+WHJmPt+sOwHAywOb4SilfM3K2cGeF/qrjQJfrDlKanYVGwWEEDajyn9Nvb29GTZsGL1796Z+/fp4eXmV+xIaknKi1s/QY5W6F4ovVuohp87n823ZegYvD2wm6xlYgE6n43+3qAUCft6WzMHUnMo/WHonrZ+h0uDpyg/VmrH8MEWlerpF+3FTswAzBSYuN7BVELERPhQU63m/bHicqHuSk5N58MEHCQkJwcnJiYiICJ555hnOnataCfYTJ06g0+nMVmxJp9Px+++/V2rf1atXM3DgQPz8/HBzc6N58+Y899xznD5dg8IpZjZnzhy8vb3Ncuwql/b95ptvzBGHMAW5CLJ+3uHgHgB56eok5/DO133I5RdBvWU9A4uJjfBlUKtgluxNYeqSBL59sBO66w27ys2ArJOADkLbWyROUQ0NOkLCokrPG9l/Jpvfd6kXCS8NaHb994EwCZ1OxyuDmjHssw0s3HGKUd0iaRkqjZ51ybFjx+jatStNmjThxx9/JCoqiv379zNhwgT++usvNm3ahK+vr9ZhVskXX3zB448/zsiRI1m4cCGRkZEkJSXx7bffMn369GovkVFUVIST05UN0cXFxVcsw2FtpIm1NpFyotZPp7v0+6lEq+yBM5dKzL44IEYugizshf4xONnbsfbIWdYcOXv9Bxh+p/5NwUUumqzW5cMlK1Fm+534QygK3NomhFYN5PdqSe3Dfbi1TQiKAtP+koUQ65onnngCJycn/v77b3r37k14eDgDBgxgxYoVnD59mldeecW4b0U9E97e3syZMweAqKgoANq1a4dOp+OGG24AYNSoUQwZMoQpU6bg7++Pp6cnjz76KEVFRcbjREZG8uGHH5Y7dtu2bXnttdeM9wMMHToUnU5n/Pm/Tp06xdNPP83TTz/N119/zQ033EBkZCS9evVi9uzZTJo0CYDXXnuNtm3blnvshx9+WO64hrinTp1KSEgITZs2Nfb+zJ8/n969e+Pi4sIPP/wAwOzZs2nWrBkuLi7ExMTw2WefGY9leNyvv/5Knz59cHNzo02bNmzcuBGAf/75h9GjR5OdnY1Op0On0xmfuylUKhnp378/mzZtuu5+Fy5c4J133uHTTz+tcWCiiqScqO2owryRd5cdRFHgltbBtG7gbd64xBXC/dyME5Xf+esg+uuteSC9k7YhuC3o7CE3DbKvXTp2feJZ1hzOwMFOx/P9mlgmPlHOxLimONnbsT7xHGuPZGgdTu2hKFCUZ/mvSq6zlZmZybJly3j88cdxdXUtd19QUBD33nsv8+fPR6nk8bZs2QLAihUrSElJ4ddffzXet3LlSuOSFT/++CO//vorU6ZMqeQLCVu3qv/Pv/nmG1JSUow//9eCBQsoKipi4sSJFd5f1WFQK1eu5NChQyxfvpzFixcbb3/xxRd55plnSEhIIC4ujh9++IFJkyYxdepUEhISeOutt/jf//7H3Llzyx3vlVde4fnnn2fXrl00adKEu+++m5KSErp168aHH36Ip6cnKSkppKSk8Pzzz1cp1mup1DCtO+64g+HDh+Pl5cWtt95Khw4dCAkJwcXFhfPnz3PgwAHWrVvH0qVLGTRoEO+9957JAhSVJOVEbYfhQvXUtcv7bjh6ln8OGS6CqrdStKi5J/o04uetyRxIyeHPPWcY3Db06jsbeydl8rpVc3KDwBaQukf9nXlXXBRCr1d4+6+DANzbOZwIP1nbRwthvm7c1yWCr9cf5+2/DtI9uj52dtJLXGPF+fBWiOXP+/IZcLr+Z+nIkSMoikKzZhUv8NusWTPOnz9PRkYGAQHXn8fl768Oc/bz8yMoKKjcfU5OTnz99de4ubnRokULXn/9dSZMmMAbb7yBnd312+0Nx/b29r7i2P99Tp6engQHB1/3mJXh7u7O7NmzjcOzTpw4AcC4cePKFZWaPHky06dPN94WFRXFgQMH+OKLLxg5cqRxv+eff55BgwYBMGXKFFq0aEFiYiIxMTF4eXmh0+mu+fyqq1I9I2PGjOHYsWO8/PLLHDhwgLFjx9KzZ086duxIXFwcX331FeHh4WzdupX58+cTHh5u8kDFdUg5UdsR0g7QQXYSXEircBdFUXin7CLons7hssChhnzdnXj0hmhAXQixsOQqCyHq9XB6h7oti45av0qsN7J0Xwp7T2fj7mTPU7LAoaaevLER9Zwd2H9GbRQQdUdlez5qok2bNri5uRl/7tq1K7m5uSQnJ5v0PIqimHS4datWrSqcJ9Khw6Xe+by8PI4ePcqYMWOoV6+e8evNN9/k6NGj5R7XunVr47YhYUpPTzdZvFdT6Qnszs7O3Hfffdx3330AZGdnc/HiRfz8/Kx+YkydIOVEbYeLJwQ0g/QDahIZM+iKXZbuTWX3KfUi6Gm5CNLcg92jmLvhBKfOX2Te5iRGd4+6cqezh6EwBxzdwL/iljxhRRp0hG1fXzUZKSrR894ytYLT2F7R1K/nbMnoxH/4ujvxaO+GvP/3Yd7/+xADWgbj5CDTXmvE0U3tpdDivJXQqFEjdDodCQkJDB069Ir7ExIS8PHxMfZK6HS6KxKX4uLimscL2NnZmeTYTZo0ITs7m5SUlGv2jlT2fO7uFTdUXn57bq66ntJXX31F587li+bY29uX+/ny63lD0qTX668ap6lU+5Ps5eVFUFCQJCLWQsaq2xZDadEKLoSKS/W8t0ztFXm4V0O5CLICrk72PHuzOl/g41WJXCio4J+QoXcypB3YV7lQobA0w9/KlF1QeuXv86etSZw8l0/9es481LOC5FNY3IM9ovD3cCY58yLzNp/UOhzbp9Opw6Us/VXJngE/Pz9uvvlmPvvsMy5eLF8KPzU1lR9++IERI0YYL5r9/f1JSUkx7nPkyBHy8/ONPxt6EEpLr+zd3r17d7lzbNq0iXr16hEWFlbhsXNycjh+/Hi5Yzg6OlZ47MvdfvvtODk58e6771Z4f1ZWlvF8qamp5RKS6pYkDgwMJCQkhGPHjtGoUaNyX4ZJ/ZXh5OR03edXXdKsUBtIOVHbc42KWj9tTebEuXzq13PioZ4NLRyYuJo7YhvQ0N+dzLyiileENvZOSoOATfBrBM5eUFIAafvL3ZVbWMLMlUcAeKZvY9ydJbm0Bm5ODozrq/YUz7xao4CoVT755BMKCwuJi4tjzZo1JCcnEx8fz80330xoaChTp0417nvjjTfyySefsHPnTrZt28ajjz5arsE8ICAAV1dX4uPjSUtLIzs723hfUVERY8aM4cCBAyxdupTJkyfz5JNPGueL3HjjjXz33XesXbuWvXv3MnLkyCt6FSIjI1m5ciWpqamcP3++wucTFhbGBx98wEcffcSYMWP4999/OXnyJOvXr+eRRx7hjTfeAOCGG24gIyODd999l6NHj/Lpp5/y119/Vft1nDJlCtOmTWPmzJkcPnyYvXv38s0331SpjHBkZCS5ubmsXLmSs2fPlkv0akqSkdpAyonaHsOcgtM7QH+ppSGvsISPVqgXQU/f1Jh6chFkNRzs7ZgYp64IPXvtcdJz/rMitKEggfRO2gY7u0vDWv9T2W722mOczS0i0s+NuzpWPLldaOPODmE0rK82CnxVUaOAqFUaN27Mtm3baNiwIXfeeSfR0dGMHTuWPn36sHHjxnJrjEyfPp2wsDB69uzJPffcw/PPP19uHoiDgwMzZ87kiy++ICQkhMGDBxvvu+mmm2jcuDG9evVixIgR3HbbbeVK17700kv07t2bW265hUGDBjFkyBCio6PLxTp9+nSWL19OWFgY7dq1u+pzevzxx/n77785ffo0Q4cOJSYmhoceeghPT09jhapmzZrx2Wef8emnn9KmTRu2bNlSo+pVDz30ELNnz+abb76hVatW9O7dmzlz5lSpZ6Rbt248+uijjBgxAn9//6v27lSHTrHEzKA6LicnBy8vL7Kzs/H09DT9CVa+AWvfh7b3wRApq2wT9KXwdjgU5cJjGyGwOQAfrTjCBysOE+nnxvLxvXGU1datiqIoDPt8AzuTsri3czhTh7ZS7yjKg2kNQNHD+ATw1KBCjai6VVNhzbvQ5m4YOguAjAuF9H5vNflFpXx6T3sGtTZN1RthOn/tTeGxH3bg6mjPvxNvIMDDxWznMvv/bwspKCjg+PHjREVF4eJivtfLFo0aNYqsrKxKr54uKqcq7zm50qkNpJyo7bGzL6uqhfH3dza3kC/XqJUtno9rKomIFdLpdLzYX+0d+WlrMscy1ImBnNmlJiKeoZKI2JIKKmp9vOoI+UWltGngxcBWpi9hKWquf8sg2oR5c7G41DicTghhu6p8tdOwYUPOnTt3xe1ZWVk0bCjj2y1Oyonarv8sfvjJqkTyikpp3cCLgS2lNdZadW7ox00xAZTqFd7/W622ZBzmEyoNAjbFMKTu3BG4eJ4TZ/OYtzkJgBcHNDNpCU5hOjqdjpcGqI0CP265rFFACGGTqpyMnDhxosLZ9IWFhZw+fdokQYkqkHKituuyxQ9Pnsvjh7LqMC/2j5EFvazcxP4x6HRqCeadSecv652U+SI2xd0PfMrGTJ/ezvt/H6JEr3BDU3+6RvtpG5u4pi4N/bixrFFg+t+HtQ5H2LA5c+bIEC2NVToZWbRoEYsWLQJg2bJlxp8XLVrEb7/9xhtvvEFkZKS54jT69NNPiYyMxMXFhc6dO7Nly5Zr7r9gwQJiYmJwcXGhVatWLF26tNz9iqIwadIkgoODcXV1pW/fvhw5Ur7bNzMzk3vvvRdPT0+8vb0ZM2aMsW6z5qScqO0yXLhmJPBx/C6KSxV6N/GnW6P62sYlrqtpkAfD2zcA4O2/DqIYJq9L76TtKfscph5Yz+I9Keh08ELZUDxh3Sb2b4pOB0v2prArOUvrcIQQ1VTpZGTIkCEMGTIEnU7HyJEjjT8PGTKEu+66i+XLlzN9+nRzxsr8+fMZP348kydPZseOHbRp04a4uLirrg65YcMG7r77bsaMGcPOnTuN8e7bt8+4z7vvvsvMmTOZNWsWmzdvxt3dnbi4OAoKLlXKuffee9m/fz/Lly9n8eLFrFmzhrFjx5r1uVaalBO1XR5B4BUGip7T+9fLRZCNefbmJjg52HHy+BF0F86Azh6C22odlqiqsgQyZf9aAIa2C6VZsO1OVK5LYoI8GdbO0CiQYJGVum2dvEbCUqryXqt0MqLX69Hr9YSHh5Oenm78Wa/XU1hYyKFDh7jllluqFXBlzZgxg4cffpjRo0fTvHlzZs2ahZubG19//XWF+3/00Uf079+fCRMm0KxZM9544w3at2/PJ598Aqgv1Icffsirr77K4MGDad26Nd9++y1nzpwxdtklJCQQHx/P7Nmz6dy5Mz169ODjjz/mp59+4swZDVYu/Y+SJMNYdUlGbFLZHIO2uqMMaRtK8xC5CLIVod6ujOoWSVs7teiAEtgcnCq3srCwImV/OyMKEnCy1zG+bHFLYRvG92uCk4OOguNbWHtQhopfjWG9DVOuDSHEtRjea5VZHL3K43r+u+KkpRQVFbF9+3Zeeukl4212dnb07duXjRs3VviYjRs3Mn78+HK3xcXFGRON48ePk5qaSt++fY33e3l50blzZzZu3Mhdd93Fxo0b8fb2pkOHSxf7ffv2xc7Ojs2bNzN06NArzltYWEhhYaHx55ycnGo95+vZmXiK1ukHQAcFge2QYn2255hLDA2B9vZHiZGLIJvz+A3R/LZFXevguHNzpISH7dEHtKAUB3x1uTzTzp4GPpJQ2pJQb1eeaufMU3snUTB/KvpXkrFzdNY6LKtjb2+Pt7e3cSSJm5ubFGgQZqEoCvn5+aSnp+Pt7X3F4pAVqdYkg5UrV7Jy5UpjD8nlrtZLUVNnz56ltLSUwMDAcrcHBgZy8ODBCh+Tmppa4f6pqanG+w23XWufgICAcvc7ODjg6+tr3Oe/pk2bxpQpUyr5zKqvuVs253Q+lCiw9EAxD/U0+ymFCen1Cp8d8eV9oIvzMTx8XLUOSVSRt5sTcV7JkA0/ng7gueJSXByv/4dXWI9F+88Rro+kvV0io8LPah2OqIbRkedgL5x2CMe7EPyu3xBbJwUFqaWqrza0XQhT8vb2Nr7nrqfKyciUKVN4/fXX6dChA8HBwZJZV+Cll14q1yOTk5NDWJjpV/F1DmnB6kH/MnXhJuxWJ3JHhzC8XOWvsK34c88Z/swIYJqzPR7F5yD7FHjLas82pbSE4Hy1vO+qvHACN53koZ7SP2IrCktKef/vQzyob0R7u0Tcz+4C7tU6LFFF9c7uBqBh217o6kmvyNXodDqCg4MJCAiguLhY63BELebo6FipHhGDKicjs2bNYs6cOdx///1VfWiN1K9fH3t7e9LS0srdnpaWdtXMKygo6Jr7G76npaURHBxcbp+2bdsa9/lvK0JJSQmZmZlXPa+zszPOzpb5gzi8fQO+WhtIYnous/49KhOgbURhSSnvLTtEIU6c92hMQO5BtTKaJCO2Jf0AuuJ8ihw8OFYQzCfSKGBTvt+UxKnzFznm3gxK48stfihsyGm1mp1OCrlUir29fZUuFIUwtyqvM1JUVES3bt3MEcs1OTk5ERsby8qVK4236fV6Vq5cSdeuXSt8TNeuXcvtD7B8+XLj/lFRUQQFBZXbJycnh82bNxv36dq1K1lZWWzfvt24z6pVq9Dr9XTu3Nlkz6+6HOztjAnI1+uOk5pdcJ1HCGswb7N6ERTg4YxPk7LPk1wI2Z6yanaO4R1oHOhJVn4xs/49qnFQojJyCor5ZJVaxr1zz37qjal7oVj+htqU0mI4s0vdlkIuQtikKicjDz30EPPmzTNHLNc1fvx4vvrqK+bOnUtCQgKPPfYYeXl5jB49GoAHHnig3AT3Z555hvj4eKZPn87Bgwd57bXX2LZtG08++SSgdlmOGzeON998k0WLFrF3714eeOABQkJCGDJkCADNmjWjf//+PPzww2zZsoX169fz5JNPctdddxESEmLx16AifZsF0CHCh8ISPR+ukMWfrN2FgmI+XpUIwLi+TXAM76TeIcmI7bmsRXZinDQK2JIv/z3G+fxiov3dGdCjM7jVB30xpO7ROjRRFekHoOQiOHuBXyOtoxFCVEOVh2kVFBTw5ZdfsmLFClq3bn1Fya4ZM2aYLLj/GjFiBBkZGUyaNInU1FTatm1LfHy8cQJ6UlISdnaX8qtu3boxb948Xn31VV5++WUaN27M77//TsuWLY37TJw4kby8PMaOHUtWVhY9evQgPj4eF5dLtal++OEHnnzySW666Sbs7OwYPnw4M2fONNvzrCqdTsdLA2MY/vlGft6WzJgeUTQO9NA6LHEVX605RmZeEQ3ru3NnhwZwvqw1L2WX2spnL0N8bIYhgQztwE1NAugY6cPWE+f5cMVh3h7eWtvYxFWl5xQwe51aBW1i/xgcHOzV9UYO/6X+TsM6aRyhqDTjZ7Ad2FW5fVUIYQV0ShVXwOnTp8/VD6bTsWrVqhoHVdvk5OTg5eVFdnY2np7mW0di7Lfb+PtAGjc3D+SrB6S72hqlXyig97v/cLG4lFn3tad/y2DQ6+HdKCjIgrH/QEg7rcMUlXExC96JULcnHAX3+mw/mcnwzzdip4O/n+1FowBpFLBGL/+2l3mbk2gf7s3Cx7qphVjWvAer3oQWw+COb7QOUVTW70/Aru+h5/Nw0/9MfnhL/f8Woi6rcs/I6tWrzRGHMIGJ/ZuyIiGN5QfS2HYikw6RvlqHJP5j5sojXCwupV24N3Etygog2Nmpix8eXam28kkyYhvO7FC/+0SCe30AYiN8iWsRyLL9abwTf0gaBazQ0Yxc5m9NBuDFAc0uVYQ0zDc4LcMlbYrh9yWT14WwWdXu00xMTGTZsmVcvHgRqNqy78I8GgV4MKKjWo1p2l8H5XdiZY5l5PLjlrKLoP4x5ctiG/6RyrwR23GqrKjFfybNToiLwU6HsVFAWJf3lx2iVK/Qt1kAnaIua7AJbQ/oICsJcjM0i09UQUEOZKiltWXyuhC2q8rJyLlz57jpppto0qQJAwcOJCUlBYAxY8bw3HPPmTxAUTXj+jbBxdGO7SfPs/xA2vUfICxm+t+HKdUr3BQTQOeGfuXvbNBR/S6tsrajrJKW8XdXplFAPWOjwNvSKGBVdiSd5699qdjp1KSxHBcv8G+qbsvn0Dac2Qko4B0O9fy1jkYIUU1VTkaeffZZHB0dSUpKws3NzXj7iBEjiI+PN2lwouoCPV0Y0yMKgHeXHaKkVK9xRAJgV3IWS/amoNOpE2avEBqrfj+XCPnSmm71FOWaw0MMjQLbTp5nRYKsdmwNFEXh7b8OAur6TE2DKpjPY2hdNySawroZPoOGv59CCJtU5WTk77//5p133qFBgwblbm/cuDEnT540WWCi+h7pHY23myOJ6bn8sv2U1uHUeepFUAJwjYsgN1/wLVu5+/QOC0YnquX8Ccg/B/ZOENTqirsvbxR4J/6gNApYgX8OZbDleCZODnY8e3OTineS4ZK25SpDJYUQtqXKyUheXl65HhGDzMxMi606Lq7N08WRJ/uo9dY/WHGYi0WlGkdUt/17OINNx65zEQQyVMuWGC5Wg1qDQ8V/9y5vFFi4QxoFtFSqV3gnXu0VGd0tkhBv14p3NCQjp3eAXv5uWrXr9E4KIWxHlZORnj178u233xp/1ul06PV63n333WuW/RWWdX/XCEK9XUnLKeTr9ce1DqfOKtVfGhoyqlskoVe7CILLhohIMmL1KnERVK5RYPkRaRTQ0G87T3Mw9QKeLg48dkP01Xf0bwaOblB0Ac7KArJWLec05KaBzh6C22gdjRCiBqqcjLz77rt8+eWXDBgwgKKiIiZOnEjLli1Zs2YN77zzjjliFNXg7GDP83FqK/ysf45yPq9I44jqpj92qRdBHi4OPH6tiyCABmXjnk9vU1v9hPW6bLHDazE0CqTmFDBnwwnzxyWuUFBcyoy/1YpLj/dphLeb09V3tneAkPbqtjQKWDfD7yewBTheo5FHCGH1qpyMtGzZksOHD9OjRw8GDx5MXl4ew4YNY+fOnURHX+diS1jU4DahNAv25EJhCZ+uTtQ6nDqnoLiU95epF0GP3RB97YsggMBWYO8MF89D5jELRCiqpaQQUveo29cZHnJ5o8Bn/ySSlS+NApb2zfoTnMkuIMjThVHdIq//gMsbBYT1uko1OyGE7alSMlJcXMxNN91Eeno6r7zyCj///DNLly7lzTffJDg42Fwximqys9Px4gC1ctO3G0+SnJmvcUR1y/+tO86Z7AJCvV15sHvU9R/g4HRpuIG0ylqv1L1QWgRu9dUFD6/D2ChQII0ClnYut5DPyl7zCXFNcXG0v/6DZLikbThdNnldkhEhbF6VkhFHR0f27NljrliEGfRqXJ9u0X4UleqZXjZUQZhfxoVLF0ET+1fyIgguq+YjpUWtlrFFtgNcvnDlVdjZ6Xihv7p+xdwN0ihgSR+uOMKFwhJahnoytF1o5R5kuLhNPwCFueYLTlRfaXHZGiPI5HUhaoEqD9O67777+L//+z9zxCLMQKfT8dKAZgD8vusMu5KztA2ojpix/DB5RaW0aeDFra1DKv9AYzUfaZW1WpcnI5XUu4k/3RupjQKGqk7CvBLTLzBvSxIArwxsjp3d9RNHADyDwTMUFD2k7DJfgKL60vZBSQG4eIOvDA8XwtY5VPUBJSUlfP3116xYsYLY2Fjc3d3L3T9jxgyTBSdMo1UDL4a1D+XXHad5c/EBFjzaFV0lWnRF9RxKvcD8repF0Ku3VOEiCC4NEUndC8UXZWKmNark5PXL6XQ6XhnYnEEfr2XxnhRGd88kNsLXTAEKgLeWHqRUr3Bz80C6RvtV7cENOsCB02riGdnDPAGK6jt12WKHdlVuUxVCWJkqf4r37dtH+/bt8fDw4PDhw+zcudP4tWvXLjOEKExhYlwMro72bDt5niV7U7QOp1abujQBvQIDWgbRMbKKF5ze4eDuD/oSSJEhkVYnNwOyTgI6CG1fpYc2D/FkRIcwAF7/8wB6vVRMM5d1R86y6mA6DnY6XiqbN1clMm/Euhl+LzJfRIhaoUo9I6WlpUyZMoVWrVrh4+NjrpiEGQR5ufBo72g+WHGYaUsP0rdZYOXnMYhK+/dwBmsOZ+Bof6l4QJXodOo/2ENL1aFa4Z1NH6SoPsPwOf+m4OJV5YeP79eEP3efYfepbP7YfZqh7RqYOEBRqld4c8kBAO7rEkFD/3pVP8jlK7ErSqXmBgkLksUOhahVqtQzYm9vT79+/cjKyjJTOMKcxvZqSLCXC6ezLvJ/62QhRFMrKdUztewiaGTXSCL83K/ziKsILSstKq2y1qca80UuF+DhwhM3qgshvvPXIfKLSkwVmSizcPsp4wKHz9zUuHoHCW6rLqaXm6ouriesR34mnCurSmf4WymEsGnVWmfk2DFZA8EWuTrZM7Gsqs9nqxNJv1CgcUS1y8/bTnE4LRdvN0eeurGaF0FQvlVWWBcTrG3wYPcoGvioCyF+uUb+lppSXmEJ75VVDXzqxsb4uF9nbZ+rcXJTF9MD+RxaG0NJX79G4CbzroSoDaqcjLz55ps8//zzLF68mJSUFHJycsp9Ces2uE0obcK8ySsqZcbfh7UOp9bIvljMjOXqRdDTNzbGy82x+gcLaQ/oIDsJctNNE6CoOX0pnC4rJ1qFyev/5eJobxzC98W/x0jNlkYBU/nsn0QyLhQS7uvGA90ianYwqWxnnapRQEIIYd2qnIwMHDiQ3bt3c9ttt9GgQQN8fHzw8fHB29tb5pHYADs7HZNuUUv9zt+WzP4z2RpHVDt8tOIIZ3OLiPZ3574uNbwIcvEE/7L5JtIqaz0yDkHRBXB0h4BmNTrUoFbBdIjw4WJxKe8uk1K/pnDyXB5frVGHn748sBnODjWcE2fo/ZLPoHWp4VBJIYT1qXJp39WrV5sjDmFBsRG+3NomhD93n+GNxQf48eEuUuq3Bg6nXWDuxhMAvHZbC5wcTFBqskEsZCSo/3hjBtb8eKLmDC3koe3BrmYXujqdjv/d0pzBn67n1x2neaBrJG3DvGseYx32xuIDFJXq6dm4PnEtAmt+QEPL+5ld6iJ79jXo7RSmoddftvK6JCNC1BZVTkZ69+5tjjiEhb3Qvyl/709l07FMFu9J4dY2VViYTxgpisJri/ZTqleIaxFIz8b+pjlwg46w83sZImJNTNwi2ybM27j+z6Q/9vHb492xr8qaNMJo9aF0ViSopXwn39rcNI0rfo3A2QsKs9XV2IPb1PyYomYyj0JBFji4QGBLraMRQphIlZORNWvWXPP+Xr16VTsYYTkNfNx4ok8jZiw/zJtLDtAnJoB6zlV+O9R5f+1LZcPRczg72PHqoOamO7ChVfb0TnWuQg1b4oUJmGGs+osDYli+P409p7KZvzWZezqHm+zYdUVhSSmv/6lWsRvVLZJGAR6mObCdndpDeXSVmohKMqI9Q4NAcFvpqRKiFqny1ecNN9xwxW2Xt0KVlpbWKCBhOWN7NWThjlOcPJfPzJVHeHlgzcbB1zUXi0qZuiQBgEd6RxPm62a6gwc0U+cmFF1Q5yoEmjDREVVXeAHS1d+1KYeHBHi48OzNTXh98QHeXXaQ/i2D8K1uBag66pv1Jzh+No/69Zx5pm8NqthVJLRDWTKyHTo+ZNpji6o7JeuLCFEbVXlw+/nz58t9paenEx8fT8eOHfn777/NEaMwExdHe167TS1f+fW64xxOu6BxRLbl83+PcjrrIqHerjzWO9q0B7ezv7TCtwzV0t7pHYACXuHgEWTSQz/QNYKYIA+y8ot5TyazV0laTgEfrzwCqL1MHi4mbi2XilrWxQSltYUQ1qfKyYiXl1e5r/r163PzzTfzzjvvMHHiRHPEKMyoT9MA+jUPpESvMOmPfSiKonVINuHkuTy++PcoAK8OaoarkxmGUcnih9bDuOKz6RdZc7C34/XB6vj3n7YmszPpvMnPUVtNXZJAXlEp7cK9GdYu1PQnMAzJO3sYLsrvRVNF+ZC2X92WnhEhahUTlP1RBQYGcujQIVMdTljQ/25pjrODHZuOZbJo9xmtw7F6iqLw6u/7KCxRK/f0b2nalnIjWfzQehiHh5inRbZTlC/D2oeiKDDpD7Uggri2fw9nsGj3Gex08PptLbEzx+R/dz/wiVK3T+8w/fFF5aXsAqUUPILB0wyJpxBCM1VORvbs2VPua/fu3cTHx/Poo4/Stm1bM4QozC3M140n+zQC1JbGCwXFGkdk3f7YdYa1R87i7GDHm0Namq8ssqFVNiMBCnPNcw5xfYpyaXiIGRdae2lAMzycHdh7Opt5W5LMdp7a4GJRKa/+vheAUd2iaNXAy3wnMw7V2m6+c4jrM34GY0FK0QtRq1Q5GWnbti3t2rWjbdu2xu2BAwdSVFTE7NmzzRGjsICHezUk0s+N9AuFvBMv49avJiu/iDcWq5V7nr6pMRF+7uY7mWcweDYARQ9ndprvPOLaspIgLwPsHCG4tdlO4+/hzHP9mgDw7l8HZWX2a/h41RGSMy8S7OXC+LLXzGyMix9uNe95xLWZuXdSCKGdKicjx48f59ixYxw/fpzjx49z8uRJ8vPz2bBhAzExMeaIUViAi6M9bw1tBcD3m5LYeiJT44is09t/HeRcXhGNA+rxcM+G5j+hYY6CXAhpx/DaB7UER1eznur+rpG0CfPmQmEJ/5M5XBU6mJrDl2uOATDlthbmL0keetlwSfl9aEcqaQlRa1U5GYmIiCj3FRYWhouLizliExbWrVF9RnQIA+CFhXsoKJYyzZfbcjyTn7YmA/DWsFamWWn9egytgDJERDvGFZ/N3yJrb6fjneGtcLDTsfxAGvH7Us1+Tlui1yu8/OteSvQK/ZoH0q+FmeZrXS6oFdg7w8VMOH/c/OcTV8o+DRfOgM4OQtppHY0QwsQqfTW1atUqmjdvTk5OzhX3ZWdn06JFC9auXWvS4ITlvTywGf4ezhzLyOPT1Ylah2M1CopLeenXPQDc3SmMjpG+ljmxsVV2q7TKasXC5URjgjx5/Aa1VPSkRfvJzpc5XAY/bEliR1IW7k6XypKbnYPTpeF5UkxCG4ZqdoEtwMmMQ2OFEJqodDLy4Ycf8vDDD+Pp6XnFfV5eXjzyyCPMmDHDpMEJy/Nyc+T1sn/yn/9zlISUK5PPuuiDFYc5mqEurPZifwsuDhncBnT2kJsG2acsd16hKimEFDUJNZZatoAnbmxEtL87GRcKeWtpgsXOa82SM/OZVvZaPB/XlBBv8w6ZKydUKttpyvC6m7GAhBBCO5VORnbv3k3//v2ven+/fv3Yvl2GktQGA1oFE9dCXXvkxYV7KCnVax2SpnYkneersjHqbw1tiZebiRdWuxYnN3WuAsjCa1pI3QelheDqC74WmCNUxtnBnneGq63x87clsz7xrMXObY30eoUJv+wmv6iUTpG+jOwaadkAZPFDbcnkdSFqtUonI2lpaTg6Xv0izMHBgYyMDJMEJbT3+uCWeLg4sPtUNp//c1TrcDRTUFzK8wt2o1dgWLtQy4xR/y9pldWOcYhWB4uXE+0Q6csDXSMAmLBgN9kX6+5wre83n2TTsUxcHe15747W5llT5FoMyUjKHiiWKmcWVVp8qZqgTF4XolaqdDISGhrKvn37rnr/nj17CA4ONklQQnuBni68UbYq9Ecrj7DnVJa2AWlkxvLDHMvII8DDmcm3WmiM+n/J4ofaOa1ti+wL/WOI8HPjTHYBUxbt1yQGrZ08l8e0pWq58RcHxJi3nPbVeEeAW33QF0PqXsufvy5LPwAlF8HZC/waax2NEMIMKp2MDBw4kP/9738UFFzZKnTx4kUmT57MLbfcYtLghLYGtw1hUKtgSvQKz87fVeeqa209kclXa9XhWdOGtbLs8KzLGS6EU3aprYTCci7vGdGAu7MDM+5si50Oft15miV7UjSJQyuleoXnF+zmYnEpXRr6cn+XCG0C0ekuq2wnjQIWZfwMxoKdBSoYCiEsrtKf7FdffZXMzEyaNGnCu+++yx9//MEff/zBO++8Q9OmTcnMzOSVV14xZ6zCwnQ6HW8OaUmAhzNHM/J4+6+6sxhidn4x437ahaLA7bENuKlZoHbB+EaDixeUFEDa1XsnhYnlZsD5E+p2SHvNwoiN8OGJPo0AeOX3vaTl1J1hQp+uTmTrifO4O9nz3u1tLD8863Ky5o82ZPK6ELVepZORwMBANmzYQMuWLXnppZcYOnQoQ4cO5eWXX6Zly5asW7eOwEANL9iEWfi4O/HeHW0AmLPhBGuP1P55QYqi8PJvezmddZFIPzfLlRC9Gju7S5WcZKiW5Zzaon73bwau3pqG8vRNjWkZ6klWfjETftmDXl/7yzxvP5nJRyuPAPDGkJaE+bppG5DM3dJG8mb1e1hnbeMQQphNlfo8IyIiWLp0KWfPnmXz5s1s2rSJs2fPsnTpUqKioswVo9BY7yb+xom0z87fTXotb5n9eVsyS/am4GCn46O72pl/hefKkMUPLc94EaR9BR9Hezs+uLMtzg52rDmcYRw+WFtlXyzm6R93UapXGNI2hGHtG2gdEoS2B3SQdVLtNRPml5sBmWXv9QaWK60thLCsag3A9PHxoWPHjnTq1AkfHx9TxySs0MsDmxET5MHZ3EKe+nFnrS33m5iey2uLDgDqWgZtwry1Dcjg8sUPhWUkl73WVtIi2zjQg0m3Ngfg3WWH2HoiU+OIzENRFF4p65kM93XjjSEttQ5J5eIF/k3VbZk3YhmGv3f+MeAq1xpC1FYyG0xUioujPZ/e2x53J3s2H8/kwxVHtA7J5HILS3j0++1cLC6lR6P6jO1puXUlrsswTOtcIlw8r20sdUFJEZzZoW5bSTICcE+ncAa3DaFUr/DkvB2cyy3UOiSTm7PhBIv3GHom2+LholHhiIrIUC3LMvZOdtI2DiGEWUkyIiot2r8e08oWYvtkdSL/HErXOCLTURSFib/sJjE9lyBPFz4Y0VbbybL/5e53adE9Gaplfql71YIBrj7g10jraIx0Oh1vDW1FtL87aTmFjJuvDmWqLbYcz2TqEnWV9ZcGNqNduJW1hsvih5aVXDZvy4oaBIQQpifJiKiS29qEcF+XcACe+WkXx8/maRyRaXy55hhL96biaK/js/va4+/hrHVIV5JWWcu5fNKshRc7vB53Zwc+uzcWF0c71h45y/t/H9I6JJNIyyng8R92UKJXuK1NCA92j9Q6pCsZk5EdoK+dQ1WthpX2TgohTE+SEVFlrw5qTtswb7IvFjNm7labXxl6zeEM3olXyxZPurUF7a2tNdbAMInd0FoozMfKh4c0DfLgnbJeys//OcqvO05pHFHNFBSX8tj32zmbW0hMkAdvD2+FzsqSQECtrOZUDwpzIKPulDrXRJp19k4KIUxPkhFRZS6O9nz5QCzBXi4cy8iz6QntB1NzePyHHejL1hO5r3O41iFdXXhZ6+CpraCvWwtQWpwh4WtgnckIwOC2oTx+QzQALy7cy44k25xLpNcrPLdgNzuSsvB0cWDWfbG4OVlBBbuK2Dtcmr+VvEnbWGq7yz+D1piYCiFMRpIRUS0BHi589UAHXB3tWXM4g9cXH0BRbGvselpOAaO/2UpuYQmdo3yZOrSldbbGGgS0AEd3aZU1t+xTcOEM6OzLyrlar+f7NeXm5oEUleoZ++12ks7lax1Slb277BBL9qTgaK9j1v2xRNZ31zqkazMMGZIeSvOy8t5JIYTpSDIiqq1lqBcz7lQXRPx240lmrkzUOKLKyy0s4cE5W0nJLqChvztf3t8BZwd7rcO6NnuHS2PWk6RV1mwMF0FBrcDJui+M7ex0fDiirbHs9v1fbyb9gu2sA/TD5pPM+vcoAG8Pa0236PoaR1QJhh5K+Qyal0xeF6LOkGRE1MiAVsFMKVuh/IMVh5m74YS2AVXCxaJSHpyzlf1ncvBzd2LOqE54uVlR+dBrCe+ifjdcMAvTs7GLIHdnB+Y+2IkwX1dOnstn5Ne2MY/rj12nefX3fQCM69uY4bFWsLBhZTToCOjg/HHIrT0VBa1K9inIOW0TvZNCiJqTZETU2MhukYzr2xiAyYv2W/Vk2oLiUsZ+t40txzPxcHbgm9EdCfdz0zqsyjMMWZBkxHxscHhIoKcL3z3Ymfr1nElIyeGhuVvJKyzROqyrit+Xwvifd6MocE/ncJ65qbHWIVWeixcEqItPyufQTAwNAjbQOymEqDlJRoRJPHNTY0Z2jQDguQW7mb81SeOIrlRQXMrjP+xg7ZGzuDnZM+fBjrRu4K11WFVjbJU9ARfStI6m9inKg5Q96rYNJSMAkfXd+fbBTni4OLD1xHnu/7/N5BRYXw/J8gNpPPXjTkr1CsPbN+DNwVY+V6siMlTLvIy9k7b1GRRCVI8kI8IkdDodk29twX1dwlEUeGHhXuasP651WEY5BcWM/HoLqw6m4+xgx/+N7EhshK/WYVWdixcEqsPipJqPGZzZCUopeASDV5jW0VRZ8xBPvh/TGS9XR3YkZXHvV5s5n1ekdVhGC7ef4tHvt1NcqnBL62Devb21dS0uWlnGSezSM2IWl6/zI4So9SQZESZjZ6fjjcEtebhnFACv/XmA95YdRK/xCtHpFwq4+8tNbD6eST1nB+aM7kTXaD9NY6oR41AtqeZjcpe3yNpaa32ZNmHe/PhwF/zcndh7OpvbZ23g5DltFydVFIXZa4/x3ILdlOoVhrUP5YMRbbG3xUQELl0kn9kFxbZTMMAmFOVDqm32TgohqkeSEWFSOp2Olwc2M44B/3T1UZ6Yt4OLRdqsi7E7OYvbPl7P/jM51K/nxE9ju9h2IgIQVjaJXYaImJ6NTV6/muYhnsx/pAvBXi4czchjyKfr2XzsnCaxFJaU8uLCvby5JAGAh3pE8f7tbXC0t+F/Pz6RUC8Q9MVqb5ownTM7QV9is72TQoiqs+H/BsJa6XQ6nr25CdPvaIOjvY6/9qUy7PMNJKZfsFgMiqKwYFsyd3yxkdScAqL93VnwaDdahnpZLAazMYxXT9kNxRe1jaU2UZRaNTykUYAHfzzRnTYNvDifX8x9/7eZ2WuPWbSnMiX7Ind9uYn525Kx08ErA5vxyqBmtjk063I63WU9lNIoYFKnbL93UghRNZKMCLMZHtuAHx5Sh4skpORwy8fr+HFLktkXRzyfV8ST83Yy4Zc9FJXo6dsskN+f6E6UtS+mVlneEdIqaw7njsLFTLB3hqDWWkdjEgGeLvw0tiu3tA6muFThzSUJjJ6z1SJrkfyx6zRxH6xhZ1IWXq6OzBndiYd7NbS9yepXY+ihlOGSpnX5yutCiDpBkhFhVp2ifPnrmZ70aFSfgmI9L/26l3tnbyYxPdfk51IUhd92nqLfh2tYsjcFBzsdz/drwpf3x+LhYiPriFSGTnep5V6GapmOoVckpB04OGkbiwm5Otnz8d3teHNIS5wd7Pj3cAZ9p//L95tOUmqGXpLkzHwe+W4bz/y0i5yCEto08GLRk93p1cTf5OfS1OVr/pi5gaXOqGW9k0KIyrGZZCQzM5N7770XT09PvL29GTNmDLm5176gLSgo4IknnsDPz4969eoxfPhw0tLKl0NNSkpi0KBBuLm5ERAQwIQJEygpuVSfPyUlhXvuuYcmTZpgZ2fHuHHjzPH0arUATxe+fbATLw2IwdnBjg1HzzHgozVM/mMfqdk1b6FVFIUNR88y/PMNPDt/NxkXCon2d+fXx7vx5I2NbX9ISEVk8UPTs8H1RSpLp9NxX5cIFj3ZgxYhnuQUlPDq7/u47ZN1rDiQZpLeynO5hbwbf5CbZvzLsv1p2NvpGNe3Mb881o0Iv1rSK3m5oNbg4AL55+BcotbR1A6Zx9TX094ZgmtH76QQ4voctA6gsu69915SUlJYvnw5xcXFjB49mrFjxzJv3ryrPubZZ59lyZIlLFiwAC8vL5588kmGDRvG+vXrASgtLWXQoEEEBQWxYcMGUlJSeOCBB3B0dOStt94CoLCwEH9/f1599VU++OADizzX2sjOTscjvaMZ0DKYyYv2sfpQBnM3nuTHLckMaRfCiI5htA/3qdIQjvyiEv7en8Y3G06wOzkLADcne57o04gxPaJwcbQ307OxAmH/aZWtLUNftFSLkxGDpkHqPJLvN51k+t+H2X8mh4e+3UaLEE/u7RzBLW2C8axCL6KiKOw/k8PP25L5eVsyBcV6ALpF+zH51hY0DfIw11PRnoMThLSHpA3qe6e+DS3caK0MPb0hbcHBWdNQhBCWo1PMPYDfBBISEmjevDlbt26lQ4cOAMTHxzNw4EBOnTpFSEjIFY/Jzs7G39+fefPmcfvttwNw8OBBmjVrxsaNG+nSpQt//fUXt9xyC2fOnCEwMBCAWbNm8cILL5CRkYGTU/mhGjfccANt27blww8/rFL8OTk5eHl5kZ2djaenZzVegdpF7ck4x0crjrDlRKbx9nBfN3o1qU+Xhn40DfQg3M8NZwd742Oy8os5djaPvaey2HD0HOsSz5JfVqXL2cGOOzuE8USfRgR5uWjyvCyqpAjeDoOSAnhiK/g30Toi25afCe+qJamZcBTc62sbjwWcyy3kq7XH+XbjiXKfo27RfvRo7E/LEE8aB3rg4+ZobCQoKtGTlJlPYvoFNh3LZO2RDI5mXCob3LqBF0/2acTNzQNrz9yQa1k+GdZ/CO3uh8GfaB2N7fvjSdj5HXQfBzdP0ToaQP5/C2EJNtEzsnHjRry9vY2JCEDfvn2xs7Nj8+bNDB069IrHbN++neLiYvr27Wu8LSYmhvDwcGMysnHjRlq1amVMRADi4uJ47LHH2L9/P+3atatWvIWFhRQWFhp/zsnJqdZxaiudTkf3RvXpFu3HtpPnmb81mSV7UkjKzOf7TUl8v+nS6u3ODnY42duRX1xa4fj2CD83hrVrwL1dwqlfrw61pDk4QWgsnFyvVvORZKRmDC2y9ZvUiUQEwK+eMy8OiGFsr4Ys3H6Kn7clcyQ9l9WHMlh9KMO4n50O3J0cKCrVU1iiv+I4Tg523Nw8kLs7htO9kV/dSEIMwrvAemS4pKkkbVS/R3TTNg4hhEXZRDKSmppKQEBAudscHBzw9fUlNTX1qo9xcnLC29u73O2BgYHGx6SmppZLRAz3G+6rrmnTpjFlinW06lgznU5Hx0hfOkb6MuW2Fmw8eo41RzLYcyqbxPRccgtLKCwpfwEU7OVC40APOkf50qNRfVo38KpbFz+XC+tcloxshvYPaB2NbUvaoH4P76ptHBrwdXfi4V4NeahnFAdTL7DuyFk2HTvHobQLnDp/Eb0CFwovzaNzc7Inqr477cK96dqwPj2b1K/S0K5axVDx6exhtXfNzVfbeGxZbnrZ3BtdrR4qKYS4kqbJyIsvvsg777xzzX0SEhIsFI3pvPTSS4wfP974c05ODmFhsnjTtbg7O9C3eSB9m6vJoKIo5BSUcKGgmKISPe7ODni6OOLqVIvngVSVsaKWtMrW2MmyFtk6mIwY6HQ6mgV70izYk4d7NQSgoLiUnIJiLhSU4GRvh7uzQ7lhW3Weux/4NYZzR9SStE37ax2R7TL0igQ0B1cfbWMRQliUpsnIc889x6hRo665T8OGDQkKCiI9Pb3c7SUlJWRmZhIUFFTh44KCgigqKiIrK6tc70haWprxMUFBQWzZUr5GvKHa1tWOWxnOzs44O9ehIUNmoNPp8HJ1xMu1jra4Voah9fDcEcg7p14YiaoryoeUXep2RN1NRiri4miPi6M9AbV4HnqNhXcuS0Y2STJSE4ahkvIZFKLO0bS0r7+/PzExMdf8cnJyomvXrmRlZbF9+3bjY1etWoVer6dz54prkcfGxuLo6MjKlSuNtx06dIikpCS6dlX/2HXt2pW9e/eWS3SWL1+Op6cnzZs3N9OzFsJE3HyhflN1W8asV9/pbaAvAY8QdUFJIarCUNlOeihr5v/bu/O4qOr9f+CvYRsUBEQ2URYxFVQkV5wsM/cl07JMr2F61cqL3Szv/Vn3W3nr9qvbrW6/X11bH5l1S1O7ZqUmVw21FEUBFTfcEFwAF2JHlpnP94/DDIwwwyIzn1lez8eDxznMnOV9ODPMvD9rjvM2lSRydnYxz0hMTAwmTpyIRYsWITU1FXv37sWSJUswa9Ysw0haly9fRnR0tKGmw9fXFwsWLMBzzz2H5ORkpKWlYf78+dBoNBg+XPnwGD9+PPr27YuEhAQcOXIESUlJePHFF5GYmGhUs3H48GEcPnwYZWVluHbtGg4fPowTJ05Y/w9BdCv9fCP6Pg/UevomWhEaDpFMraf/8nw5Daix/Mz2DqmqFMg/qqwzGSFyOnbRgR0Avv76ayxZsgRjxoyBi4sLZsyYgffee8/wfE1NDbKyslBRUWF47N133zVsW1VVhQkTJuCDDz4wPO/q6orNmzdj8eLF0Gg08PLywuOPP45XX33V6NwNR9VKS0vDmjVrEBERgQsXLljugolaImIEkP5FfakitZ4Td16ndtClJ+AVBJRfBa6kcySotriYCggd4BcO+HaTHQ0RWZndJCP+/v5mJziMjIxsNIuwp6cnVq5ciZUrV5rcLyIiAlu3bjV7bjuYioWclf6Lz5XDQFUZoPaWGo7d0dYCFw8q60xGqC1UKuV9eGKTMrodk5HW03deD+ffjsgZ2UUzLSIywS8M8A0HhBa4lNr89mQs/yhQUw54+iqj+BC1RcQIZckayrZh53Uip8ZkhMjeRfKLUJvpS2TDhgMu/HdIbaR/D+YeUGrbqOVqq4FLrJ0kcmb89CWyd/pmIUxGWk//N2OJLN2OwBjA00+pZcs/Ijsa+5J3GKi9CXTsAgT0lh0NEUnAZITI3umbiFw6xNF8WkOI+uYhbKtOt8PFhYUCbdVwSF+OZkfklJiMENk7/yjAOxjQVimj+VDL3DgLVFwHXNVA6J2yoyF7x2SkbQwFAqydJHJWTEaI7J1+NB9AGc2HWkb/pbH7EMBNbX5bouY0TEZ0Ormx2AudrsFIWkxGiJwVkxEiR6BvqnWByUiL8UsQtaeQOMDdC7hZBFzlpLgtcu2U8vdy7wh0HSA7GiKShMkIkSPQl8peTAW0NXJjsRfsvE7tydUNCI9X1tlUq2X0E452Hwq4usuNhYikYTJC5AgajuaTd1R2NLavKBcoygFUrkBYvOxoyFGwuWTrZP+iLCPvlhsHEUnFZITIERiN5sMvQs268Kuy7DYIUHeSGws5joaTHwohNxZbJ0T9+zDyHrmxEJFUTEaIHAVH82k5lsiSJYQOUkZnK78K3DgnOxrbdu2UMpqdWwelUICInBaTESJHoU9GcjmaT7NYIkuW4O6pjM4GsIayOfr3YHg8R7MjcnJMRogchWE0n2KO5mPObzlAcS7g4sb+ItT+WEPZMtl7lCVrJ4mcHpMRIkfRcDQffakjNXahrolWt8GA2ltuLOR49MnIhV/Zb8QUna6+5ihypNxYiEg6JiNEjqRH3Qe7/gs3NWZoosUSWbKAsOGAiztQcgn4LVt2NLbp2kmg4oYyv0joQNnREJFkTEaIHEnDZESnlRuLLRKCndfJsjw6AmHDlPXzu+XGYqsM/UWGA24ecmMhIumYjBA5kpA4QO2r9BvJOyI7Gtvz2wWlxNrFnf1FyHL0hQL6fhFkjP1FiKgBJiNEjsTVDYism+uAX4QaM8wvMhjw8JIbCzmuhskI+40YY38RIroFkxEiR8NSWdP0fWl6cEhfsqBuQ5T+EBXXObLdra4eByp/U0b+C71TdjREZAOYjBA5Gn0ykpsC1FbLjcWWGM34zOYhZEFuHkC4RllnoYAx/XswQgO4usuNhYhsApMRIkcT1BfoGADUVACX02RHYzsKzwMllwFXD6D7MNnRkKNjDWXTOIAEEd2CyQiRo1GpGnwR4mg+Bob5RYYoIx4RWZJhZLtfAW2t3FhshU7L/iJE1AiTESJHxFLZxs7vUpY9+CWIrKBrHODpC1SVcGQ7vbzDwM0iQO2j/H2IiMBkhMgx6b9wX0wFqivkxmILdLr6OR963ic3FnIOLq5AZN1ACayhVJxLVpY9Rioj/xERgckIkWPyjwJ8ugO6GuDiftnRyJd/FKgsBDw6KcP6ElkDayiN6Wsno0bJjIKIbAyTESJHpFIBUfcq6/wiBJyvK5GNvJsj+JD1GEa22w/UVsmNRbbqCuDiAWU9irWTRFSPyQiRo9J/ETrPJiKG5iFsokXWFBgNeAUBtZXApYOyo5ErZx+grQZ8w4AuPWVHQ0Q2hMkIkaPSJyN5h4GKQqmhSFVTqZRMAyyRJetqOLKdvomSs9LXTkaNUv4uRER1mIwQOSqfUKVkVuicuwNtzj5AWwX4dAMCesmOhpxNz9HK8uxOuXHIxtpJIjKByQiRI+s5Rlk68xehhp1mWSJL1qZPRq5kAOU35MYiS2kBcPW4st7jXrmxEJHNYTJC5MjuqPsidO5nQAi5schiaB7CElmSwKcrENQPgKh/LTobfc1syADAK0BuLERkc5iMEDmyiBGAmydQchm4liU7GusruwbkZyrrHE6UZGlYKOCM2ESLiMxgMkLkyNw7ABF3KevnnLCplr5ENjgW8A6UGws5L31zSWesoRSCtZNEZBaTESJH58z9RvQl0VFsp04ShWsAtw5AaR5w9YTsaKzr2inlul3VQPhw2dEQkQ1iMkLk6O6oS0Zy9irD3DoLnQ44u0NZ7zVObizk3Nw9lQk3AecrFDizXVn2uEepqSUiugWTESJHFxitDGtbe1NJSJxF/lGgrABw91JKpolk0hcKOFtzyTP/VZZ3sECAiJrGZITI0alUDeY6cKIOtPoS2ahRgJtaaihEhuaSOSlAdYXcWKzlZgmQm6Kss3aSiExgMkLkDJyxVFZfIssvQWQLAnoBvmHKBJzOUkN5fhegqwX8ewJdesqOhohsFJMRImcQNQpQuSidSYsvyY7G8ioKgcuHlHUmI2QLjGood8iNxVrO1tVO9hovNw4ismlMRoicQYfOQPehyvrpbXJjsYZzPwNCp0w259tddjRECn1ifHqb4w/xK0R9U0kWCBCRGUxGiJxF74nK8nSS3DisgU20yBZF3Qe4egC/XQCun5YdjWUVHFOG9HXvqEy+SkRkApMRImfRZ5KyPL8bqC6XG4sl6bQNhvRl8xCyIWpvoMdIZT3rJ7mxWJq+QKDHvcrQxkREJjAZIXIWgdGAX4TSgfb8LtnRWM6VDKDiBqD2BcKGyY6GyJihhtLBm0uyiRYRtRCTESJnoVLVfxFy5FJZfTO0nqMAV3epoRA10nuCsrx4QBlowRFVFCrXBzAZIaJmMRkhciZ9GvQb0enkxmIpWVuVpT7xIrIlfuFAcH9lgAV9UyZHc+a/dQNI9FWul4jIDCYjRM4k4m7AoxNQfhXIy5AdTfv77YLScVblymSEbJejN9U6tUVZRk+RGwcR2QUmI0TOxM0DuKNuroMsB/widKquViTiLqCjv9xYiEzRDyZxdidQWy03lvZWU6lcF8BkhIhahMkIkbMxlMo6YL8RlsiSPQgdBHgFAlUlQO4+2dG0r/O7gZpywKcb0PVO2dEQkR1gMkLkbHqNV2Zjz88Eii7Kjqb9lN+o/2LXZ7LcWIjMcXEBetV1ZNfX5jmKrLoCgT6TlUEziIiawWSEyNl4BQDhGmX95I9yY2lPp7cpnWZDYoHOEbKjITIv5n5lefJHxxlMQqetH6mPtZNE1EJMRoicUcwDyvLE93LjaE/6UbSi75cbB1FLRN2nDCZRegW4nCY7mvZx6SBQfk2Z4yfybtnREJGdYDJC5IxipirLiweAkjy5sbSH6or6TrNsokX2wN2zfs6RE5ukhtJu9H22ek/gHD9E1GJMRoickW83oPtQAAI4tVl2NLfv7A6gthLwDVeaaRHZg77TlOXJHwAh5MZyu4RQrgMAolkgQEQtx2SEyFk5UlOt498py37T2GmW7McdYwH3jkBRLpB3WHY0tyfvsDLPj1sHZZAMIqIWYjJC5Kz61iUjOXuB8utyY7kd1eX1k8f1e1BuLESt4dER6DVOWT/xg9xYbtexjcqy9wTAw0tuLERkV5iMEDmrzpFA1zhlBCp7bqp15r9ATYVyPaGDZEdD1DoNayjttamWEMDxTcp6/4ekhkJE9sdukpHCwkLMmTMHPj4+8PPzw4IFC1BWVmZ2n5s3byIxMRFdunSBt7c3ZsyYgYKCAqNtcnNzMWXKFHTs2BFBQUH485//jNraWsPzGzduxLhx4xAYGAgfHx9oNBokJSVZ5BqJrE7fZt2em2rpS2T7PcgmWmR/ek8AXNVA4Tmg4LjsaNrmchpQnAu4e7GJFhG1mt0kI3PmzMHx48exfft2bN68GXv27METTzxhdp9nn30WP/74IzZs2IDdu3fjypUreOih+lIbrVaLKVOmoLq6Gvv27cMXX3yB1atX4+WXXzZss2fPHowbNw5bt25FWloa7rvvPkydOhUZGRkWu1Yiq+k7XVme3wWUXZUZSdtUlSk1IwCbaJF9Uneqb6qVuUFuLG2lLxDoMwlw7yA3FiKyOyohbL9e+OTJk+jbty8OHjyIIUOGAAC2bduGyZMn49KlSwgNDW20T3FxMQIDA7FmzRo8/PDDAIBTp04hJiYGKSkpGD58OH766Sfcf//9uHLlCoKDgwEAH330EZYvX45r167Bw8OjyXj69euHRx991ChpMaekpAS+vr4oLi6Gj49PW/4ERJbz6WilZHPim8Dwp2RH0zqZ3wL/WQD49wSeTmPNCNmn45uADY8DPt2BpZnKDO32QqcD3u2nzJcya43DTXbIz28iy7OL/3gpKSnw8/MzJCIAMHbsWLi4uODAgQNN7pOWloaamhqMHTvW8Fh0dDTCw8ORkpJiOG5sbKwhEQGACRMmoKSkBMePN11drtPpUFpaCn9/f5PxVlVVoaSkxOiHyGYNeFRZHl0nN462OPYfZckmWmTPek8E1D5AySUgd5/saFrn4n4lEVH7AD3HyI6GiOyQXSQj+fn5CAoKMnrMzc0N/v7+yM/PN7mPh4cH/Pz8jB4PDg427JOfn2+UiOif1z/XlLfffhtlZWWYOXOmyXjfeOMN+Pr6Gn7CwsLMXh+RVP0eAlSuwJV04MY52dG0XPn1+iZasY/IjYXodrh71o9ud3S93Fha68haZRkzVbkOIqJWkpqMPP/881CpVGZ/Tp06JTNEI2vWrMErr7yC9evXN0qOGnrhhRdQXFxs+Ll48aIVoyRqJe9AoOdoZd2evghlfgvoaoHQgUBQtOxoiG5PbF0B14lNQG2V1FBarKayfhStuNlSQyEi++Um8+TLli3DvHnzzG4TFRWFkJAQXL1q3Lm2trYWhYWFCAkJaXK/kJAQVFdXo6ioyKh2pKCgwLBPSEgIUlNTjfbTj7Z163G/+eYbLFy4EBs2bDBq+tUUtVoNtVptdhsimzJgJnB2u9JUa9Tz9tHk6cgaZRn3O7lxELWHyLuBTl2B0jylxi9mquyImndqC1BVAviGAxEjZEdDRHZKas1IYGAgoqOjzf54eHhAo9GgqKgIaWlphn1//vln6HQ6xMfHN3nswYMHw93dHTt37jQ8lpWVhdzcXGg0GgCARqNBZmamUaKzfft2+Pj4oG/fvobH1q5di/nz52Pt2rWYMsWxOucRAQD6TFZmgv4tG7h0UHY0zSs4AeQdAVzcgf4zZEdDdPtcXOtfy0e+kRtLSx3WFwjMsq9O90RkU+ziv0dMTAwmTpyIRYsWITU1FXv37sWSJUswa9Ysw0haly9fRnR0tKGmw9fXFwsWLMBzzz2H5ORkpKWlYf78+dBoNBg+fDgAYPz48ejbty8SEhJw5MgRJCUl4cUXX0RiYqKhZmPNmjWYO3cu3nnnHcTHxyM/Px/5+fkoLi6W88cgsgS1d/2cI+lfyo2lJfTt1HtPALy6yI2FqL3omzqd3mb7Q22X5AHnk5X1uFlyYyEiu2YXyQgAfP3114iOjsaYMWMwefJk3H333fjkk08Mz9fU1CArKwsVFRWGx959913cf//9mDFjBkaOHImQkBBs3LjR8Lyrqys2b94MV1dXaDQaPPbYY5g7dy5effVVwzaffPIJamtrkZiYiK5duxp+nnnmGetcOJG1DJqrLI9tBKpK5cZijra2vm8L26mTIwnpD3QbrPSF0tc62KrM9YDQAWHDgS49ZUdDRHbMLuYZsXccp5zsghDAymHA9dPA/f8PGDJfdkRNy9oGrH0U6OAPLMsC3JqeD4jILqV9Afz4R9ueO8de/le0A35+E1me3dSMEJGFqVT1tSPpX8iNxZxDnynLO3/HRIQcT/8ZgIc3UHgOyNkrO5qmXfhFSUQ8vIHYh2VHQ0R2jskIEdWLm610Cr+SAeQdlR1NY79dAM5sV9aH/F5qKEQWofau78ieZqOFAgfrCgQGzATUneTGQkR2j8kIEdXzCgCi60aMS1stNZQmpa0GIICo+9hOnRzX4MeV5YnvgYpCubHcqjQfOLVZWR+yQG4sROQQmIwQkbHB85TlkW+AyiKZkRirrQLS/62sD+WXIHJgoYOAkFhAW2V7TSbT/610sA+LVzrcExHdJiYjRGQsahQQGAPUlAMZ/5YdTb0TPwAV14FOoUDvSbKjIbIclQqIX6ysp34KaGvkxqOnra2vMWWtCBG1EyYjRGRMpQKG130ROvCJ8gVENiGAlPeV9SHzAVc3ufEQWVrsw4BXIFByWWmuZQtObAJKLgEdA+rnJSIiuk1MRoiosQEzgY5dgOLc+vbhMmXvUWZcd+vAEllyDm5qYOhCZX3/B0pCLpMQwL73lPX4JwF3T7nxEJHDYDJCRI25d6gfrWr/B3JjAYB9dbUiA+dwxnVyHkMWAK4ewOU04GKq3Fgu/MICASKyCCYjRNS0oQuVL0IXDwAXfpUXR8EJ4Ox2ACpAkygvDiJr8w5UaikB4Nd/yo1lb12tyMDHWCBARO2KyQgRNa1TCDAwQVnf/aa8OH55R1nGTAX8o+TFQSTDiGcBlQtwepsy/48MVzKUAgGVC6D5g5wYiMhhMRkhItPuflaZBDF7D5CTYv3zF5wAjv1HWR/5Z+ufn0i2gDuA/nWznO9+S04MyW8oy9hHWCBARO2OyQgRmeYXBtz5O2VdRu3I7r8DEEDMA0DXAdY/P5EtGPlnACogawuQd9S65754EDiTBKhcgXuXW/fcROQUmIwQkXn3LANc3IDzycD5XdY7b35m3ZCmKuC+v1jvvES2JrA30H+Gsr7zFeueO/n/Ksu42UCXntY9NxE5BSYjRGRe54j60XOSXgR0WsufUwjgvy8p6/0fAoJiLH9OIls2+n+UJpNndyg/1nB2h1II4eIG3MtmkkRkGUxGiKh5o54HPH2BgkzgyFrLny/rJ+VLkKsaGP2S5c9HZOv8o4BhTyjrSS9afjJSbQ2wra5GctiTQOdIy56PiJwWkxEial5H//oO5DtfBW4WW+5ctVVAUt2XIE0i4N/Dcucisicj/wR4+gHXTgJpn1v2XAc/A65nKZOf3vt/LHsuInJqTEaIqGWGPQH49wTKCoAdf7Xcefa8DfyWDXiHAPc8Z7nzENmbjv71/ad2vgqUXLHMeYov1/cVGf0S0MHPMuchIgKTESJqKTc1MPX/K+uHVgEX9rb/OfKO1E/uNvENQN2p/c9BZM+GLgS6DQGqSoAty5T+Ve1JCODHZ5Tjdx8KDJrbvscnIroFkxEiarke9wCD5ynr3/+hfZtr1VYBmxIBXa0ylG//h9rv2ESOwsUVeOB9pTN71lbg8Jr2PX7GV8oEh65qYNoHyvmIiCyIyQgRtc64VwHfcOC3C8APT7dfyey2F5QO8h38gSnvtM8xiRxRcF9gVN2cH1uWAVdPts9xC44DW+v6ht33gjKkMBGRhTEZIaLW8fQFHlmtlMye+B7Y/8HtH/PIN8ChzwCogIc+AbyDbv+YRI7s7ueAqPuA2kpg/Vygsuj2jldZpBynthLoORq464/tESURUbOYjBBR63UfDIz/m7Ke9D/A8U1tP9a5n4HvlyjrI/8M9Bp32+EROTwXV+ChT4FOXYHrp4F1jylNHduiphJYOxu4cRbw6aYcl82ziMhKmIwQUdvEP1U3GaIANi4CTm5u/TGy9wDfPAboaoB+DwKjXmj3MIkclncg8Lt1gEcn4MIvSs1GTWXrjlFdoeyXuw9Q+yjH8wqwTLxERE1gMkJEbaNSAZPfAvpOA7TVwPoEIPXTlvchOboe+GoGUFMORI0CHvwYcOG/JKJW6RoHzPoKcPMETm8DvpwOlBa0bN/SAuDLB4Az/1X2n70WCIm1aLhERLfiJz8RtZ2LKzBjFTDwMUDogK1/UpqLFF00vU9pAfDdU0ptirZaGTlr9jpl6GAiar2oUUDCd4DaF7i4H/hQAxzbaLpgQKcDMr9Vtrt0UJlIce4PQOTd1oyaiAgAoBKivQcpp1uVlJTA19cXxcXF8PHxkR0OUfsTAkj5F7DjFaXJlasH0O8hoM8kIKA3oHIBCs8pJbeZ/1FqQ6AC7lmmTOLG9ulEt+9aFvDt74GCY8rvwbFA3KNA92HKhIkVhcClVODwWuDq8fptHl7FkbNM4Oc3keUxGbEC/jMjp5F3FEj6i9J+3Zxug4EJrwPhw60TF5GzqK0CfnkHSFkJVJeZ3s7DWxkx6+6lrJU0g5/fRJbHZMQK+M+MnIoQStOPzG+VJiO/5SiP+4Ypo3D1f1hpDqJSyY2TyJFVFALH/gNk/QRcO6UkJh7eQFBfoPcEoP8MpbaEzOLnN5HlMRmxAv4zIyIisj/8/CayPHZgJyIiIiIiKZiMEBERERGRFExGiIiIiIhICiYjREREREQkBZMRIiIiIiKSgskIERERERFJwWSEiIiIiIikYDJCRERERERSMBkhIiIiIiIpmIwQEREREZEUTEaIiIiIiEgKJiNERERERCQFkxEiIiIiIpKCyQgREREREUnhJjsAZyCEAACUlJRIjoSIiIhaSv+5rf8cJ6L2x2TECkpLSwEAYWFhkiMhIiKi1iotLYWvr6/sMIgckkow3bc4nU6HK1euoFOnTlCpVO167JKSEoSFheHixYvw8fFp12PbAke/PsDxr5HXZ/8c/Rp5ffbPUtcohEBpaSlCQ0Ph4sKW7USWwJoRK3BxcUH37t0teg4fHx+H/ZABHP/6AMe/Rl6f/XP0a+T12T9LXCNrRIgsi2k+ERERERFJwWSEiIiIiIikYDJi59RqNVasWAG1Wi07FItw9OsDHP8aeX32z9Gvkddn/5zhGokcFTuwExERERGRFKwZISIiIiIiKZiMEBERERGRFExGiIiIiIhICiYjREREREQkBZMRO7By5UpERkbC09MT8fHxSE1NNbv9hg0bEB0dDU9PT8TGxmLr1q1WirR13njjDQwdOhSdOnVCUFAQpk+fjqysLLP7rF69GiqVyujH09PTShG33l//+tdG8UZHR5vdx17uHwBERkY2uj6VSoXExMQmt7eH+7dnzx5MnToVoaGhUKlU2LRpk9HzQgi8/PLL6Nq1Kzp06ICxY8fizJkzzR63te9jSzF3fTU1NVi+fDliY2Ph5eWF0NBQzJ07F1euXDF7zLa8zi2lufs3b968RrFOnDix2ePayv0Dmr/Gpt6TKpUKb731lslj2tI9bMlnw82bN5GYmIguXbrA29sbM2bMQEFBgdnjtvW9S0SWxWTExq1btw7PPfccVqxYgfT0dMTFxWHChAm4evVqk9vv27cPs2fPxoIFC5CRkYHp06dj+vTpOHbsmJUjb97u3buRmJiI/fv3Y/v27aipqcH48eNRXl5udj8fHx/k5eUZfnJycqwUcdv069fPKN5ff/3V5Lb2dP8A4ODBg0bXtn37dgDAI488YnIfW79/5eXliIuLw8qVK5t8/h//+Afee+89fPTRRzhw4AC8vLwwYcIE3Lx50+QxW/s+tiRz11dRUYH09HS89NJLSE9Px8aNG5GVlYUHHnig2eO25nVuSc3dPwCYOHGiUaxr1641e0xbun9A89fY8Nry8vKwatUqqFQqzJgxw+xxbeUetuSz4dlnn8WPP/6IDRs2YPfu3bhy5Qoeeughs8dty3uXiKxAkE0bNmyYSExMNPyu1WpFaGioeOONN5rcfubMmWLKlClGj8XHx4snn3zSonG2h6tXrwoAYvfu3Sa3+fzzz4Wvr6/1grpNK1asEHFxcS3e3p7vnxBCPPPMM6Jnz55Cp9M1+by93T8A4rvvvjP8rtPpREhIiHjrrbcMjxUVFQm1Wi3Wrl1r8jitfR9by63X15TU1FQBQOTk5JjcprWvc2tp6voef/xxMW3atFYdx1bvnxAtu4fTpk0To0ePNruNrd5DIRp/NhQVFQl3d3exYcMGwzYnT54UAERKSkqTx2jre5eILI81IzasuroaaWlpGDt2rOExFxcXjB07FikpKU3uk5KSYrQ9AEyYMMHk9rakuLgYAODv7292u7KyMkRERCAsLAzTpk3D8ePHrRFem505cwahoaGIiorCnDlzkJuba3Jbe75/1dXV+Oqrr/D73/8eKpXK5Hb2dv8ays7ORn5+vtE98vX1RXx8vMl71Jb3sS0pLi6GSqWCn5+f2e1a8zqXbdeuXQgKCkKfPn2wePFi3Lhxw+S29n7/CgoKsGXLFixYsKDZbW31Ht762ZCWloaamhqjexIdHY3w8HCT96Qt710isg4mIzbs+vXr0Gq1CA4ONno8ODgY+fn5Te6Tn5/fqu1thU6nw9KlSzFixAj079/f5HZ9+vTBqlWr8P333+Orr76CTqfDXXfdhUuXLlkx2paLj4/H6tWrsW3bNnz44YfIzs7GPffcg9LS0ia3t9f7BwCbNm1CUVER5s2bZ3Ibe7t/t9Lfh9bco7a8j23FzZs3sXz5csyePRs+Pj4mt2vt61ymiRMn4ssvv8TOnTvx5ptvYvfu3Zg0aRK0Wm2T29vz/QOAL774Ap06dWq2CZOt3sOmPhvy8/Ph4eHRKEFu7rNRv01L9yEi63CTHQARACQmJuLYsWPNtlHWaDTQaDSG3++66y7ExMTg448/xt/+9jdLh9lqkyZNMqwPGDAA8fHxiIiIwPr161tUUmlPPvvsM0yaNAmhoaEmt7G3++fMampqMHPmTAgh8OGHH5rd1p5e57NmzTKsx8bGYsCAAejZsyd27dqFMWPGSIzMMlatWoU5c+Y0O1CErd7Dln42EJH9Ys2IDQsICICrq2ujEUIKCgoQEhLS5D4hISGt2t4WLFmyBJs3b0ZycjK6d+/eqn3d3d0xcOBAnD171kLRtS8/Pz/07t3bZLz2eP8AICcnBzt27MDChQtbtZ+93T/9fWjNPWrL+1g2fSKSk5OD7du3m60VaUpzr3NbEhUVhYCAAJOx2uP90/vll1+QlZXV6vclYBv30NRnQ0hICKqrq1FUVGS0fXOfjfptWroPEVkHkxEb5uHhgcGDB2Pnzp2Gx3Q6HXbu3GlUutyQRqMx2h4Atm/fbnJ7mYQQWLJkCb777jv8/PPP6NGjR6uPodVqkZmZia5du1ogwvZXVlaGc+fOmYzXnu5fQ59//jmCgoIwZcqUVu1nb/evR48eCAkJMbpHJSUlOHDggMl71Jb3sUz6ROTMmTPYsWMHunTp0upjNPc6tyWXLl3CjRs3TMZqb/evoc8++wyDBw9GXFxcq/eVeQ+b+2wYPHgw3N3dje5JVlYWcnNzTd6Ttrx3ichKJHegp2Z88803Qq1Wi9WrV4sTJ06IJ554Qvj5+Yn8/HwhhBAJCQni+eefN2y/d+9e4ebmJt5++21x8uRJsWLFCuHu7i4yMzNlXYJJixcvFr6+vmLXrl0iLy/P8FNRUWHY5tbre+WVV0RSUpI4d+6cSEtLE7NmzRKenp7i+PHjMi6hWcuWLRO7du0S2dnZYu/evWLs2LEiICBAXL16VQhh3/dPT6vVivDwcLF8+fJGz9nj/SstLRUZGRkiIyNDABD//Oc/RUZGhmE0qb///e/Cz89PfP/99+Lo0aNi2rRpokePHqKystJwjNGjR4v333/f8Htz72Nbub7q6mrxwAMPiO7du4vDhw8bvS+rqqpMXl9zr3Nbub7S0lLxpz/9SaSkpIjs7GyxY8cOMWjQINGrVy9x8+ZNk9dnS/dPiOZfo0IIUVxcLDp27Cg+/PDDJo9hy/ewJZ8NTz31lAgPDxc///yzOHTokNBoNEKj0Rgdp0+fPmLjxo2G31vy3iUi62MyYgfef/99ER4eLjw8PMSwYcPE/v37Dc/de++94vHHHzfafv369aJ3797Cw8ND9OvXT2zZssXKEbcMgCZ/Pv/8c8M2t17f0qVLDX+L4OBgMXnyZJGenm794Fvo0UcfFV27dhUeHh6iW7du4tFHHxVnz541PG/P908vKSlJABBZWVmNnrPH+5ecnNzk61J/HTqdTrz00ksiODhYqNVqMWbMmEbXHhERIVasWGH0mLn3sTWZu77s7GyT78vk5GTDMW69vuZe59Zk7voqKirE+PHjRWBgoHB3dxcRERFi0aJFjZIKW75/QjT/GhVCiI8//lh06NBBFBUVNXkMW76HLflsqKysFH/4wx9E586dRceOHcWDDz4o8vLyGh2n4T4tee8SkfWphBDCMnUuREREREREprHPCBERERERScFkhIiIiIiIpGAyQkREREREUjAZISIiIiIiKZiMEBERERGRFExGiIiIiIhICiYjREREREQkBZMRIiIiIiKSgskIETmsefPmYfr06dLOn5CQgNdff91ixz9x4gS6d++O8vJyi52DiIjIkjgDOxHZJZVKZfb5FStW4Nlnn4UQAn5+ftYJqoEjR45g9OjRyMnJgbe3t8XO8/DDDyMuLg4vvfSSxc5BRERkKUxGiMgu5efnG9bXrVuHl19+GVlZWYbHvL29LZoENGfhwoVwc3PDRx99ZNHzbNmyBYsWLUJubi7c3Nwsei4iIqL2xmZaRGSXQkJCDD++vr5QqVRGj3l7ezdqpjVq1Cg8/fTTWLp0KTp37ozg4GB8+umnKC8vx/z589GpUyfccccd+Omnn4zOdezYMUyaNAne3t4IDg5GQkICrl+/bjI2rVaLb7/9FlOnTjV6PDIyEq+99hrmzp0Lb29vRERE4IcffsC1a9cwbdo0eHt7Y8CAATh06JBhn5ycHEydOhWdO3eGl5cX+vXrh61btxqeHzduHAoLC7F79+7b/IsSERFZH5MRInIqX3zxBQICApCamoqnn34aixcvxiOPPIK77roL6enpGD9+PBISElBRUQEAKCoqwujRozFw4EAcOnQI27ZtQ0FBAWbOnGnyHEePHkVxcTGGDBnS6Ll3330XI0aMQEZGBqZMmYKEhATMnTsXjz32GNLT09GzZ0/MnTsX+krrxMREVFVVYc+ePcjMzMSbb75pVOPj4eGBO++8E7/88ks7/6WIiIgsj8kIETmVuLg4vPjii+jVqxdeeOEFeHp6IiAgAIsWLUKvXr3w8ssv48aNGzh69CgA4F//+hcGDhyI119/HdHR0Rg4cCBWrVqF5ORknD59uslz5OTkwNXVFUFBQY2emzx5Mp588knDuUpKSjB06FA88sgj6N27N5YvX46TJ0+ioKAAAJCbm4sRI0YgNjYWUVFRuP/++zFy5EijY4aGhiInJ6ed/1JERESWx2SEiJzKgAEDDOuurq7o0qULYmNjDY8FBwcDAK5evQpA6YienJxs6IPi7e2N6OhoAMC5c+eaPEdlZSXUanWTnewbnl9/LnPn/+Mf/4jXXnsNI0aMwIoVKwxJUkMdOnQw1OQQERHZEyYjRORU3N3djX5XqVRGj+kTCJ1OBwAoKyvD1KlTcfjwYaOfM2fONKqh0AsICEBFRQWqq6vNnl9/LnPnX7hwIc6fP4+EhARkZmZiyJAheP/9942OWVhYiMDAwJb9AYiIiGwIkxEiIjMGDRqE48ePIzIyEnfccYfRj5eXV5P73HnnnQCUeUDaQ1hYGJ566ils3LgRy5Ytw6effmr0/LFjxzBw4MB2ORcREZE1MRkhIjIjMTERhYWFmD17Ng4ePIhz584hKSkJ8+fPh1arbXKfwMBADBo0CL/++uttn3/p0qVISkpCdnY20tPTkZycjJiYGMPzFy5cwOXLlzF27NjbPhcREZG1MRkhIjIjNDQUe/fuhVarxfjx4xEbG4ulS5fCz88PLi6m/4UuXLgQX3/99W2fX6vVIjExETExMZg4cSJ69+6NDz74wPD82rVrMX78eERERNz2uYiIiKyNkx4SEVlAZWUl+vTpg3Xr1kGj0VjkHNXV1ejVqxfWrFmDESNGWOQcRERElsSaESIiC+jQoQO+/PJLs5Mj3q7c3Fz85S9/YSJCRER2izUjREREREQkBWtGiIiIiIhICiYjREREREQkBZMRIiIiIiKSgskIERERERFJwWSEiIiIiIikYDJCRERERERSMBkhIiIiIiIpmIwQEREREZEUTEaIiIiIiEiK/wWfO5XWD+3X8AAAAABJRU5ErkJggg==", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -842,21 +855,25 @@ "name": "stderr", "output_type": "stream", "text": [ + "ERROR: No footprint for SINEV/V1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/1212841228.py:12]\n", + "ERROR: No footprint for T/T1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/1212841228.py:12]\n", + "ERROR: No footprint for R/R1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/1212841228.py:12]\n", + "INFO: 0 warnings found while generating netlist.\n", + "INFO: 3 errors found while generating netlist.\n", "\n", - "No errors or warnings found during netlist generation.\n", - "\n" + "ERROR: No footprint for SINEV/V1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/1212841228.py:12]\n", + "ERROR: No footprint for T/T1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/1212841228.py:12]\n", + "ERROR: No footprint for R/R1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/1212841228.py:12]\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -922,21 +939,31 @@ "name": "stderr", "output_type": "stream", "text": [ + "ERROR: No footprint for SINEV/V1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/1446144757.py:25]\n", + "ERROR: No footprint for R/R1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/1446144757.py:25]\n", + "ERROR: No footprint for L/L1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/1446144757.py:25]\n", + "ERROR: No footprint for L/L2. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/1446144757.py:25]\n", + "ERROR: No footprint for R/R2. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/1446144757.py:25]\n", + "ERROR: No footprint for K/K1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/1446144757.py:25]\n", + "INFO: 0 warnings found while generating netlist.\n", + "INFO: 6 errors found while generating netlist.\n", "\n", - "No errors or warnings found during netlist generation.\n", - "\n" + "ERROR: No footprint for SINEV/V1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/1446144757.py:25]\n", + "ERROR: No footprint for R/R1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/1446144757.py:25]\n", + "ERROR: No footprint for L/L1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/1446144757.py:25]\n", + "ERROR: No footprint for L/L2. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/1446144757.py:25]\n", + "ERROR: No footprint for R/R2. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/1446144757.py:25]\n", + "ERROR: No footprint for K/K1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/1446144757.py:25]\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -1010,12 +1037,33 @@ } }, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "ERROR: No footprint for Q/Q1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/1015924567.py:17]\n", + "ERROR: No footprint for V/V1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/1015924567.py:17]\n", + "ERROR: No footprint for R/R1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/1015924567.py:17]\n", + "ERROR: No footprint for R/R2. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/1015924567.py:17]\n", + "ERROR: No footprint for R/R3. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/1015924567.py:17]\n", + "ERROR: No footprint for SINEV/V2. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/1015924567.py:17]\n", + "INFO: 0 warnings found while generating netlist.\n", + "INFO: 6 errors found while generating netlist.\n", + "\n", + "ERROR: No footprint for Q/Q1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/1015924567.py:17]\n", + "ERROR: No footprint for V/V1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/1015924567.py:17]\n", + "ERROR: No footprint for R/R1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/1015924567.py:17]\n", + "ERROR: No footprint for R/R2. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/1015924567.py:17]\n", + "ERROR: No footprint for R/R3. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/1015924567.py:17]\n", + "ERROR: No footprint for SINEV/V2. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/1015924567.py:17]\n" + ] + }, { "name": "stdout", "output_type": "stream", "text": [ ".title \n", - ".include /media/devb/Main/xesscorp/KiCad/tools/skidl/examples/spice-sim-intro/SpiceLib/2N2222A.lib\n", + ".include /home/jonathan/git_repos/skidl/tests/examples/spice-sim-intro/SpiceLib/2N2222A.lib\n", "Q1 N_1 N_2 0 2n2222a\n", "V1 N_3 0 5V\n", "R1 N_4 N_2 5kOhm\n", @@ -1025,25 +1073,14 @@ "\n" ] }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "No errors or warnings found during netlist generation.\n", - "\n" - ] - }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -1103,7 +1140,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 14, "metadata": { "ExecuteTime": { "end_time": "2021-04-29T13:33:01.955509Z", @@ -1111,6 +1148,25 @@ } }, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "ERROR: No footprint for SINEV/V1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/1744560864.py:51]\n", + "ERROR: No footprint for A/A1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/1744560864.py:51]\n", + "ERROR: No footprint for A/A2. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/1744560864.py:51]\n", + "ERROR: No footprint for A/A3. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/1744560864.py:51]\n", + "ERROR: No footprint for R/R1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/1744560864.py:51]\n", + "INFO: 0 warnings found while generating netlist.\n", + "INFO: 5 errors found while generating netlist.\n", + "\n", + "ERROR: No footprint for SINEV/V1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/1744560864.py:51]\n", + "ERROR: No footprint for A/A1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/1744560864.py:51]\n", + "ERROR: No footprint for A/A2. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/1744560864.py:51]\n", + "ERROR: No footprint for A/A3. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/1744560864.py:51]\n", + "ERROR: No footprint for R/R1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/1744560864.py:51]\n" + ] + }, { "name": "stdout", "output_type": "stream", @@ -1118,7 +1174,7 @@ ".title \n", "V1 N_1 0 DC 0V AC 1V SIN(1.65V 1.65V 100000000.0Hz 0s 0Hz)\n", "A1 [N_1] [N_2] adc\n", - "A2 N_2 N_3 buf\n", + "A2 N$2 N$3 buf\n", "A3 [N_3] [N_4] dac\n", "R1 N_4 0 1kOhm\n", ".model adc adc_bridge (fall_delay=1e-09s in_high=0.1V in_low=0.05V rise_delay=1e-09s)\n", @@ -1127,614 +1183,535 @@ "\n", " vin vout \n", "===============\n", - " 1.65 3.30\n", - " 1.65 3.30\n", - " 1.65 3.30\n", - " 1.65 3.30\n", - " 1.66 3.30\n", - " 1.67 3.30\n", - " 1.68 3.30\n", - " 1.72 3.30\n", - " 1.78 3.30\n", - " 1.89 3.30\n", - " 1.99 3.30\n", - " 2.09 3.30\n", - " 2.19 3.30\n", - " 2.28 3.30\n", - " 2.38 3.30\n", - " 2.47 3.30\n", - " 2.56 3.30\n", - " 2.64 3.30\n", - " 2.72 3.30\n", - " 2.80 3.30\n", - " 2.87 3.30\n", - " 2.94 3.30\n", - " 3.00 3.30\n", - " 3.06 3.30\n", - " 3.11 3.30\n", - " 3.16 3.30\n", - " 3.19 3.30\n", - " 3.23 3.30\n", - " 3.26 3.30\n", - " 3.28 3.30\n", - " 3.29 3.30\n", - " 3.30 3.30\n", - " 3.30 3.30\n", - " 3.29 3.30\n", - " 3.28 3.30\n", - " 3.27 3.30\n", - " 3.24 3.30\n", - " 3.21 3.30\n", - " 3.17 3.30\n", - " 3.13 3.30\n", - " 3.08 3.30\n", - " 3.03 3.30\n", - " 2.97 3.30\n", - " 2.90 3.30\n", - " 2.83 3.30\n", - " 2.76 3.30\n", - " 2.68 3.30\n", - " 2.60 3.30\n", - " 2.51 3.30\n", - " 2.42 3.30\n", - " 2.33 3.30\n", - " 2.23 3.30\n", - " 2.13 3.30\n", - " 2.03 3.30\n", - " 1.93 3.30\n", - " 1.83 3.30\n", - " 1.72 3.30\n", - " 1.62 3.30\n", - " 1.52 3.30\n", - " 1.41 3.30\n", - " 1.31 3.30\n", - " 1.21 3.30\n", - " 1.11 3.30\n", - " 1.02 3.30\n", - " 0.92 3.30\n", - " 0.83 3.30\n", - " 0.74 3.30\n", - " 0.66 3.30\n", - " 0.58 3.30\n", - " 0.50 3.30\n", - " 0.43 3.30\n", - " 0.36 3.30\n", - " 0.30 3.30\n", - " 0.24 3.30\n", - " 0.19 3.30\n", - " 0.14 3.30\n", - " 0.11 3.30\n", - " 0.07 3.30\n", - " 0.04 3.30\n", - " 0.02 3.30\n", - " 0.01 3.30\n", - " 0.00 3.30\n", - " 0.00 3.30\n", - " 0.01 3.30\n", - " 0.02 3.30\n", - " 0.03 3.30\n", - " 0.06 3.30\n", - " 0.09 3.30\n", - " 0.13 3.30\n", - " 0.17 3.30\n", - " 0.22 3.30\n", - " 0.27 3.30\n", - " 0.33 3.30\n", - " 0.40 3.30\n", - " 0.47 3.30\n", - " 0.54 3.30\n", - " 0.62 3.30\n", - " 0.70 3.30\n", - " 0.79 3.30\n", - " 0.88 3.07\n", - " 0.97 2.84\n", - " 1.07 2.61\n", - " 1.17 2.38\n", - " 1.27 2.15\n", - " 1.32 2.04\n", - " 1.42 1.81\n", - " 1.52 1.58\n", - " 1.58 1.46\n", - " 1.59 1.48\n", - " 1.61 1.53\n", - " 1.65 1.62\n", - " 1.73 1.80\n", - " 1.78 1.92\n", - " 1.79 1.94\n", - " 1.81 1.99\n", - " 1.85 2.08\n", - " 1.89 2.15\n", - " 1.89 2.17\n", - " 1.91 2.21\n", - " 1.94 2.28\n", - " 2.01 2.43\n", - " 2.11 2.66\n", - " 2.21 2.89\n", - " 2.30 3.12\n", - " 2.38 3.30\n", - " 2.39 3.30\n", - " 2.41 3.30\n", - " 2.44 3.30\n", - " 2.51 3.30\n", - " 2.60 3.30\n", - " 2.68 3.30\n", - " 2.76 3.30\n", - " 2.84 3.30\n", - " 2.91 3.30\n", - " 2.97 3.30\n", - " 3.03 3.30\n", - " 3.08 3.30\n", - " 3.13 3.30\n", - " 3.18 3.30\n", - " 3.21 3.30\n", - " 3.24 3.30\n", - " 3.27 3.30\n", - " 3.28 3.30\n", - " 3.30 3.30\n", - " 3.30 3.30\n", - " 3.30 3.30\n", - " 3.29 3.30\n", - " 3.27 3.30\n", - " 3.25 3.30\n", - " 3.23 3.30\n", - " 3.19 3.30\n", - " 3.15 3.30\n", - " 3.11 3.30\n", - " 3.06 3.30\n", - " 3.00 3.30\n", - " 2.94 3.30\n", - " 2.87 3.30\n", - " 2.80 3.30\n", - " 2.72 3.30\n", - " 2.64 3.30\n", - " 2.55 3.30\n", - " 2.46 3.30\n", - " 2.37 3.30\n", - " 2.28 3.30\n", - " 2.18 3.30\n", - " 2.08 3.30\n", - " 1.98 3.30\n", - " 1.88 3.30\n", - " 1.78 3.30\n", - " 1.67 3.30\n", - " 1.57 3.30\n", - " 1.47 3.30\n", - " 1.36 3.30\n", - " 1.26 3.30\n", - " 1.16 3.30\n", - " 1.06 3.30\n", - " 0.97 3.30\n", - " 0.88 3.30\n", - " 0.79 3.30\n", - " 0.70 3.30\n", - " 0.62 3.30\n", - " 0.54 3.30\n", - " 0.46 3.30\n", - " 0.39 3.30\n", - " 0.33 3.30\n", - " 0.27 3.30\n", - " 0.22 3.30\n", - " 0.17 3.30\n", - " 0.12 3.30\n", - " 0.09 3.30\n", - " 0.06 3.30\n", - " 0.03 3.30\n", - " 0.02 3.30\n", - " 0.00 3.30\n", - " 0.00 3.30\n", - " 0.00 3.30\n", - " 0.01 3.30\n", - " 0.03 3.30\n", - " 0.05 3.30\n", - " 0.07 3.30\n", - " 0.11 3.30\n", - " 0.15 3.30\n", - " 0.19 3.30\n", - " 0.24 3.30\n", - " 0.30 3.30\n", - " 0.36 3.30\n", - " 0.43 3.30\n", - " 0.50 3.30\n", - " 0.58 3.30\n", - " 0.66 3.30\n", - " 0.67 3.28\n", - " 0.69 3.23\n", - " 0.72 3.14\n", - " 0.79 2.95\n", - " 0.84 2.84\n", - " 0.84 2.82\n", - " 0.86 2.77\n", - " 0.90 2.68\n", - " 0.97 2.49\n", - " 1.07 2.26\n", - " 1.12 2.15\n", - " 1.13 2.13\n", - " 1.15 2.08\n", - " 1.19 1.99\n", - " 1.27 1.80\n", - " 1.37 1.57\n", - " 1.47 1.34\n", - " 1.58 1.11\n", - " 1.63 1.00\n", - " 1.64 1.00\n", - " 1.66 1.05\n", - " 1.70 1.14\n", - " 1.73 1.21\n", - " 1.74 1.23\n", - " 1.76 1.26\n", - " 1.79 1.34\n", - " 1.85 1.48\n", - " 1.96 1.71\n", - " 2.06 1.94\n", - " 2.15 2.15\n", - " 2.16 2.17\n", - " 2.18 2.22\n", - " 2.22 2.31\n", - " 2.29 2.50\n", - " 2.39 2.73\n", - " 2.48 2.96\n", - " 2.57 3.19\n", - " 2.61 3.30\n", - " 2.62 3.30\n", - " 2.63 3.30\n", - " 2.67 3.30\n", - " 2.73 3.30\n", - " 2.81 3.30\n", - " 2.88 3.30\n", - " 2.95 3.30\n", - " 3.01 3.30\n", - " 3.06 3.30\n", - " 3.11 3.30\n", - " 3.16 3.30\n", - " 3.20 3.30\n", - " 3.23 3.30\n", - " 3.26 3.30\n", - " 3.28 3.30\n", - " 3.29 3.30\n", - " 3.30 3.30\n", - " 3.30 3.30\n", - " 3.29 3.30\n", - " 3.28 3.30\n", - " 3.26 3.30\n", - " 3.24 3.30\n", - " 3.21 3.30\n", - " 3.17 3.30\n", - " 3.13 3.30\n", - " 3.08 3.30\n", - " 3.02 3.30\n", - " 2.96 3.30\n", - " 2.90 3.30\n", - " 2.83 3.30\n", - " 2.75 3.30\n", - " 2.67 3.30\n", - " 2.59 3.30\n", - " 2.50 3.30\n", - " 2.41 3.30\n", - " 2.32 3.30\n", - " 2.22 3.30\n", - " 2.12 3.30\n", - " 2.02 3.30\n", - " 1.92 3.30\n", - " 1.82 3.30\n", - " 1.71 3.30\n", - " 1.61 3.30\n", - " 1.51 3.30\n", - " 1.40 3.30\n", - " 1.30 3.30\n", - " 1.20 3.30\n", - " 1.10 3.30\n", - " 1.01 3.30\n", - " 0.91 3.30\n", - " 0.82 3.30\n", - " 0.73 3.30\n", - " 0.65 3.30\n", - " 0.57 3.30\n", - " 0.49 3.30\n", - " 0.42 3.30\n", - " 0.35 3.30\n", - " 0.29 3.30\n", - " 0.24 3.30\n", - " 0.19 3.30\n", - " 0.14 3.30\n", - " 0.10 3.30\n", - " 0.07 3.30\n", - " 0.04 3.30\n", - " 0.02 3.30\n", - " 0.01 3.30\n", - " 0.00 3.30\n", - " 0.00 3.30\n", - " 0.01 3.30\n", - " 0.02 3.30\n", - " 0.04 3.30\n", - " 0.06 3.30\n", - " 0.09 3.30\n", - " 0.13 3.30\n", - " 0.17 3.30\n", - " 0.22 3.30\n", - " 0.28 3.30\n", - " 0.34 3.30\n", - " 0.40 3.30\n", - " 0.47 3.30\n", - " 0.55 3.30\n", - " 0.63 3.30\n", - " 0.71 3.30\n", - " 0.72 3.28\n", - " 0.74 3.23\n", - " 0.77 3.14\n", - " 0.80 3.07\n", - " 0.81 3.05\n", - " 0.82 3.01\n", - " 0.85 2.94\n", - " 0.91 2.79\n", - " 1.00 2.56\n", - " 1.10 2.33\n", - " 1.18 2.15\n", - " 1.19 2.13\n", - " 1.21 2.08\n", - " 1.25 1.99\n", - " 1.33 1.80\n", - " 1.43 1.57\n", - " 1.53 1.34\n", - " 1.59 1.23\n", - " 1.60 1.25\n", - " 1.62 1.30\n", - " 1.66 1.39\n", - " 1.69 1.46\n", - " 1.70 1.48\n", - " 1.71 1.52\n", - " 1.75 1.59\n", - " 1.79 1.69\n", - " 1.80 1.70\n", - " 1.81 1.73\n", - " 1.84 1.79\n", - " 1.89 1.91\n", - " 1.99 2.14\n", - " 2.00 2.15\n", - " 2.01 2.17\n", - " 2.02 2.21\n", - " 2.05 2.28\n", - " 2.12 2.43\n", - " 2.22 2.66\n", - " 2.31 2.89\n", - " 2.41 3.12\n", - " 2.48 3.30\n", - " 2.49 3.30\n", - " 2.51 3.30\n", - " 2.54 3.30\n", - " 2.61 3.30\n", - " 2.69 3.30\n", - " 2.77 3.30\n", - " 2.84 3.30\n", - " 2.91 3.30\n", - " 2.98 3.30\n", - " 3.04 3.30\n", - " 3.09 3.30\n", - " 3.14 3.30\n", - " 3.18 3.30\n", - " 3.22 3.30\n", - " 3.25 3.30\n", - " 3.27 3.30\n", - " 3.29 3.30\n", - " 3.30 3.30\n", - " 3.30 3.30\n", - " 3.30 3.30\n", - " 3.29 3.30\n", - " 3.27 3.30\n", - " 3.25 3.30\n", - " 3.22 3.30\n", - " 3.19 3.30\n", - " 3.15 3.30\n", - " 3.10 3.30\n", - " 3.05 3.30\n", - " 2.99 3.30\n", - " 2.93 3.30\n", - " 2.86 3.30\n", - " 2.79 3.30\n", - " 2.71 3.30\n", - " 2.63 3.30\n", - " 2.54 3.30\n", - " 2.46 3.30\n", - " 2.36 3.30\n", - " 2.27 3.30\n", - " 2.17 3.30\n", - " 2.07 3.30\n", - " 1.97 3.30\n", - " 1.87 3.30\n", - " 1.77 3.30\n", - " 1.66 3.30\n", - " 1.56 3.30\n", - " 1.46 3.30\n", - " 1.35 3.30\n", - " 1.25 3.30\n", - " 1.15 3.30\n", - " 1.05 3.30\n", - " 0.96 3.30\n", - " 0.87 3.30\n", - " 0.78 3.30\n", - " 0.69 3.30\n", - " 0.61 3.30\n", - " 0.53 3.30\n", - " 0.46 3.30\n", - " 0.39 3.30\n", - " 0.32 3.30\n", - " 0.26 3.30\n", - " 0.21 3.30\n", - " 0.16 3.30\n", - " 0.12 3.30\n", - " 0.08 3.30\n", - " 0.05 3.30\n", - " 0.03 3.30\n", - " 0.01 3.30\n", - " 0.00 3.30\n", - " 0.00 3.30\n", - " 0.00 3.30\n", - " 0.01 3.30\n", - " 0.03 3.30\n", - " 0.05 3.30\n", - " 0.08 3.30\n", - " 0.11 3.30\n", - " 0.15 3.30\n", - " 0.20 3.30\n", - " 0.25 3.30\n", - " 0.31 3.30\n", - " 0.37 3.30\n", - " 0.44 3.30\n", - " 0.51 3.30\n", - " 0.59 3.30\n", - " 0.67 3.30\n", - " 0.68 3.28\n", - " 0.70 3.23\n", - " 0.73 3.14\n", - " 0.80 2.96\n", - " 0.84 2.84\n", - " 0.85 2.82\n", - " 0.87 2.77\n", - " 0.91 2.68\n", - " 0.98 2.50\n", - " 1.08 2.26\n", - " 1.13 2.15\n", - " 1.14 2.13\n", - " 1.16 2.08\n", - " 1.20 1.99\n", - " 1.28 1.81\n", - " 1.38 1.58\n", - " 1.48 1.35\n", - " 1.59 1.12\n", - " 1.64 1.00\n", " 1.65 1.00\n", - " 1.67 1.05\n", - " 1.71 1.14\n", - " 1.74 1.21\n", - " 1.75 1.23\n", - " 1.77 1.26\n", - " 1.80 1.34\n", - " 1.87 1.48\n", - " 1.97 1.71\n", - " 2.07 1.94\n", - " 2.16 2.15\n", - " 2.17 2.17\n", - " 2.19 2.22\n", - " 2.23 2.31\n", - " 2.30 2.49\n", - " 2.40 2.72\n", - " 2.49 2.95\n", - " 2.58 3.18\n", - " 2.62 3.30\n", - " 2.63 3.30\n", - " 2.64 3.30\n", - " 2.68 3.30\n", - " 2.74 3.30\n", - " 2.82 3.30\n", - " 2.89 3.30\n", - " 2.95 3.30\n", - " 3.01 3.30\n", - " 3.07 3.30\n", - " 3.12 3.30\n", - " 3.16 3.30\n", - " 3.20 3.30\n", - " 3.23 3.30\n", - " 3.26 3.30\n", - " 3.28 3.30\n", - " 3.29 3.30\n", - " 3.30 3.30\n", - " 3.30 3.30\n", - " 3.29 3.30\n", - " 3.28 3.30\n", - " 3.26 3.30\n", - " 3.24 3.30\n", - " 3.20 3.30\n", - " 3.17 3.30\n", - " 3.12 3.30\n", - " 3.07 3.30\n", - " 3.02 3.30\n", - " 2.96 3.30\n", - " 2.89 3.30\n", - " 2.82 3.30\n", - " 2.74 3.30\n", - " 2.66 3.30\n", - " 2.58 3.30\n", - " 2.49 3.30\n", - " 2.40 3.30\n", - " 2.31 3.30\n", - " 2.21 3.30\n", - " 2.11 3.30\n", - " 2.01 3.30\n", - " 1.91 3.30\n", - " 1.81 3.30\n", - " 1.70 3.30\n", - " 1.60 3.30\n", - " 1.50 3.30\n", - " 1.39 3.30\n", - " 1.29 3.30\n", - " 1.19 3.30\n", - " 1.09 3.30\n", - " 1.00 3.30\n", - " 0.90 3.30\n", - " 0.81 3.30\n", - " 0.72 3.30\n", - " 0.64 3.30\n", - " 0.56 3.30\n", - " 0.48 3.30\n", - " 0.41 3.30\n", - " 0.35 3.30\n", - " 0.29 3.30\n", - " 0.23 3.30\n", - " 0.18 3.30\n", - " 0.14 3.30\n", - " 0.10 3.30\n", - " 0.07 3.30\n", - " 0.04 3.30\n", - " 0.02 3.30\n", - " 0.01 3.30\n", - " 0.00 3.30\n", - " 0.00 3.30\n", - " 0.01 3.30\n", - " 0.02 3.30\n", - " 0.04 3.30\n", - " 0.06 3.30\n", - " 0.10 3.30\n", - " 0.13 3.30\n", - " 0.18 3.30\n", - " 0.23 3.30\n", - " 0.28 3.30\n", - " 0.34 3.30\n", - " 0.41 3.30\n", - " 0.48 3.30\n", - " 0.56 3.30\n", - " 0.64 3.30\n", - " 0.65 3.28\n", - " 0.66 3.23\n", - " 0.70 3.14\n", - " 0.76 2.96\n", - " 0.81 2.84\n", - " 0.82 2.82\n", - " 0.84 2.77\n", - " 0.87 2.68\n", - " 0.95 2.50\n", - " 1.04 2.26\n", - " 1.09 2.15\n", - " 1.10 2.13\n", - " 1.12 2.08\n", - " 1.16 1.99\n", - " 1.24 1.81\n", - " 1.34 1.58\n", - " 1.44 1.35\n", - " 1.54 1.12\n", - " 1.60 1.00\n", - " 1.60 1.00\n", - " 1.61 1.02\n", - " 1.63 1.07\n", - " 1.65 1.11\n" + " 1.65 1.00\n", + " 1.65 1.00\n", + " 1.65 1.00\n", + " 1.66 1.00\n", + " 1.67 1.00\n", + " 1.68 1.00\n", + " 1.72 1.00\n", + " 1.78 1.00\n", + " 1.89 1.00\n", + " 1.99 1.00\n", + " 2.09 1.00\n", + " 2.19 1.00\n", + " 2.28 1.00\n", + " 2.38 1.00\n", + " 2.47 1.00\n", + " 2.56 1.00\n", + " 2.64 1.00\n", + " 2.72 1.00\n", + " 2.80 1.00\n", + " 2.87 1.00\n", + " 2.94 1.00\n", + " 3.00 1.00\n", + " 3.06 1.00\n", + " 3.11 1.00\n", + " 3.16 1.00\n", + " 3.19 1.00\n", + " 3.23 1.00\n", + " 3.26 1.00\n", + " 3.28 1.00\n", + " 3.29 1.00\n", + " 3.30 1.00\n", + " 3.30 1.00\n", + " 3.29 1.00\n", + " 3.28 1.00\n", + " 3.27 1.00\n", + " 3.24 1.00\n", + " 3.21 1.00\n", + " 3.17 1.00\n", + " 3.13 1.00\n", + " 3.08 1.00\n", + " 3.03 1.00\n", + " 2.97 1.00\n", + " 2.90 1.00\n", + " 2.83 1.00\n", + " 2.76 1.00\n", + " 2.68 1.00\n", + " 2.60 1.00\n", + " 2.51 1.00\n", + " 2.42 1.00\n", + " 2.33 1.00\n", + " 2.23 1.00\n", + " 2.13 1.00\n", + " 2.03 1.00\n", + " 1.93 1.00\n", + " 1.83 1.00\n", + " 1.72 1.00\n", + " 1.62 1.00\n", + " 1.52 1.00\n", + " 1.41 1.00\n", + " 1.31 1.00\n", + " 1.21 1.00\n", + " 1.11 1.00\n", + " 1.02 1.00\n", + " 0.92 1.00\n", + " 0.83 1.00\n", + " 0.74 1.00\n", + " 0.66 1.00\n", + " 0.58 1.00\n", + " 0.50 1.00\n", + " 0.43 1.00\n", + " 0.36 1.00\n", + " 0.30 1.00\n", + " 0.24 1.00\n", + " 0.19 1.00\n", + " 0.14 1.00\n", + " 0.11 1.00\n", + " 0.07 1.00\n", + " 0.04 1.00\n", + " 0.02 1.00\n", + " 0.01 1.00\n", + " 0.00 1.00\n", + " 0.00 1.00\n", + " 0.01 1.00\n", + " 0.02 1.00\n", + " 0.03 1.00\n", + " 0.06 1.00\n", + " 0.09 1.00\n", + " 0.13 1.00\n", + " 0.17 1.00\n", + " 0.22 1.00\n", + " 0.27 1.00\n", + " 0.33 1.00\n", + " 0.40 1.00\n", + " 0.47 1.00\n", + " 0.54 1.00\n", + " 0.62 1.00\n", + " 0.70 1.00\n", + " 0.79 1.00\n", + " 0.88 1.00\n", + " 0.97 1.00\n", + " 1.07 1.00\n", + " 1.17 1.00\n", + " 1.27 1.00\n", + " 1.37 1.00\n", + " 1.47 1.00\n", + " 1.58 1.00\n", + " 1.68 1.00\n", + " 1.78 1.00\n", + " 1.89 1.00\n", + " 1.99 1.00\n", + " 2.09 1.00\n", + " 2.19 1.00\n", + " 2.28 1.00\n", + " 2.38 1.00\n", + " 2.47 1.00\n", + " 2.56 1.00\n", + " 2.64 1.00\n", + " 2.72 1.00\n", + " 2.80 1.00\n", + " 2.87 1.00\n", + " 2.94 1.00\n", + " 3.00 1.00\n", + " 3.06 1.00\n", + " 3.11 1.00\n", + " 3.16 1.00\n", + " 3.19 1.00\n", + " 3.23 1.00\n", + " 3.26 1.00\n", + " 3.28 1.00\n", + " 3.29 1.00\n", + " 3.30 1.00\n", + " 3.30 1.00\n", + " 3.29 1.00\n", + " 3.28 1.00\n", + " 3.27 1.00\n", + " 3.24 1.00\n", + " 3.21 1.00\n", + " 3.17 1.00\n", + " 3.13 1.00\n", + " 3.08 1.00\n", + " 3.03 1.00\n", + " 2.97 1.00\n", + " 2.90 1.00\n", + " 2.83 1.00\n", + " 2.76 1.00\n", + " 2.68 1.00\n", + " 2.60 1.00\n", + " 2.51 1.00\n", + " 2.42 1.00\n", + " 2.33 1.00\n", + " 2.23 1.00\n", + " 2.13 1.00\n", + " 2.03 1.00\n", + " 1.93 1.00\n", + " 1.83 1.00\n", + " 1.72 1.00\n", + " 1.62 1.00\n", + " 1.52 1.00\n", + " 1.41 1.00\n", + " 1.31 1.00\n", + " 1.21 1.00\n", + " 1.11 1.00\n", + " 1.02 1.00\n", + " 0.92 1.00\n", + " 0.83 1.00\n", + " 0.74 1.00\n", + " 0.66 1.00\n", + " 0.58 1.00\n", + " 0.50 1.00\n", + " 0.43 1.00\n", + " 0.36 1.00\n", + " 0.30 1.00\n", + " 0.24 1.00\n", + " 0.19 1.00\n", + " 0.14 1.00\n", + " 0.11 1.00\n", + " 0.07 1.00\n", + " 0.04 1.00\n", + " 0.02 1.00\n", + " 0.01 1.00\n", + " 0.00 1.00\n", + " 0.00 1.00\n", + " 0.01 1.00\n", + " 0.02 1.00\n", + " 0.03 1.00\n", + " 0.06 1.00\n", + " 0.09 1.00\n", + " 0.13 1.00\n", + " 0.17 1.00\n", + " 0.22 1.00\n", + " 0.27 1.00\n", + " 0.33 1.00\n", + " 0.40 1.00\n", + " 0.47 1.00\n", + " 0.54 1.00\n", + " 0.62 1.00\n", + " 0.70 1.00\n", + " 0.79 1.00\n", + " 0.88 1.00\n", + " 0.97 1.00\n", + " 1.07 1.00\n", + " 1.17 1.00\n", + " 1.27 1.00\n", + " 1.37 1.00\n", + " 1.47 1.00\n", + " 1.58 1.00\n", + " 1.68 1.00\n", + " 1.78 1.00\n", + " 1.89 1.00\n", + " 1.99 1.00\n", + " 2.09 1.00\n", + " 2.19 1.00\n", + " 2.28 1.00\n", + " 2.38 1.00\n", + " 2.47 1.00\n", + " 2.56 1.00\n", + " 2.64 1.00\n", + " 2.72 1.00\n", + " 2.80 1.00\n", + " 2.87 1.00\n", + " 2.94 1.00\n", + " 3.00 1.00\n", + " 3.06 1.00\n", + " 3.11 1.00\n", + " 3.16 1.00\n", + " 3.19 1.00\n", + " 3.23 1.00\n", + " 3.26 1.00\n", + " 3.28 1.00\n", + " 3.29 1.00\n", + " 3.30 1.00\n", + " 3.30 1.00\n", + " 3.29 1.00\n", + " 3.28 1.00\n", + " 3.27 1.00\n", + " 3.24 1.00\n", + " 3.21 1.00\n", + " 3.17 1.00\n", + " 3.13 1.00\n", + " 3.08 1.00\n", + " 3.03 1.00\n", + " 2.97 1.00\n", + " 2.90 1.00\n", + " 2.83 1.00\n", + " 2.76 1.00\n", + " 2.68 1.00\n", + " 2.60 1.00\n", + " 2.51 1.00\n", + " 2.42 1.00\n", + " 2.33 1.00\n", + " 2.23 1.00\n", + " 2.13 1.00\n", + " 2.03 1.00\n", + " 1.93 1.00\n", + " 1.83 1.00\n", + " 1.72 1.00\n", + " 1.62 1.00\n", + " 1.52 1.00\n", + " 1.41 1.00\n", + " 1.31 1.00\n", + " 1.21 1.00\n", + " 1.11 1.00\n", + " 1.02 1.00\n", + " 0.92 1.00\n", + " 0.83 1.00\n", + " 0.74 1.00\n", + " 0.66 1.00\n", + " 0.58 1.00\n", + " 0.50 1.00\n", + " 0.43 1.00\n", + " 0.36 1.00\n", + " 0.30 1.00\n", + " 0.24 1.00\n", + " 0.19 1.00\n", + " 0.14 1.00\n", + " 0.11 1.00\n", + " 0.07 1.00\n", + " 0.04 1.00\n", + " 0.02 1.00\n", + " 0.01 1.00\n", + " 0.00 1.00\n", + " 0.00 1.00\n", + " 0.01 1.00\n", + " 0.02 1.00\n", + " 0.03 1.00\n", + " 0.06 1.00\n", + " 0.09 1.00\n", + " 0.13 1.00\n", + " 0.17 1.00\n", + " 0.22 1.00\n", + " 0.27 1.00\n", + " 0.33 1.00\n", + " 0.40 1.00\n", + " 0.47 1.00\n", + " 0.54 1.00\n", + " 0.62 1.00\n", + " 0.70 1.00\n", + " 0.79 1.00\n", + " 0.88 1.00\n", + " 0.97 1.00\n", + " 1.07 1.00\n", + " 1.17 1.00\n", + " 1.27 1.00\n", + " 1.37 1.00\n", + " 1.47 1.00\n", + " 1.58 1.00\n", + " 1.68 1.00\n", + " 1.78 1.00\n", + " 1.89 1.00\n", + " 1.99 1.00\n", + " 2.09 1.00\n", + " 2.19 1.00\n", + " 2.28 1.00\n", + " 2.38 1.00\n", + " 2.47 1.00\n", + " 2.56 1.00\n", + " 2.64 1.00\n", + " 2.72 1.00\n", + " 2.80 1.00\n", + " 2.87 1.00\n", + " 2.94 1.00\n", + " 3.00 1.00\n", + " 3.06 1.00\n", + " 3.11 1.00\n", + " 3.16 1.00\n", + " 3.19 1.00\n", + " 3.23 1.00\n", + " 3.26 1.00\n", + " 3.28 1.00\n", + " 3.29 1.00\n", + " 3.30 1.00\n", + " 3.30 1.00\n", + " 3.29 1.00\n", + " 3.28 1.00\n", + " 3.27 1.00\n", + " 3.24 1.00\n", + " 3.21 1.00\n", + " 3.17 1.00\n", + " 3.13 1.00\n", + " 3.08 1.00\n", + " 3.03 1.00\n", + " 2.97 1.00\n", + " 2.90 1.00\n", + " 2.83 1.00\n", + " 2.76 1.00\n", + " 2.68 1.00\n", + " 2.60 1.00\n", + " 2.51 1.00\n", + " 2.42 1.00\n", + " 2.33 1.00\n", + " 2.23 1.00\n", + " 2.13 1.00\n", + " 2.03 1.00\n", + " 1.93 1.00\n", + " 1.83 1.00\n", + " 1.72 1.00\n", + " 1.62 1.00\n", + " 1.52 1.00\n", + " 1.41 1.00\n", + " 1.31 1.00\n", + " 1.21 1.00\n", + " 1.11 1.00\n", + " 1.02 1.00\n", + " 0.92 1.00\n", + " 0.83 1.00\n", + " 0.74 1.00\n", + " 0.66 1.00\n", + " 0.58 1.00\n", + " 0.50 1.00\n", + " 0.43 1.00\n", + " 0.36 1.00\n", + " 0.30 1.00\n", + " 0.24 1.00\n", + " 0.19 1.00\n", + " 0.14 1.00\n", + " 0.11 1.00\n", + " 0.07 1.00\n", + " 0.04 1.00\n", + " 0.02 1.00\n", + " 0.01 1.00\n", + " 0.00 1.00\n", + " 0.00 1.00\n", + " 0.01 1.00\n", + " 0.02 1.00\n", + " 0.03 1.00\n", + " 0.06 1.00\n", + " 0.09 1.00\n", + " 0.13 1.00\n", + " 0.17 1.00\n", + " 0.22 1.00\n", + " 0.27 1.00\n", + " 0.33 1.00\n", + " 0.40 1.00\n", + " 0.47 1.00\n", + " 0.54 1.00\n", + " 0.62 1.00\n", + " 0.70 1.00\n", + " 0.79 1.00\n", + " 0.88 1.00\n", + " 0.97 1.00\n", + " 1.07 1.00\n", + " 1.17 1.00\n", + " 1.27 1.00\n", + " 1.37 1.00\n", + " 1.47 1.00\n", + " 1.58 1.00\n", + " 1.68 1.00\n", + " 1.78 1.00\n", + " 1.89 1.00\n", + " 1.99 1.00\n", + " 2.09 1.00\n", + " 2.19 1.00\n", + " 2.28 1.00\n", + " 2.38 1.00\n", + " 2.47 1.00\n", + " 2.56 1.00\n", + " 2.64 1.00\n", + " 2.72 1.00\n", + " 2.80 1.00\n", + " 2.87 1.00\n", + " 2.94 1.00\n", + " 3.00 1.00\n", + " 3.06 1.00\n", + " 3.11 1.00\n", + " 3.16 1.00\n", + " 3.19 1.00\n", + " 3.23 1.00\n", + " 3.26 1.00\n", + " 3.28 1.00\n", + " 3.29 1.00\n", + " 3.30 1.00\n", + " 3.30 1.00\n", + " 3.29 1.00\n", + " 3.28 1.00\n", + " 3.27 1.00\n", + " 3.24 1.00\n", + " 3.21 1.00\n", + " 3.17 1.00\n", + " 3.13 1.00\n", + " 3.08 1.00\n", + " 3.03 1.00\n", + " 2.97 1.00\n", + " 2.90 1.00\n", + " 2.83 1.00\n", + " 2.76 1.00\n", + " 2.68 1.00\n", + " 2.60 1.00\n", + " 2.51 1.00\n", + " 2.42 1.00\n", + " 2.33 1.00\n", + " 2.23 1.00\n", + " 2.13 1.00\n", + " 2.03 1.00\n", + " 1.93 1.00\n", + " 1.83 1.00\n", + " 1.72 1.00\n", + " 1.62 1.00\n", + " 1.52 1.00\n", + " 1.41 1.00\n", + " 1.31 1.00\n", + " 1.21 1.00\n", + " 1.11 1.00\n", + " 1.02 1.00\n", + " 0.92 1.00\n", + " 0.83 1.00\n", + " 0.74 1.00\n", + " 0.66 1.00\n", + " 0.58 1.00\n", + " 0.50 1.00\n", + " 0.43 1.00\n", + " 0.36 1.00\n", + " 0.30 1.00\n", + " 0.24 1.00\n", + " 0.19 1.00\n", + " 0.14 1.00\n", + " 0.11 1.00\n", + " 0.07 1.00\n", + " 0.04 1.00\n", + " 0.02 1.00\n", + " 0.01 1.00\n", + " 0.00 1.00\n", + " 0.00 1.00\n", + " 0.01 1.00\n", + " 0.02 1.00\n", + " 0.03 1.00\n", + " 0.06 1.00\n", + " 0.09 1.00\n", + " 0.13 1.00\n", + " 0.17 1.00\n", + " 0.22 1.00\n", + " 0.27 1.00\n", + " 0.33 1.00\n", + " 0.40 1.00\n", + " 0.47 1.00\n", + " 0.54 1.00\n", + " 0.62 1.00\n", + " 0.70 1.00\n", + " 0.79 1.00\n", + " 0.88 1.00\n", + " 0.97 1.00\n", + " 1.07 1.00\n", + " 1.17 1.00\n", + " 1.27 1.00\n", + " 1.37 1.00\n", + " 1.47 1.00\n", + " 1.58 1.00\n", + " 1.65 1.00\n" ] }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "No errors or warnings found during netlist generation.\n", - "\n" - ] + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ @@ -1799,7 +1776,10 @@ "print('{:^7s}{:^7s}'.format('vin', 'vout'))\n", "print('='*15)\n", "for v1, v2 in zip(vin.as_ndarray(), vout.as_ndarray()):\n", - " print('{:6.2f} {:6.2f}'.format(v1, v2))" + " print('{:6.2f} {:6.2f}'.format(v1, v2))\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.plot(vin, vout)" ] }, { @@ -1920,7 +1900,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 15, "metadata": { "ExecuteTime": { "end_time": "2021-04-29T13:33:02.621663Z", @@ -1929,35 +1909,39 @@ }, "outputs": [ { - "name": "stdout", + "name": "stderr", "output_type": "stream", "text": [ + "ERROR: No footprint for V/VIN. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/2366597661.py:13]\n", + "ERROR: No footprint for ncp1117_33-x/X1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/2366597661.py:13]\n", + "ERROR: No footprint for R/R1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/2366597661.py:13]\n", + "INFO: 0 warnings found while generating netlist.\n", + "INFO: 3 errors found while generating netlist.\n", "\n", - " ncp1117_33-x (): 1.0a low-dropout positive fixed and adjustable voltage regulators\n", - " Pin X1/3/in/UNSPECIFIED\n", - " Pin X1/1/out/UNSPECIFIED\n", - " Pin X1/2/gnd/UNSPECIFIED\n" + "ERROR: No footprint for V/VIN. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/2366597661.py:13]\n", + "ERROR: No footprint for ncp1117_33-x/X1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/2366597661.py:13]\n", + "ERROR: No footprint for R/R1. @ [/home/jonathan/python_envs/skidl/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3460=>/tmp/ipykernel_172636/2366597661.py:13]\n" ] }, { - "name": "stderr", + "name": "stdout", "output_type": "stream", "text": [ "\n", - "No errors or warnings found during netlist generation.\n", - "\n" + " ncp1117_33-x (ncp1117_33-x): 1.0a low-dropout positive fixed and adjustable voltage regulators\n", + " Pin X1/3/in,p3,in/UNSPECIFIED\n", + " Pin X1/1/out,out,p1/UNSPECIFIED\n", + " Pin X1/2/gnd,p2,gnd/UNSPECIFIED\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -2102,7 +2086,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, "metadata": { "ExecuteTime": { "end_time": "2021-04-29T13:33:02.662351Z", @@ -2114,187 +2098,187 @@ "name": "stdout", "output_type": "stream", "text": [ - "A (XSPICE, xspice): XSPICE code module\n", + "A (XSPICE, A, xspice): XSPICE code module\n", "\tPins: \n", "\tAttributes: model\n", "\n", - "B (BEHAVIORALSOURCE, behavioralsource, behavsrc, BEHAVSRC): Behavioral (arbitrary) source\n", + "B (behavioralsource, BEHAVSRC, BEHAVIORALSOURCE, B, behavsrc): Behavioral (arbitrary) source\n", "\tPins: p, n\n", "\tAttributes: i, i_expression, v, v_expression, tc1, tc2, temp, temperature, dtemp, device_temperature, p, n\n", "\n", - "C (CAP, cap): Capacitor\n", + "C (cap, C, CAP): Capacitor\n", "\tPins: p, n\n", "\tAttributes: value, capacitance, model, multiplier, m, scale, temp, temperature, dtemp, device_temperature, ic, initial_condition, p, n\n", "\n", - "BEHAVCAP (behavioralcap, BEHAVIORALCAP, behavcap): Behavioral capacitor\n", + "BEHAVCAP (behavioralcap, BEHAVIORALCAP, BEHAVCAP, behavcap): Behavioral capacitor\n", "\tPins: p, n\n", "\tAttributes: expression, tc1, tc2, p, n\n", "\n", - "SEMICAP (semicap, SEMICONDUCTORCAP, semiconductorcap): Semiconductor capacitor\n", + "SEMICAP (semiconductorcap, semicap, SEMICAP, SEMICONDUCTORCAP): Semiconductor capacitor\n", "\tPins: p, n\n", "\tAttributes: value, model, length, l, width, w, multiplier, m, scale, temp, temperature, dtemp, device_temperature, ic, initial_condition, p, n\n", "\n", - "D (diode, DIODE): Diode\n", + "D (D, diode, DIODE): Diode\n", "\tPins: p, n\n", "\tAttributes: model, area, multiplier, m, pj, off, ic, initial_condition, temp, temperature, dtemp, device_temperature, p, n\n", "\n", - "E (vcvs, VCVS): Voltage-controlled voltage source\n", + "E (vcvs, VCVS, E): Voltage-controlled voltage source\n", "\tPins: ip, in, op, on\n", "\tAttributes: gain, voltage_gain, op, on, ip, in\n", "\n", - "NONLINV (NONLINEARVOLTAGESOURCE, nonlinv, nonlinearvoltagesource): Nonlinear voltage source\n", + "NONLINV (NONLINEARVOLTAGESOURCE, nonlinearvoltagesource, NONLINV, nonlinv): Nonlinear voltage source\n", "\tPins: p, n\n", "\tAttributes: expression, table, p, n\n", "\n", - "F (cccs, CCCS): Current-controlled current source\n", + "F (cccs, F, CCCS): Current-controlled current source\n", "\tPins: p, n\n", "\tAttributes: control, source, gain, current_gain, multiplier, m, p, n\n", "\n", - "G (): Voltage-controlled current source\n", + "G (G): Voltage-controlled current source\n", "\tPins: ip, in, op, on\n", "\tAttributes: gain, current_gain, multiplier, m, op, on, ip, in\n", "\n", - "NONLINI (nonlinearcurrentsource, NONLINEARCURRENTSOURCE, nonlinvi): Nonlinear current source\n", + "NONLINI (nonlinvi, nonlinearcurrentsource, NONLINEARCURRENTSOURCE, NONLINI): Nonlinear current source\n", "\tPins: p, n\n", "\tAttributes: expression, table, p, n\n", "\n", - "H (ccvs, CCVS): Current-controlled voltage source\n", + "H (H, ccvs, CCVS): Current-controlled voltage source\n", "\tPins: p, n\n", "\tAttributes: control, source, transresistance, p, n\n", "\n", - "I (CS, cs, i): Current source\n", + "I (CS, cs, I, i): Current source\n", "\tPins: p, n\n", "\tAttributes: value, dc_value, p, n\n", "\n", - "J (jfet, JFET): Junction field-effect transistor\n", + "J (J, jfet, JFET): Junction field-effect transistor\n", "\tPins: d, g, s\n", "\tAttributes: model, area, multiplier, m, off, ic, initial_condition, temp, temperature, d, g, s\n", "\n", - "K (): Coupled (mutual) inductors\n", + "K (K): Coupled (mutual) inductors\n", "\tPins: \n", "\tAttributes: ind1, ind2, coupling\n", "\n", - "L (): Inductor\n", + "L (L): Inductor\n", "\tPins: p, n\n", "\tAttributes: value, inductance, model, nt, multiplier, m, scale, temp, temperature, dtemp, device_temperature, ic, initial_condition, p, n\n", "\n", - "BEHAVIND (behavind, behavioralind, BEHAVIORALIND): Behavioral inductor\n", + "BEHAVIND (BEHAVIORALIND, behavind, behavioralind, BEHAVIND): Behavioral inductor\n", "\tPins: p, n\n", "\tAttributes: expression, tc1, tc2, p, n\n", "\n", - "M (fet, MOSFET, mosfet, FET): Metal-oxide field-effect transistor\n", + "M (M, fet, mosfet, FET, MOSFET): Metal-oxide field-effect transistor\n", "\tPins: d, g, s, b\n", "\tAttributes: model, multiplier, m, l, length, w, width, drain_area, source_area, drain_perimeter, source_perimeter, drain_number_square, source_number_square, off, ic, initial_condition, temp, temperature, d, g, s, b\n", "\n", - "N (): Numerical device for GSS\n", + "N (N): Numerical device for GSS\n", "\tPins: \n", "\tAttributes: \n", "\n", - "O (): Lossy transmission line\n", + "O (O): Lossy transmission line\n", "\tPins: ip, in, op, on\n", "\tAttributes: model, op, on, ip, in\n", "\n", - "P (): Coupled multiconductor line\n", + "P (P): Coupled multiconductor line\n", "\tPins: \n", "\tAttributes: model, length, l, op, on, ip, in\n", "\n", - "Q (bjt, BJT): Bipolar Junction Transistor\n", + "Q (bjt, Q, BJT): Bipolar Junction Transistor\n", "\tPins: c, b, e, s\n", "\tAttributes: model, area, areab, areac, multiplier, m, off, ic, initial_condition, temp, temperature, dtemp, device_temperature, c, b, e, s\n", "\n", - "R (): Resistor\n", + "R (R): Resistor\n", "\tPins: p, n\n", "\tAttributes: value, resistance, ac, multiplier, m, scale, temp, temperature, dtemp, device_temperature, noisy, p, n\n", "\n", - "BEHAVRES (behavioralresistor, BEHAVIORALRESISTOR, behavres): Behavioral resistor\n", + "BEHAVRES (BEHAVIORALRESISTOR, behavres, behavioralresistor, BEHAVRES): Behavioral resistor\n", "\tPins: p, n\n", "\tAttributes: expression, tc1, tc2, p, n\n", "\n", - "SEMIRES (semires, semiconductorresistor, SEMICONDUCTORRESISTOR): Semiconductor resistor\n", + "SEMIRES (semires, SEMIRES, SEMICONDUCTORRESISTOR, semiconductorresistor): Semiconductor resistor\n", "\tPins: p, n\n", "\tAttributes: value, capacitance, model, ac, length, l, width, w, multiplier, m, scale, temp, temperature, dtemp, device_temperature, noisy, p, n\n", "\n", - "S (VCS, vcs): Voltage-controlled switch\n", + "S (vcs, VCS, S): Voltage-controlled switch\n", "\tPins: ip, in, op, on\n", "\tAttributes: model, initial_state, op, on, ip, in\n", "\n", - "T (TRANSMISSIONLINE, transmissionline): Transmission line\n", + "T (T, transmissionline, TRANSMISSIONLINE): Transmission line\n", "\tPins: ip, in, op, on\n", "\tAttributes: impedance, Z0, time_delay, TD, frequency, F, normalized_length, NL, op, on, ip, in\n", "\n", - "U (): Uniformly-distributed RC line\n", + "U (U): Uniformly-distributed RC line\n", "\tPins: o, i, cn\n", "\tAttributes: model, length, l, number_of_lumps, m, o, i, cn\n", "\n", - "V (ammeter, vs, VS, AMMETER, v): Voltage source\n", + "V (ammeter, vs, AMMETER, V, VS, v): Voltage source\n", "\tPins: p, n\n", "\tAttributes: value, dc_value, p, n\n", "\n", - "W (CCS, ccs): Current-controlled switch\n", + "W (ccs, W, CCS): Current-controlled switch\n", "\tPins: p, n\n", "\tAttributes: control, source, model, initial_state, p, n\n", "\n", - "Y (): Single lossy transmission line\n", + "Y (Y): Single lossy transmission line\n", "\tPins: ip, in, op, on\n", "\tAttributes: model, length, l, op, on, ip, in\n", "\n", - "Z (MESFET, mesfet): Metal-semiconductor field-effect transistor\n", + "Z (MESFET, Z, mesfet): Metal-semiconductor field-effect transistor\n", "\tPins: d, g, s\n", "\tAttributes: model, area, multiplier, m, off, ic, initial_condition, d, g, s\n", "\n", - "SINEV (sinev, SINUSOIDALVOLTAGE, sinusoidalvoltage): Sinusoidal voltage source\n", + "SINEV (SINUSOIDALVOLTAGE, SINEV, sinev, sinusoidalvoltage): Sinusoidal voltage source\n", "\tPins: p, n\n", "\tAttributes: dc_offset, ac_magnitude, ac_phase, offset, amplitude, frequency, delay, damping_factor, p, n\n", "\n", - "SINEI (SINUSOIDALCURRENT, sinei, sinusoidalcurrent): Sinusoidal current source\n", + "SINEI (sinusoidalcurrent, SINUSOIDALCURRENT, sinei, SINEI): Sinusoidal current source\n", "\tPins: p, n\n", "\tAttributes: dc_offset, ac_magnitude, ac_phase, offset, amplitude, frequency, delay, damping_factor, p, n\n", "\n", - "PULSEV (pulsevoltage, PULSEVOLTAGE, pulsev): Pulsed voltage source\n", + "PULSEV (pulsevoltage, pulsev, PULSEV, PULSEVOLTAGE): Pulsed voltage source\n", "\tPins: p, n\n", "\tAttributes: initial_value, pulsed_value, delay_time, rise_time, fall_time, pulse_width, period, p, n\n", "\n", - "PULSEI (pulsecurrent, PULSECURRENT, pulsei): Pulsed current source\n", + "PULSEI (pulsecurrent, PULSECURRENT, PULSEI, pulsei): Pulsed current source\n", "\tPins: p, n\n", "\tAttributes: initial_value, pulsed_value, delay_time, rise_time, fall_time, pulse_width, period, p, n\n", "\n", - "EXPV (expv, exponentialvoltage, EXPONENTIALVOLTAGE): Exponential voltage source\n", + "EXPV (expv, EXPONENTIALVOLTAGE, EXPV, exponentialvoltage): Exponential voltage source\n", "\tPins: p, n\n", "\tAttributes: initial_value, pulsed_value, rise_delay_time, rise_time_constant, fall_delay_time, fall_time_constant, p, n\n", "\n", - "EXPI (exponentialcurrent, EXPONENTIALCURRENT, expi): Exponential current source\n", + "EXPI (EXPI, expi, exponentialcurrent, EXPONENTIALCURRENT): Exponential current source\n", "\tPins: p, n\n", "\tAttributes: initial_value, pulsed_value, rise_delay_time, rise_time_constant, fall_delay_time, fall_time_constant, p, n\n", "\n", - "PWLV (PIECEWISELINEARVOLTAGE, pwlv, piecewiselinearvoltage): Piecewise linear voltage source\n", + "PWLV (piecewiselinearvoltage, PWLV, pwlv, PIECEWISELINEARVOLTAGE): Piecewise linear voltage source\n", "\tPins: p, n\n", "\tAttributes: values, repeate_time, delay_time, p, n\n", "\n", - "PWLI (pwli, piecewiselinearcurrent, PIECEWISELINEARCURRENT): Piecewise linear current source\n", + "PWLI (pwli, PIECEWISELINEARCURRENT, piecewiselinearcurrent, PWLI): Piecewise linear current source\n", "\tPins: p, n\n", "\tAttributes: values, repeate_time, delay_time, p, n\n", "\n", - "FMV (SFFMV, SINGLEFREQUENCYFMVOLTAGE, sffmv, singlefrequencyfmvoltage, fmv): Single-frequency FM-modulated voltage source\n", + "FMV (singlefrequencyfmvoltage, sffmv, fmv, SFFMV, FMV, SINGLEFREQUENCYFMVOLTAGE): Single-frequency FM-modulated voltage source\n", "\tPins: p, n\n", "\tAttributes: offset, amplitude, carrier_frequency, modulation_index, signal_frequency, p, n\n", "\n", - "FMI (singlefrequencyfmcurrent, fmi, sffmi, SFFMI, SINGLEFREQUENCYFMCURRENT): Single-frequency FM-modulated current source\n", + "FMI (SFFMI, singlefrequencyfmcurrent, fmi, SINGLEFREQUENCYFMCURRENT, sffmi, FMI): Single-frequency FM-modulated current source\n", "\tPins: p, n\n", "\tAttributes: offset, amplitude, carrier_frequency, modulation_index, signal_frequency, p, n\n", "\n", - "AMV (AMPLITUDEMODULATEDVOLTAGE, amplitudemodulatedvoltage, amv): Amplitude-modulated voltage source\n", + "AMV (amv, AMV, amplitudemodulatedvoltage, AMPLITUDEMODULATEDVOLTAGE): Amplitude-modulated voltage source\n", "\tPins: p, n\n", "\tAttributes: offset, amplitude, carrier_frequency, modulating_frequency, signal_delay, p, n\n", "\n", - "AMI (AMPLITUDEMODULATEDCURRENT, ami, amplitudemodulatedcurrent): Amplitude-modulated current source\n", + "AMI (ami, amplitudemodulatedcurrent, AMPLITUDEMODULATEDCURRENT, AMI): Amplitude-modulated current source\n", "\tPins: p, n\n", "\tAttributes: offset, amplitude, carrier_frequency, modulating_frequency, signal_delay, p, n\n", "\n", - "RNDV (randomvoltage, rndv, RANDOMVOLTAGE): Random voltage source\n", + "RNDV (rndv, randomvoltage, RNDV, RANDOMVOLTAGE): Random voltage source\n", "\tPins: p, n\n", "\tAttributes: random_type, duration, time_delay, parameter1, parameter2, p, n\n", "\n", - "RNDI (RANDOMCURRENT, randomcurrent, rndi): Random current source\n", + "RNDI (rndi, RANDOMCURRENT, randomcurrent, RNDI): Random current source\n", "\tPins: p, n\n", "\tAttributes: random_type, duration, time_delay, parameter1, parameter2, p, n\n", "\n" @@ -2444,7 +2428,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -2458,7 +2442,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.9" + "version": "3.10.6" }, "toc": { "base_numbering": 1,