From c3787e483e5adc940bac6054116ac4ba78765cc6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Johannes=20K=C3=B6ster?= Date: Sat, 29 Jan 2022 00:45:41 +0100 Subject: [PATCH 01/45] started rewriting report template --- snakemake/dag.py | 20 ++ snakemake/jobs.py | 15 +- snakemake/report/__init__.py | 71 ++++- snakemake/report/controller.js | 15 + snakemake/report/events.js | 3 + snakemake/report/logo.svg | 7 + snakemake/report/report.html.jinja2 | 456 +++++++--------------------- snakemake/report/style.css | 312 +++++++++++++++++++ 8 files changed, 526 insertions(+), 373 deletions(-) create mode 100644 snakemake/report/controller.js create mode 100644 snakemake/report/events.js create mode 100644 snakemake/report/logo.svg create mode 100644 snakemake/report/style.css diff --git a/snakemake/dag.py b/snakemake/dag.py index a50efc41c..beb3f8b06 100755 --- a/snakemake/dag.py +++ b/snakemake/dag.py @@ -2191,6 +2191,26 @@ def stats(self): yield tabulate(rows, headers="keys") yield "" + def toposorted(self, jobs=None, inherit_pipe_dependencies=False): + from toposort import toposort + + if jobs is None: + jobs = set(self.jobs) + + def get_dependencies(job): + for dep, files in self.dependencies[job].items(): + if dep in jobs: + yield dep + if inherit_pipe_dependencies and any(is_flagged(f, "pipe") for f in files): + # In case of a pipe, inherit the dependencies of the producer, + # such that the two jobs end up on the same toposort level. + # This is important because they are executed simulataneously. + yield from get_dependencies(dep) + + dag = {job: set(get_dependencies(job)) for job in jobs} + + return toposort(dag) + def __str__(self): return self.dot() diff --git a/snakemake/jobs.py b/snakemake/jobs.py index e7b0014d4..21e4763f5 100644 --- a/snakemake/jobs.py +++ b/snakemake/jobs.py @@ -1139,20 +1139,7 @@ def finalize(self): from toposort import toposort if self.toposorted is None: - - def get_dependencies(job): - for dep, files in self.dag.dependencies[job].items(): - if dep in self.jobs: - yield dep - if any(is_flagged(f, "pipe") for f in files): - # In case of a pipe, inherit the dependencies of the producer, - # such that the two jobs end up on the same toposort level. - # This is important because they are executed simulataneously. - yield from get_dependencies(dep) - - dag = {job: set(get_dependencies(job)) for job in self.jobs} - - self.toposorted = list(toposort(dag)) + self.toposorted = list(self.dag.toposorted(jobs=self.jobs, inherit_pipe_dependencies=True)) @property def all_products(self): diff --git a/snakemake/report/__init__.py b/snakemake/report/__init__.py index 8fe5c2cf8..7f4bf4120 100644 --- a/snakemake/report/__init__.py +++ b/snakemake/report/__init__.py @@ -44,7 +44,7 @@ from snakemake.exceptions import WorkflowError from snakemake.script import Snakemake from snakemake import __version__ -from snakemake.common import num_if_possible, lazy_property +from snakemake.common import is_local_file, num_if_possible, lazy_property from snakemake import logging @@ -104,6 +104,8 @@ def mime_from_file(file): def data_uri_from_file(file, defaultenc="utf8"): """Craft a base64 data URI from file with proper encoding and mimetype.""" + if isinstance(file, Path): + file = str(file) mime, encoding = mime_from_file(file) if encoding is None: encoding = defaultenc @@ -591,13 +593,61 @@ def encode_node(node): return {"nodes": nodes, "links": links}, xmax, ymax -def get_resource_as_string(url): - r = requests.get(url) - if r.status_code == requests.codes.ok: - return r.text - raise WorkflowError( - "Failed to download resource needed for " "report: {}".format(url) - ) +def rulegraph_spec(dag): + # get toposorting, and keep only one job of each rule per level + representatives = dict() + def get_representatives(level): + unique = dict() + for job in level: + if job.rule.name in unique: + representatives[job] = unique[job.rule.name] + else: + representatives[job] = job + unique[job.rule.name] = job + return sorted(unique.values(), key=lambda job: job.rule.name) + toposorted = [get_representatives(level) for level in dag.toposorted()] + + jobs = [ + job for level in toposorted + for job in level + ] + + nodes = [ + {"rule": job.rule.name, "fx": 10, "fy": i * 50} + for i, job in enumerate(jobs) + ] + idx = {job: i for i, job in enumerate(jobs)} + + def get_links(direct: bool): + for u in jobs: + for v in dag.dependencies[u]: + target = idx[u] + source = idx[representatives[v]] + if target - source == 1: + if not direct: + continue + else: + if direct: + continue + + yield {"target": target, "source": source, "value": 1} + + xmax = 100 + ymax = max(node["fy"] for node in nodes) + + return {"nodes": nodes, "links": list(get_links(direct=False)), "links_direct": list(get_links(direct=True))}, xmax, ymax + + +def get_resource_as_string(path_or_uri): + if is_local_file(path_or_uri): + return open(Path(__file__).parent / path_or_uri).read() + else: + r = requests.get(path_or_uri) + if r.status_code == requests.codes.ok: + return r.text + raise WorkflowError( + "Failed to download resource needed for " "report: {}".format(path_or_uri) + ) def auto_report(dag, path, stylesheet=None): @@ -808,6 +858,7 @@ def get_datetime(rectime): # rulegraph rulegraph, xmax, ymax = rulegraph_d3_spec(dag) + rulegraph, xmax, ymax = rulegraph_spec(dag) # configfiles configfiles = [ConfigfileRecord(f) for f in dag.workflow.configfiles] @@ -882,8 +933,8 @@ class Snakemake: text=text, rulegraph_nodes=rulegraph["nodes"], rulegraph_links=rulegraph["links"], - rulegraph_width=xmax + 20, - rulegraph_height=ymax + 20, + rulegraph_links_direct=rulegraph["links_direct"], + logo=data_uri_from_file(Path(__file__).parent / "logo.svg"), runtimes=runtimes, timeline=timeline, rules=[rec for recs in rules.values() for rec in recs], diff --git a/snakemake/report/controller.js b/snakemake/report/controller.js new file mode 100644 index 000000000..80f8d547b --- /dev/null +++ b/snakemake/report/controller.js @@ -0,0 +1,15 @@ +sidebar_controller = { + collapsed: false, + + toggle: function() { + if (this.collapsed) { + this.collapsed = false + $("#sidebar-content").show() + $("#show-hide-button svg").replaceWith(feather.icons["arrow-left"].toSvg()) + } else { + this.collapsed = true + $("#sidebar-content").hide() + $("#show-hide-button svg").replaceWith(feather.icons["arrow-right"].toSvg()) + } + } +} \ No newline at end of file diff --git a/snakemake/report/events.js b/snakemake/report/events.js new file mode 100644 index 000000000..0099e3198 --- /dev/null +++ b/snakemake/report/events.js @@ -0,0 +1,3 @@ +$("#show-hide-button").click(function() { + sidebar_controller.toggle() +}) \ No newline at end of file diff --git a/snakemake/report/logo.svg b/snakemake/report/logo.svg new file mode 100644 index 000000000..8362455cd --- /dev/null +++ b/snakemake/report/logo.svg @@ -0,0 +1,7 @@ + + + + + + + \ No newline at end of file diff --git a/snakemake/report/report.html.jinja2 b/snakemake/report/report.html.jinja2 index 43c231908..f24fa4758 100644 --- a/snakemake/report/report.html.jinja2 +++ b/snakemake/report/report.html.jinja2 @@ -15,289 +15,10 @@ - + {% if custom_stylesheet is not none %} - + {% endif %} @@ -310,75 +31,79 @@ {% endif %} - - -
-
- +
+
+ +
+
+ +
+
-

Workflow

- - {{ text }} -
- -

Click the nodes to obtain details about each step.

-
{% for cat, subcats in results|dictsort %} @@ -759,10 +484,7 @@ var rulegraph_spec = { "$schema": "https://vega.github.io/schema/vega/v5.json", - "width": {{ rulegraph_width }}, - "height": {{ rulegraph_height }}, "padding": 0, - "autosize": "none", "signals": [ { "name": "cx", "update": "width / 2" }, @@ -777,6 +499,10 @@ { "name": "link-data", "values": {{ rulegraph_links }} + }, + { + "name": "link-data-direct", + "values": {{ rulegraph_links_direct }} } ], @@ -810,10 +536,10 @@ "tooltip": { "value": "Click to show rule details." } }, "update": { - "size": {"value": 100} + "size": {"value": 70} }, "hover": { - "size": {"value": 200} + "size": {"value": 140} } }, @@ -825,8 +551,18 @@ "forces": [ { "force": "link", - "links": "link-data", - "distance": 25 + "links": "link-data" + } + ] + }, + { + "type": "force", + "iterations": 1, + "static": true, + "forces": [ + { + "force": "link", + "links": "link-data-direct" } ] } @@ -844,19 +580,20 @@ "text": {"field": "rule"}, "x": {"field": "fx", "scale": "x"}, "y": {"field": "fy", "scale": "y"}, - "dx": {"value": 5}, + "dx": {"value": -5}, "dy": {"value": -5}, + "align": { "value": "right" } } } }, { "type": "path", - "from": {"data": "link-data"}, + "from": {"data": "link-data-direct"}, "interactive": false, "encode": { "update": { "stroke": {"value": "#ccc"}, - "strokeWidth": {"value": 0.5} + "strokeWidth": {"value": 1.0} } }, "transform": [ @@ -866,6 +603,24 @@ "targetX": "datum.target.x", "targetY": "datum.target.y" } ] + }, + { + "type": "path", + "from": {"data": "link-data"}, + "interactive": false, + "encode": { + "update": { + "stroke": {"value": "#ccc"}, + "strokeWidth": {"value": 1.0} + } + }, + "transform": [ + { + "type": "linkpath", "shape": "curve", "orient": "horizontal", + "sourceX": "datum.source.x", "sourceY": "datum.source.y", + "targetX": "datum.target.x", "targetY": "datum.target.y" + } + ] } ] }; @@ -936,5 +691,8 @@ }, 2000); }); + + + diff --git a/snakemake/report/style.css b/snakemake/report/style.css new file mode 100644 index 000000000..83c65d16c --- /dev/null +++ b/snakemake/report/style.css @@ -0,0 +1,312 @@ +body { + font-size: .875rem; +} + +.feather { + width: 16px; + height: 16px; + vertical-align: text-bottom; +} + + +/* Sidebar */ + +.sidebar { + position: fixed; + top: 0; + bottom: 0; + left: 0; + z-index: 100; +} + +#sidebar-content { + display: flex; + flex-direction: column; + align-items: stretch; + padding-top: 15px; + padding-left: 0px; + padding-right: 0px; + height: 100vh; +} + +.sidebar-background { + opacity: 80%; + background-color: black; + color: white; +} + +.sidebar #nav { + flex-grow: 1; + overflow-y: auto; +} + +.sidebar p { + margin-left: 15px; + margin-right: 15px; +} + +.sidebar #title { + letter-spacing: 0.1em; +} + +.sidebar #title #logo { + height: 1.5em; + margin: 1em; + vertical-align: middle; +} + +.sidebar .nav-link { + font-weight: 500; + color: white; +} + +.sidebar .nav-link:hover { + font-weight: 500; + color: black; + background-color: white; +} + +.sidebar-heading { + font-size: .75rem; + text-transform: uppercase; +} + +.sidebar #show-hide-container { + height: 100vh; + display: flex; + justify-content: center; + align-items: center; +} + +.sidebar #show-hide-button { + padding-top: 3em; + padding-bottom: 3em; +} + +.sidebar #show-hide-button#hover { + color: grey; +} + + +/* Content */ + +[role="main"] { + padding-top: 65px; + /* Space for fixed navbar */ +} + +*[id]:before { + display: block; + content: " "; + margin-top: -75px; + height: 75px; + visibility: hidden; +} + + +/* Navbar */ + +.navbar-brand { + padding-top: .75rem; + padding-bottom: .75rem; + font-size: 1rem; + font-weight: bold; + background-color: rgba(0, 0, 0, .25); + box-shadow: inset -1px 0 0 rgba(0, 0, 0, .25); +} + +.navbar .form-control { + padding: .75rem 1rem; + border-width: 0; + border-radius: 0; +} + +.form-control-dark { + color: #fff; + background-color: rgba(255, 255, 255, .1); + border-color: rgba(255, 255, 255, .1); +} + +.form-control-dark:focus { + border-color: transparent; + box-shadow: 0 0 0 3px rgba(255, 255, 255, .25); +} + + +/* Utilities */ + +.border-top { + border-top: 1px solid #e5e5e5; +} + +.border-bottom { + border-bottom: 1px solid #e5e5e5; +} + + +/* Snakemake specific */ + +.result img { + max-width: 100vw; +} + +.result .preview { + text-align: center; +} + +#rulegraph canvas { + display: block; + max-width: 100vw; + margin-left: auto; + margin-right: auto; +} + +@keyframes fadeinout { + 0% { + opacity: 1; + } + 50% { + opacity: 0; + } + 100% { + opacity: 1; + } +} + +#loading-screen { + background-color: white; + width: 100%; + height: 100%; + position: fixed; + top: 0; + left: 0; + z-index: 2000; + padding-top: 50vh; +} + +p.animation { + animation: fadeinout 2.5s infinite; + text-align: center; + font-size: 200%; +} + +#loading-screen p#info { + text-align: center; + color: grey; +} + +#loading-screen p#jswarning { + text-align: center; + color: red; +} + +#panel-loading-screen { + width: 100%; + height: 100%; + padding-top: 50vh; +} + +#panel-loading-sceen p.animation { + margin: auto; +} + +.vega-actions .btn { + font-size: 100%; +} + +.plot { + text-align: center; +} + +h6.sidebar-heading { + text-transform: none; +} + +.preview { + text-align: right; +} + +.ekko-lightbox-nav-overlay a span { + color: lightgrey; +} + +.navbar { + opacity: 0.8; +} + +.source { + background: none !important; + overflow-x: auto; + width: 100%; +} + +table.dataTable tbody tr.selected, +table.dataTable tbody th.selected, +table.dataTable tbody td.selected { + color: black; + font-weight: bold; +} + +table.dataTable tbody tr.selected td:first-of-type { + font-weight: bold; +} + +table.dataTable tbody tr.selected td { + border-top: 1px solid #007bff; + border-bottom: 1px solid #007bff; +} + +table.dataTable tbody>tr.selected, +table.dataTable tbody>tr>.selected { + background-color: transparent; +} + +table.dataTable tbody tr.selected a, +table.dataTable tbody th.selected a, +table.dataTable tbody td.selected a { + color: #007bff; +} + +table caption { + display: none; +} + +table.results-table { + width: 100%; + margin-bottom: 4em; +} + +.rule-property { + overflow-y: auto; + max-height: 10em; +} + +.panel { + display: none; +} + +.panel#workflow { + display: block; +} + +.ruletable th { + width: 1px; +} + +.rule-properties ul { + padding-left: 1.2em; +} + +#thumbnail-modal .modal-body { + overflow: auto; + text-align: center; +} + +.category pre { + max-width: 20vw; + max-height: 10vh; +} + +.modal-lg { + max-width: 95%; +} \ No newline at end of file From 683b05230a15976399991cb531f3df1b1e57af0d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Johannes=20K=C3=B6ster?= Date: Wed, 2 Feb 2022 11:25:25 +0100 Subject: [PATCH 02/45] fixes --- snakemake/report/controller.js | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/snakemake/report/controller.js b/snakemake/report/controller.js index 80f8d547b..89b4e204b 100644 --- a/snakemake/report/controller.js +++ b/snakemake/report/controller.js @@ -1,5 +1,6 @@ sidebar_controller = { collapsed: false, + content: "nav", toggle: function() { if (this.collapsed) { @@ -11,5 +12,11 @@ sidebar_controller = { $("#sidebar-content").hide() $("#show-hide-button svg").replaceWith(feather.icons["arrow-right"].toSvg()) } + }, + + show: function(content) { + $(`#${this.content}`).hide() + $(`#${content}`).show() + this.content = content } } \ No newline at end of file From fa6b5ddae41f833e51c1612402fedf08edcb658a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Johannes=20K=C3=B6ster?= Date: Mon, 7 Feb 2022 22:38:30 +0100 Subject: [PATCH 03/45] minor --- snakemake/report/report.html.jinja2 | 4 ++-- snakemake/report/style.css | 3 +-- 2 files changed, 3 insertions(+), 4 deletions(-) diff --git a/snakemake/report/report.html.jinja2 b/snakemake/report/report.html.jinja2 index f24fa4758..eb529db93 100644 --- a/snakemake/report/report.html.jinja2 +++ b/snakemake/report/report.html.jinja2 @@ -33,7 +33,7 @@
-
+

Snakemake Report

@@ -90,7 +90,7 @@
- +
diff --git a/snakemake/report/style.css b/snakemake/report/style.css index 83c65d16c..58a24c5db 100644 --- a/snakemake/report/style.css +++ b/snakemake/report/style.css @@ -27,12 +27,11 @@ body { padding-left: 0px; padding-right: 0px; height: 100vh; + transition: width 2s; } .sidebar-background { opacity: 80%; - background-color: black; - color: white; } .sidebar #nav { From ea3dd56d21b31b5cae30948b716acc4c513d79c3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Johannes=20K=C3=B6ster?= Date: Fri, 18 Feb 2022 23:23:35 +0100 Subject: [PATCH 04/45] polishing --- snakemake/report/__init__.py | 2 +- snakemake/report/report.html.jinja2 | 23 +++++++++++++++-------- snakemake/report/style.css | 9 ++++++--- 3 files changed, 22 insertions(+), 12 deletions(-) diff --git a/snakemake/report/__init__.py b/snakemake/report/__init__.py index 79a69c9a1..38adf1f1e 100644 --- a/snakemake/report/__init__.py +++ b/snakemake/report/__init__.py @@ -949,7 +949,7 @@ class Snakemake: runtimes=runtimes, timeline=timeline, rules=[rec for recs in rules.values() for rec in recs], - version=__version__, + version=__version__.split("+")[0], now=now, pygments_css=HtmlFormatter(style="trac").get_style_defs(".source"), custom_stylesheet=custom_stylesheet, diff --git a/snakemake/report/report.html.jinja2 b/snakemake/report/report.html.jinja2 index eb529db93..5cc9f99b3 100644 --- a/snakemake/report/report.html.jinja2 +++ b/snakemake/report/report.html.jinja2 @@ -37,10 +37,11 @@

Snakemake Report

-
-

{{ text }}

-
+ + + +
  • {{ now }}
    • @@ -92,14 +96,17 @@
    + + +
-
-
-
+
+
+
@@ -121,10 +128,10 @@
{% endfor %} -
+

Statistics

If the workflow has been executed in cluster/cloud, runtimes include the waiting time in the queue. -
+
diff --git a/snakemake/report/style.css b/snakemake/report/style.css index 58a24c5db..4a899208d 100644 --- a/snakemake/report/style.css +++ b/snakemake/report/style.css @@ -77,13 +77,16 @@ body { align-items: center; } -.sidebar #show-hide-button { +#show-hide-button { padding-top: 3em; padding-bottom: 3em; + border: 1px solid #343a40; } -.sidebar #show-hide-button#hover { - color: grey; +#show-hide-button#hover { + color: black; + background-color: white!important; + border: 1px solid #343a40; } From 22c1eb130097eaec2f4cfa6396a1b3e68cc9b061 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Johannes=20K=C3=B6ster?= Date: Wed, 9 Mar 2022 11:52:37 +0100 Subject: [PATCH 05/45] react+tailwind based report (experiment) --- playground/react/categories.js | 21 +++ playground/react/components/abstract_menu.js | 27 +++ .../react/components/abstract_results.js | 151 +++++++++++++++++ playground/react/components/app.js | 23 +++ playground/react/components/breadcrumbs.js | 103 ++++++++++++ playground/react/components/category.js | 22 +++ playground/react/components/common.js | 17 ++ playground/react/components/content.js | 26 +++ playground/react/components/icon.js | 48 ++++++ playground/react/components/list_heading.js | 11 ++ playground/react/components/list_item.js | 15 ++ playground/react/components/menu.js | 69 ++++++++ playground/react/components/navbar.js | 155 ++++++++++++++++++ playground/react/components/result_info.js | 148 +++++++++++++++++ playground/react/components/rulegraph.js | 31 ++++ playground/react/components/search_results.js | 47 ++++++ playground/react/components/stats.js | 27 +++ playground/react/components/subcategory.js | 21 +++ playground/react/index.html | 51 ++++++ playground/react/logo.svg | 7 + playground/react/results.js | 92 +++++++++++ playground/react/rulegraph.js | 142 ++++++++++++++++ playground/react/runtimes.js | 15 ++ playground/react/timeline.js | 20 +++ 24 files changed, 1289 insertions(+) create mode 100644 playground/react/categories.js create mode 100644 playground/react/components/abstract_menu.js create mode 100644 playground/react/components/abstract_results.js create mode 100644 playground/react/components/app.js create mode 100644 playground/react/components/breadcrumbs.js create mode 100644 playground/react/components/category.js create mode 100644 playground/react/components/common.js create mode 100644 playground/react/components/content.js create mode 100644 playground/react/components/icon.js create mode 100644 playground/react/components/list_heading.js create mode 100644 playground/react/components/list_item.js create mode 100644 playground/react/components/menu.js create mode 100644 playground/react/components/navbar.js create mode 100644 playground/react/components/result_info.js create mode 100644 playground/react/components/rulegraph.js create mode 100644 playground/react/components/search_results.js create mode 100644 playground/react/components/stats.js create mode 100644 playground/react/components/subcategory.js create mode 100644 playground/react/index.html create mode 100644 playground/react/logo.svg create mode 100644 playground/react/results.js create mode 100644 playground/react/rulegraph.js create mode 100644 playground/react/runtimes.js create mode 100644 playground/react/timeline.js diff --git a/playground/react/categories.js b/playground/react/categories.js new file mode 100644 index 000000000..c55585e14 --- /dev/null +++ b/playground/react/categories.js @@ -0,0 +1,21 @@ +var categories = { + "Foo": { + "Sub": [ + "testdir/1.txt", + "test.csv" + ], + "Other": [] + }, + "Bar": { + "Other": [ + "testdir/2.txt", + "testdir/3.txt" + ] + }, + "Other": { + "Other": [ + "fig1.svg", + "testmodel.fig2.png" + ] + } +} \ No newline at end of file diff --git a/playground/react/components/abstract_menu.js b/playground/react/components/abstract_menu.js new file mode 100644 index 000000000..b215e4d0b --- /dev/null +++ b/playground/react/components/abstract_menu.js @@ -0,0 +1,27 @@ +'use strict'; + +class AbstractMenu extends React.Component { + buttonProps = { className: "transition-all block hover:text-emerald-500 rounded hover:bg-slate-800 p-1 flex items-center gap-2" }; + iconProps = { className: "text-emerald-500" }; + + constructor(props) { + super(props); + } + + getMenuItem(label, iconName, onClick) { + return e( + "li", + { key: label }, + e( + "a", + { href: "#", onClick: onClick, ...this.buttonProps }, + e(Icon, { iconName: iconName, ...this.iconProps }), + e( + "span", + {}, + label + ) + ) + ); + } +} \ No newline at end of file diff --git a/playground/react/components/abstract_results.js b/playground/react/components/abstract_results.js new file mode 100644 index 000000000..b69372ead --- /dev/null +++ b/playground/react/components/abstract_results.js @@ -0,0 +1,151 @@ +'use strict'; + +class AbstractResults extends React.Component { + constructor(props) { + super(props); + } + + render() { + return e( + "table", + { className: "table-auto text-white text-sm w-full" }, + e( + "thead", + {}, + this.renderHeader(), + ), + e( + "tbody", + {}, + this.renderEntries() + ) + ) + } + + getResults() { + throw new Error("Unimplemented!"); + } + + getCategory() { + throw new Error("Unimplemented!"); + } + + getSubcategory() { + throw new Error("Unimplemented!"); + } + + getSearchTerm() { + throw new Error("Unimplemented!"); + } + + getColumns() { + return Array.from(new Set(this.getResults().map(function ([path, result]) { Object.keys(result.columns) }).flat())).sort(); + } + + isColumnBased() { + return this.getResults().every(function ([path, result]) { + "columns" in result + }); + } + + renderHeader() { + if (this.isColumnBased()) { + return e( + "tr", + {}, + this.getColumns().map(function (column) { + return e( + "th", + { className: "text-left p-1" }, + column + ) + }), + e( + "th", + { className: "text-right p-1 w-fit" }, + ) + ) + } else { + return e( + "tr", + {}, + e( + "th", + { className: "text-left p-1" }, + "Filename" + ), + e( + "th", + { className: "text-right p-1 w-fit" }, + ) + ) + } + } + + renderEntries() { + let _this = this; + let columns = undefined; + if (this.isColumnBased()) { + columns = this.getColumns(); + } + return this.getResults().map(function ([path, entry]) { + let actions = e( + "td", + { className: "p-1 text-right" }, + e( + "div", + { className: "inline-flex gap-1", role: "group" }, + _this.renderButton("eye", { href: entry.data_uri(), download: entry.name }), + _this.renderButton( + "information-circle", + { + href: "#", + onClick: () => _this.showResultInfo(path) + } + ) + ) + ); + + let entryColumns = undefined; + let key = undefined; + if (columns !== undefined) { + entryColumns = columns.map(function (column) { + return e( + "td", + { className: "p-1" }, + entry.columns[column] || "" + ); + }); + key = columns.join(); + } else { + entryColumns = e( + "td", + { className: "p-1" }, + path + ); + key = path; + } + + return [ + e( + "tr", + { key: key }, + entryColumns, + actions + ) + ]; + }) + } + + renderButton(iconName, props) { + return e( + "a", + { type: "button", className: `transition-all inline-block p-1 text-emerald-500 rounded hover:bg-slate-800`, ...props }, + e(Icon, { iconName: iconName }) + ) + } + + showResultInfo(resultPath) { + this.props.setView({ mode: "resultinfo", resultPath: resultPath, category: this.getCategory(), subcategory: this.getSubcategory(), searchTerm: this.getSearchTerm() }); + } +} \ No newline at end of file diff --git a/playground/react/components/app.js b/playground/react/components/app.js new file mode 100644 index 000000000..0cba404fb --- /dev/null +++ b/playground/react/components/app.js @@ -0,0 +1,23 @@ +'use strict'; + + + +class App extends React.Component { + constructor(props) { + super(props); + this.state = { content: "rulegraph", ruleinfo: undefined }; + } + + render() { + return [ + e(Navbar, { app: this, ruleinfo: this.state.ruleinfo }), + e(ContentDisplay, { show: this.state.content }) + ]; + } + + setView(view) { + this.setState({ content: view.content, ruleinfo: view.ruleinfo }) + } +} + +ReactDOM.render(e(App), document.querySelector('#app')); \ No newline at end of file diff --git a/playground/react/components/breadcrumbs.js b/playground/react/components/breadcrumbs.js new file mode 100644 index 000000000..12a846bc6 --- /dev/null +++ b/playground/react/components/breadcrumbs.js @@ -0,0 +1,103 @@ +'use strict'; + +class Breadcrumbs extends React.Component { + constructor(props) { + super(props); + this.state = { searchTerm: "" }; + } + + render() { + return e( + "nav", + { className: "text-white align-middle text-xs m-2 p-2 rounded bg-slate-800" }, + e( + "ol", + { className: "list-reset flex items-center gap-1" }, + this.renderEntries(), + this.renderSearch() + ) + ) + } + + renderEntries() { + let entries = this.props.entries.filter(function (entry) { + return entry !== undefined + }); + + return entries.map(function (entry, index) { + const isLast = index == entries.length - 1; + + let content = entry.name; + if (entry.icon !== undefined) { + content = e( + Icon, + { iconName: entry.icon } + ) + } + + + let link = content; + if (entry.func !== undefined) { + link = e( + "a", + { className: "hover:text-emerald-600", href: "#", onClick: entry.func }, + content + ); + } + + let props = {}; + if (isLast) { + props = { className: "grow" } + } + + let item = e( + "li", + { key: entry.name, ...props }, + link + ); + if (!isLast) { + item = [ + item, + e( + "li", + { key: `sep-${index}` }, + "/" + ) + ]; + } + + return item; + }); + } + + renderSearch() { + let _this = this; + return e( + "li", + { className: "flex-0" }, + e( + "input", + { + type: "text", + placeholder: "Search...", + title: "Search all results. Prefix with 're:' to perform regexp search.", + size: 10, + className: "border-0 bg-transparent text-white h-3 w-fit text-xs text-right form-control rounded", + onKeyPress: function (event) { + if (event.charCode == 13) { + event.preventDefault(); + _this.showSearchResults(); + } + }, + onChange: function (event) { + _this.setState({ searchTerm: event.target.value }); + } + }, + ) + ) + } + + showSearchResults() { + this.props.setView({ mode: "searchresults", searchTerm: this.state.searchTerm }) + } +} diff --git a/playground/react/components/category.js b/playground/react/components/category.js new file mode 100644 index 000000000..71121c0e6 --- /dev/null +++ b/playground/react/components/category.js @@ -0,0 +1,22 @@ +'use strict'; + +class Category extends AbstractMenu { + render() { + return e( + "ul", + {}, + this.getSubcategoryMenuitems() + ) + } + + showSubcategory(subcategory) { + this.props.setView({ mode: "category", category: this.props.category, subcategory: subcategory }) + } + + getSubcategoryMenuitems() { + let _this = this + return Object.keys(categories[this.props.category]).map(function (subcategory) { + return _this.getMenuItem(subcategory, "folder", () => _this.showSubcategory(subcategory)); + }); + } +} \ No newline at end of file diff --git a/playground/react/components/common.js b/playground/react/components/common.js new file mode 100644 index 000000000..a1181d4c0 --- /dev/null +++ b/playground/react/components/common.js @@ -0,0 +1,17 @@ +const e = React.createElement; + +function isNoResults() { + return Object.keys(categories).length == 0; +} + +function isSingleCategory() { + return Object.keys(categories).length == 1; +} + +function isSingleDefaultCategory() { + return isSingleCategory() && Object.keys(categories)[0] == "Other"; +} + +function isSingleSubcategory(category) { + return Object.keys(categories[category]).length == 1; +} \ No newline at end of file diff --git a/playground/react/components/content.js b/playground/react/components/content.js new file mode 100644 index 000000000..87ef38a7f --- /dev/null +++ b/playground/react/components/content.js @@ -0,0 +1,26 @@ +'use strict'; + + + +class ContentDisplay extends React.Component { + constructor(props) { + super(props); + } + + render() { + return e( + "div", + { className: "flex items-center justify-center min-h-screen z-0" }, + this.renderContent() + ) + } + + renderContent() { + switch (this.props.show) { + case "rulegraph": + return e(RuleGraph); + case "stats": + return e(Stats) + } + } +} \ No newline at end of file diff --git a/playground/react/components/icon.js b/playground/react/components/icon.js new file mode 100644 index 000000000..707fa525c --- /dev/null +++ b/playground/react/components/icon.js @@ -0,0 +1,48 @@ +'use strict'; + +class Icon extends React.Component { + // paths are imported from https://heroicons.com + paths = { + "arrow-down": [ + { rule: "evenodd", path: "M16.707 10.293a1 1 0 010 1.414l-6 6a1 1 0 01-1.414 0l-6-6a1 1 0 111.414-1.414L9 14.586V3a1 1 0 012 0v11.586l4.293-4.293a1 1 0 011.414 0z" } + ], + "information-circle": [ + { rule: "evenodd", path: "M18 10a8 8 0 11-16 0 8 8 0 0116 0zm-7-4a1 1 0 11-2 0 1 1 0 012 0zM9 9a1 1 0 000 2v3a1 1 0 001 1h1a1 1 0 100-2v-3a1 1 0 00-1-1H9z" } + ], + "home": [ + { rule: "evenodd", path: "M10.707 2.293a1 1 0 00-1.414 0l-7 7a1 1 0 001.414 1.414L4 10.414V17a1 1 0 001 1h2a1 1 0 001-1v-2a1 1 0 011-1h2a1 1 0 011 1v2a1 1 0 001 1h2a1 1 0 001-1v-6.586l.293.293a1 1 0 001.414-1.414l-7-7z" } + ], + "share": [ + { rule: "evenodd", path: "M15 8a3 3 0 10-2.977-2.63l-4.94 2.47a3 3 0 100 4.319l4.94 2.47a3 3 0 10.895-1.789l-4.94-2.47a3.027 3.027 0 000-.74l4.94-2.47C13.456 7.68 14.19 8 15 8z" } + ], + "chart": [ + { rule: "evenodd", path: "M2 11a1 1 0 011-1h2a1 1 0 011 1v5a1 1 0 01-1 1H3a1 1 0 01-1-1v-5zM8 7a1 1 0 011-1h2a1 1 0 011 1v9a1 1 0 01-1 1H9a1 1 0 01-1-1V7zM14 4a1 1 0 011-1h2a1 1 0 011 1v12a1 1 0 01-1 1h-2a1 1 0 01-1-1V4z" } + ], + "folder": [ + { rule: "evenodd", path: "M2 6a2 2 0 012-2h5l2 2h5a2 2 0 012 2v6a2 2 0 01-2 2H4a2 2 0 01-2-2V6z" } + ], + "eye": [ + { rule: undefined, path: "M10 12a2 2 0 100-4 2 2 0 000 4z" }, + { rule: "evenodd", path: "M.458 10C1.732 5.943 5.522 3 10 3s8.268 2.943 9.542 7c-1.274 4.057-5.064 7-9.542 7S1.732 14.057.458 10zM14 10a4 4 0 11-8 0 4 4 0 018 0z" }, + ] + } + + render() { + let _this = this; + return e( + "svg", + { xmlns: "http://www.w3.org/2000/svg", className: `h-4 w-4 ${this.props.className}`, viewBox: "0 0 20 20", fill: "currentColor", }, + this.renderPath().map(function (item) { + + return e( + "path", + { fillRule: item.rule, clipRule: item.rule, d: item.path } + ); + }) + ) + } + + renderPath() { + return this.paths[this.props.iconName]; + } +} diff --git a/playground/react/components/list_heading.js b/playground/react/components/list_heading.js new file mode 100644 index 000000000..3a485c1ad --- /dev/null +++ b/playground/react/components/list_heading.js @@ -0,0 +1,11 @@ +'use strict'; + +class ListHeading extends React.Component { + render() { + return e( + "li", + { className: "uppercase font-bold p-1" }, + this.props.text + ); + } +} \ No newline at end of file diff --git a/playground/react/components/list_item.js b/playground/react/components/list_item.js new file mode 100644 index 000000000..96748dfbe --- /dev/null +++ b/playground/react/components/list_item.js @@ -0,0 +1,15 @@ +'use strict'; + +class ListItem extends React.Component { + constructor(props) { + super(props); + } + + render() { + return e( + "li", + { className: "p-1" }, + this.props.children + ); + } +} \ No newline at end of file diff --git a/playground/react/components/menu.js b/playground/react/components/menu.js new file mode 100644 index 000000000..25192915d --- /dev/null +++ b/playground/react/components/menu.js @@ -0,0 +1,69 @@ +'use strict'; + +class Menu extends AbstractMenu { + constructor(props) { + super(props); + this.showWorkflow = this.showWorkflow.bind(this) + this.showStatistics = this.showStatistics.bind(this) + } + + render() { + return e( + "ul", + {}, + this.getHeading(), + this.getMenuItem("Workflow", "share", this.showWorkflow), + this.getMenuItem("Statistics", "chart", this.showStatistics), + this.getCategoryMenumitems() + ) + } + + showWorkflow() { + this.props.app.setView({ content: "rulegraph" }); + } + + showStatistics() { + this.props.app.setView({ content: "stats" }); + } + + getHeading() { + if (isSingleCategory()) { + return []; + } else { + return e( + ListHeading, + { text: "General" } + ) + } + } + + showCategory(category) { + let subcategory = undefined; + if (isSingleSubcategory(category)) { + subcategory = Object.keys(categories[category])[0]; + } + this.props.setView({ mode: "category", category: category, subcategory: subcategory }) + } + + getCategoryMenumitems() { + if (isSingleCategory()) { + let category = Object.keys(categories)[0]; + return this.getMenuItem("Results", "folder", () => this.showCategory(category)); + } else if (isNoResults()) { + return []; + } else { + let items = [e( + "li", + { key: "Results", className: "uppercase font-bold p-1 mt-2" }, + "Results" + )]; + + let _this = this + items.push(...Object.keys(categories).map(function (category) { + return _this.getMenuItem(category, "folder", () => _this.showCategory(category)); + })); + + return items; + } + } +} \ No newline at end of file diff --git a/playground/react/components/navbar.js b/playground/react/components/navbar.js new file mode 100644 index 000000000..7ea053f84 --- /dev/null +++ b/playground/react/components/navbar.js @@ -0,0 +1,155 @@ +'use strict'; + + +class Navbar extends React.Component { + constructor(props) { + super(props); + this.state = { mode: "menu", category: undefined, subcategory: undefined, searchTerm: undefined, resultPath: undefined }; + this.setView = this.setView.bind(this); + } + + render() { + return e( + "nav", + { className: `fixed z-50 transition-all ${this.getWidth()} min-w-fit bg-slate-900/70 backdrop-blur-sm text-white text-sm h-screen overflow-y-auto` }, + e( + "h1", + { className: "sticky bg-blur bg-white opacity-80 text-slate-700 text-l tracking-wide px-3 py-1 mb-1 flex items-center" }, + e( + "img", + { src: "logo.svg", className: "h-4" } + ), + e( + "span", + { className: "font-bold mx-1" }, + "Snakemake" + ), + e( + "span", + {}, + "Report" + ), + ), + this.renderBreadcrumbs(), + e( + "div", + { className: "p-3" }, + this.renderContent() + ) + ); + } + + renderContent() { + let setView = this.setView; + switch (this.state.mode) { + case "menu": + return e(Menu, { setView: setView, app: this.props.app }); + case "category": + if (this.state.subcategory !== undefined) { + return e(Subcategory, { setView: setView, category: this.state.category, subcategory: this.state.subcategory }); + } else { + return e(Category, { setView: setView, category: this.state.category }); + } + case "searchresults": + return e(SearchResults, { setView: setView, searchTerm: this.state.searchTerm }); + case "resultinfo": + return e(ResultInfo, { resultPath: this.state.resultPath }); + } + } + + renderBreadcrumbs() { + let setView = this.setView; + switch (this.state.mode) { + case "menu": + return e( + Breadcrumbs, + { entries: [this.getMenuBreadcrumb()], setView: setView } + ); + case "category": + return e( + Breadcrumbs, + { entries: [this.getMenuBreadcrumb(), this.getResultBreadcrumb(), this.getCategoryBreadcrumb(), this.getSubcategoryBreadcrumb()], setView: setView } + ); + case "resultinfo": + return e( + Breadcrumbs, + { entries: [this.getMenuBreadcrumb(), this.getResultBreadcrumb(), this.getCategoryBreadcrumb(), this.getSubcategoryBreadcrumb(), this.getSearchResultsBreadcrumb(), this.getResultinfoBreadcrumb()], setView: setView } + ); + case "searchresults": + return e( + Breadcrumbs, + { entries: [this.getMenuBreadcrumb(), this.getSearchResultsBreadcrumb()], setView: setView } + ) + } + } + + getMenuBreadcrumb() { + let _this = this; + return { name: "menu", icon: "home", func: function () { _this.setView({ mode: "menu", category: undefined, subcategory: undefined }) } }; + } + + getCategoryBreadcrumb() { + if (this.state.category === undefined) { + return undefined; + } + let subcategory = undefined; + if (isSingleSubcategory(this.state.category)) { + subcategory = this.state.subcategory; + } + let _this = this; + + let name = this.state.category; + if (isSingleDefaultCategory()) { + name = "Results"; + } + return { name: name, func: function () { _this.setView({ mode: "category", category: _this.state.category, subcategory: subcategory }) } }; + } + + getSubcategoryBreadcrumb() { + if (this.state.subcategory === undefined || isSingleSubcategory(this.state.category)) { + return undefined; + } + let _this = this; + return { name: this.state.subcategory, func: function () { _this.setView({ mode: "category", category: _this.state.category, subcategory: _this.state.subcategory }) } }; + } + + getResultBreadcrumb() { + if (isSingleDefaultCategory()) { + return undefined; + } + return { name: "Results", func: undefined }; + } + + getSearchResultsBreadcrumb() { + let searchTerm = this.state.searchTerm; + if (searchTerm === undefined) { + return undefined; + } + let setView = this.setView; + return { + name: "Search results", func: function () { + setView({ mode: "searchresults", searchTerm: searchTerm }) + } + }; + } + + getResultinfoBreadcrumb() { + return { name: "resultinfo", icon: "eye", func: undefined }; + } + + getWidth() { + switch (this.state.mode) { + case "menu": + return "w-1/5" + case "category": + return "w-1/3" + case "resultinfo": + return "w-3/4" + } + } + + setView(view) { + event.preventDefault(); + this.setState({ mode: view.mode, category: view.category, subcategory: view.subcategory, searchTerm: view.searchTerm, resultPath: view.resultPath }) + } +} \ No newline at end of file diff --git a/playground/react/components/result_info.js b/playground/react/components/result_info.js new file mode 100644 index 000000000..8854643e0 --- /dev/null +++ b/playground/react/components/result_info.js @@ -0,0 +1,148 @@ +'use strict'; + +class ResultInfo extends React.Component { + render() { + return e( + "ul", + {}, + this.getDescriptor(), + this.getCaption(), + this.getRule(), + this.getParamsAndWildcards(), + ) + } + + getResult() { + return results[this.props.resultPath]; + } + + getDescriptor() { + let result = this.getResult(); + + if (result.columns !== undefined) { + const columns = Object.keys(result.columns).sort(); + return [ + e( + ListHeading, + { text: "Result" } + ), + e( + "li", + {}, + e( + "table", + {}, + e( + "thead", + {}, + e( + "tr", + {}, + columns.map(function (column) { + return e( + "th", + {}, + column + ); + }) + ) + ), + e( + "tbody", + {}, + e( + "tr", + {}, + columns.map(function (column) { + const value = result.columns[column]; + return e( + "td", + {}, + value + ); + }) + ) + ) + ) + ) + ]; + } else { + return [ + e( + ListHeading, + { text: "Result" } + ), + e( + "li", + { className: "p-1" }, + this.props.resultPath + ) + ]; + } + } + + getCaption() { + const caption = this.getResult().caption; + if (caption !== undefined) { + return [ + e( + ListHeading, + { text: "Description" } + ), + e( + "li", + { + className: "p-1", + dangerouslySetInnerHTML: { __html: caption } + } + ) + ]; + } else { + return []; + } + } + + getRule() { + return [ + e( + ListHeading, + { text: "Snakemake rule" } + ), + e( + ListItem, + {}, + this.getResult().job_properties.rule + ) + ] + } + + getParamsAndWildcards() { + const jobProperties = this.getResult().job_properties; + console.log(jobProperties) + if (jobProperties.params || jobProperties.wildcards) { + let items = [ + e( + ListHeading, + { text: "Job parameters" } + ), + ]; + if (jobProperties.wildcards) { + items.push(e( + ListItem, + { key: "wildcards" }, + jobProperties.wildcards + )); + } + if (jobProperties.params) { + items.push(e( + ListItem, + { key: "params" }, + jobProperties.params + )); + } + return items; + } else { + return []; + } + } +} \ No newline at end of file diff --git a/playground/react/components/rulegraph.js b/playground/react/components/rulegraph.js new file mode 100644 index 000000000..0d8c1768d --- /dev/null +++ b/playground/react/components/rulegraph.js @@ -0,0 +1,31 @@ +'use strict'; + +class RuleGraph extends React.Component { + constructor(props) { + super(props); + } + + render() { + return e( + "div", + { id: "rulegraph" } + ) + } + + componentDidMount() { + let showRuleProperties = this.showRuleProperties; + vegaEmbed("#rulegraph", rulegraph_spec).then(function (ret) { + ret.view.addEventListener("click", function (event, item) { + if (item && "rule" in item.datum) { + var rule = item.datum.rule; + showRuleProperties(rule); + } + }); + }); + } + + + showRuleProperties() { + + } +} \ No newline at end of file diff --git a/playground/react/components/search_results.js b/playground/react/components/search_results.js new file mode 100644 index 000000000..d488355a8 --- /dev/null +++ b/playground/react/components/search_results.js @@ -0,0 +1,47 @@ +'use strict'; + +class SearchResults extends AbstractResults { + getSearchFunc() { + let term = this.props.searchTerm; + if (term.startsWith("re:")) { + let regexp = new RegExp(term.slice(3)); + return function (text) { + return regexp.test(text); + } + } else { + return function (text) { + return text.includes(term); + } + } + } + + getResults() { + let searchFunc = this.getSearchFunc(); + return Object.entries(results).map(function ([path, result]) { + if (searchFunc(path)) { + return [path, result]; + } + const columns = result.columns || []; + for (columnValue in columns) { + if (searchFunc(columnValue)) { + return [path, result]; + } + } + return undefined; + }).filter(function (item) { + return item !== undefined; + }) + } + + getCategory() { + return undefined; + } + + getSubcategory() { + return undefined; + } + + getSearchTerm() { + return this.props.searchTerm; + } +} \ No newline at end of file diff --git a/playground/react/components/stats.js b/playground/react/components/stats.js new file mode 100644 index 000000000..4fada01a4 --- /dev/null +++ b/playground/react/components/stats.js @@ -0,0 +1,27 @@ +'use strict'; + +class Stats extends React.Component { + constructor(props) { + super(props); + } + + render() { + return e( + "div", + { className: "flex" }, + e( + "div", + { id: "runtimes" } + ), + e( + "div", + { id: "timeline" } + ) + ) + } + + componentDidMount() { + vegaEmbed("#runtimes", runtimes_spec); + vegaEmbed("#timeline", timeline_spec); + } +} \ No newline at end of file diff --git a/playground/react/components/subcategory.js b/playground/react/components/subcategory.js new file mode 100644 index 000000000..9eae67d6a --- /dev/null +++ b/playground/react/components/subcategory.js @@ -0,0 +1,21 @@ +'use strict'; + +class Subcategory extends AbstractResults { + getResults() { + return categories[this.props.category][this.props.subcategory].map(function (path) { + return [path, results[path]]; + }); + } + + getCategory() { + return this.props.category; + } + + getSubcategory() { + return this.props.subcategory; + } + + getSearchTerm() { + return undefined; + } +} \ No newline at end of file diff --git a/playground/react/index.html b/playground/react/index.html new file mode 100644 index 000000000..fd0c9706b --- /dev/null +++ b/playground/react/index.html @@ -0,0 +1,51 @@ + + + + + + Snakemake Report + + + + + +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/playground/react/logo.svg b/playground/react/logo.svg new file mode 100644 index 000000000..8362455cd --- /dev/null +++ b/playground/react/logo.svg @@ -0,0 +1,7 @@ + + + + + + + \ No newline at end of file diff --git a/playground/react/results.js b/playground/react/results.js new file mode 100644 index 000000000..c547a295a --- /dev/null +++ b/playground/react/results.js @@ -0,0 +1,92 @@ +var results = { + "testdir/1.txt": { + name: "1.txt", + filename: "1.txt", + path: "testdir/1.txt", + size: "2 Bytes", + caption: "

Files obtained from a directory. This file starts with 1. This value has been dynamically inferred from the given pattern.

\n", + job_properties: { + rule: "e", + wildcards: "name=1", + params: "" + }, + data_uri: function () { return "data:text/plain;charset=utf8;filename=1.txt;base64,MQo="; }, + thumbnail_uri: function () { return null; } + }, + "testdir/2.txt": { + name: "2.txt", + filename: "2.txt", + path: "testdir/2.txt", + size: "2 Bytes", + caption: "

Files obtained from a directory. This file starts with 2. This value has been dynamically inferred from the given pattern.

\n", + job_properties: { + rule: "e", + wildcards: "name=2", + params: "" + }, + data_uri: function () { return "data:text/plain;charset=utf8;filename=2.txt;base64,Mgo="; }, + thumbnail_uri: function () { return null; } + }, + "testdir/3.txt": { + name: "3.txt", + filename: "3.txt", + path: "testdir/3.txt", + size: "2 Bytes", + caption: "

Files obtained from a directory. This file starts with 3. This value has been dynamically inferred from the given pattern.

\n", + job_properties: { + rule: "e", + wildcards: "name=3", + params: "" + }, + data_uri: function () { return "data:text/plain;charset=utf8;filename=3.txt;base64,Mwo="; }, + thumbnail_uri: function () { return null; } + }, + "test.csv": { + name: "test.csv", + filename: "test.csv", + path: "test.csv", + size: "113.2 kB", + caption: "

An example table.

\n", + job_properties: { + rule: "d", + wildcards: "", + params: "" + }, + data_uri: function () { return "data:text/csv;charset=utf8;filename=test.csv;base64,street,city,zip,state,beds,baths,sq__ft,type,sale_date,price,latitude,longitude3526 HIGH ST,SACRAMENTO,95838,CA,2,1,836,Residential,Wed May 21 00:00:00 EDT 2008,59222,38.631913,-121.43487951 OMAHA CT,SACRAMENTO,95823,CA,3,1,1167,Residential,Wed May 21 00:00:00 EDT 2008,68212,38.478902,-121.4310282796 BRANCH ST,SACRAMENTO,95815,CA,2,1,796,Residential,Wed May 21 00:00:00 EDT 2008,68880,38.618305,-121.4438392805 JANETTE WAY,SACRAMENTO,95815,CA,2,1,852,Residential,Wed May 21 00:00:00 EDT 2008,69307,38.616835,-121.4391466001 MCMAHON DR,SACRAMENTO,95824,CA,2,1,797,Residential,Wed May 21 00:00:00 EDT 2008,81900,38.51947,-121.4357685828 PEPPERMILL CT,SACRAMENTO,95841,CA,3,1,1122,Condo,Wed May 21 00:00:00 EDT 2008,89921,38.662595,-121.3278136048 OGDEN NASH WAY,SACRAMENTO,95842,CA,3,2,1104,Residential,Wed May 21 00:00:00 EDT 2008,90895,38.681659,-121.3517052561 19TH AVE,SACRAMENTO,95820,CA,3,1,1177,Residential,Wed May 21 00:00:00 EDT 2008,91002,38.535092,-121.48136711150 TRINITY RIVER DR Unit 114,RANCHO CORDOVA,95670,CA,2,2,941,Condo,Wed May 21 00:00:00 EDT 2008,94905,38.621188,-121.2705557325 10TH ST,RIO LINDA,95673,CA,3,2,1146,Residential,Wed May 21 00:00:00 EDT 2008,98937,38.700909,-121.442979645 MORRISON AVE,SACRAMENTO,95838,CA,3,2,909,Residential,Wed May 21 00:00:00 EDT 2008,100309,38.637663,-121.451524085 FAWN CIR,SACRAMENTO,95823,CA,3,2,1289,Residential,Wed May 21 00:00:00 EDT 2008,106250,38.470746,-121.4589182930 LA ROSA RD,SACRAMENTO,95815,CA,1,1,871,Residential,Wed May 21 00:00:00 EDT 2008,106852,38.618698,-121.4358332113 KIRK WAY,SACRAMENTO,95822,CA,3,1,1020,Residential,Wed May 21 00:00:00 EDT 2008,107502,38.482215,-121.4926034533 LOCH HAVEN WAY,SACRAMENTO,95842,CA,2,2,1022,Residential,Wed May 21 00:00:00 EDT 2008,108750,38.672914,-121.359347340 HAMDEN PL,SACRAMENTO,95842,CA,2,2,1134,Condo,Wed May 21 00:00:00 EDT 2008,110700,38.700051,-121.3512786715 6TH ST,RIO LINDA,95673,CA,2,1,844,Residential,Wed May 21 00:00:00 EDT 2008,113263,38.689591,-121.4522396236 LONGFORD DR Unit 1,CITRUS HEIGHTS,95621,CA,2,1,795,Condo,Wed May 21 00:00:00 EDT 2008,116250,38.679776,-121.314089250 PERALTA AVE,SACRAMENTO,95833,CA,2,1,588,Residential,Wed May 21 00:00:00 EDT 2008,120000,38.612099,-121.469095113 LEEWILL AVE,RIO LINDA,95673,CA,3,2,1356,Residential,Wed May 21 00:00:00 EDT 2008,121630,38.689999,-121.463226118 STONEHAND AVE,CITRUS HEIGHTS,95621,CA,3,2,1118,Residential,Wed May 21 00:00:00 EDT 2008,122000,38.707851,-121.3207074882 BANDALIN WAY,SACRAMENTO,95823,CA,4,2,1329,Residential,Wed May 21 00:00:00 EDT 2008,122682,38.468173,-121.4440717511 OAKVALE CT,NORTH HIGHLANDS,95660,CA,4,2,1240,Residential,Wed May 21 00:00:00 EDT 2008,123000,38.702792,-121.382219 PASTURE CT,SACRAMENTO,95834,CA,3,2,1601,Residential,Wed May 21 00:00:00 EDT 2008,124100,38.628631,-121.4880973729 BAINBRIDGE DR,NORTH HIGHLANDS,95660,CA,3,2,901,Residential,Wed May 21 00:00:00 EDT 2008,125000,38.701499,-121.376223828 BLACKFOOT WAY,ANTELOPE,95843,CA,3,2,1088,Residential,Wed May 21 00:00:00 EDT 2008,126640,38.70974,-121.373774108 NORTON WAY,SACRAMENTO,95820,CA,3,1,963,Residential,Wed May 21 00:00:00 EDT 2008,127281,38.537526,-121.4783151469 JANRICK AVE,SACRAMENTO,95832,CA,3,2,1119,Residential,Wed May 21 00:00:00 EDT 2008,129000,38.476472,-121.5017119861 CULP WAY,SACRAMENTO,95827,CA,4,2,1380,Residential,Wed May 21 00:00:00 EDT 2008,131200,38.558423,-121.3279487825 CREEK VALLEY CIR,SACRAMENTO,95828,CA,3,2,1248,Residential,Wed May 21 00:00:00 EDT 2008,132000,38.472122,-121.4041995201 LAGUNA OAKS DR Unit 140,ELK GROVE,95758,CA,2,2,1039,Condo,Wed May 21 00:00:00 EDT 2008,133000,38.423251,-121.4444896768 MEDORA DR,NORTH HIGHLANDS,95660,CA,3,2,1152,Residential,Wed May 21 00:00:00 EDT 2008,134555,38.691161,-121.371923100 EXPLORER DR,SACRAMENTO,95827,CA,3,2,1380,Residential,Wed May 21 00:00:00 EDT 2008,136500,38.566663,-121.3326447944 DOMINION WAY,ELVERTA,95626,CA,3,2,1116,Residential,Wed May 21 00:00:00 EDT 2008,138750,38.713182,-121.4112275201 LAGUNA OAKS DR Unit 162,ELK GROVE,95758,CA,2,2,1039,Condo,Wed May 21 00:00:00 EDT 2008,141000,38.423251,-121.4444893920 SHINING STAR DR,SACRAMENTO,95823,CA,3,2,1418,Residential,Wed May 21 00:00:00 EDT 2008,146250,38.48742,-121.4624595031 CORVAIR ST,NORTH HIGHLANDS,95660,CA,3,2,1082,Residential,Wed May 21 00:00:00 EDT 2008,147308,38.658246,-121.3754697661 NIXOS WAY,SACRAMENTO,95823,CA,4,2,1472,Residential,Wed May 21 00:00:00 EDT 2008,148750,38.479553,-121.4633177044 CARTHY WAY,SACRAMENTO,95828,CA,4,2,1146,Residential,Wed May 21 00:00:00 EDT 2008,149593,38.49857,-121.4209252442 LARKSPUR LN,SACRAMENTO,95825,CA,1,1,760,Condo,Wed May 21 00:00:00 EDT 2008,150000,38.58514,-121.4037364800 WESTLAKE PKWY Unit 2109,SACRAMENTO,95835,CA,2,2,1304,Condo,Wed May 21 00:00:00 EDT 2008,152000,38.658812,-121.5423452178 63RD AVE,SACRAMENTO,95822,CA,3,2,1207,Residential,Wed May 21 00:00:00 EDT 2008,154000,38.493955,-121.489668718 ELK WAY,ELK GROVE,95624,CA,3,2,1056,Residential,Wed May 21 00:00:00 EDT 2008,156896,38.41653,-121.3796535708 RIDGEPOINT DR,ANTELOPE,95843,CA,2,2,1043,Residential,Wed May 21 00:00:00 EDT 2008,161250,38.72027,-121.3315557315 KOALA CT,NORTH HIGHLANDS,95660,CA,4,2,1587,Residential,Wed May 21 00:00:00 EDT 2008,161500,38.699251,-121.3714142622 ERIN DR,SACRAMENTO,95833,CA,4,1,1120,Residential,Wed May 21 00:00:00 EDT 2008,164000,38.613765,-121.4886948421 SUNBLAZE WAY,SACRAMENTO,95823,CA,4,2,1580,Residential,Wed May 21 00:00:00 EDT 2008,165000,38.450543,-121.4325387420 ALIX PKWY,SACRAMENTO,95823,CA,4,1,1955,Residential,Wed May 21 00:00:00 EDT 2008,166357,38.489405,-121.4528113820 NATOMA WAY,SACRAMENTO,95838,CA,4,2,1656,Residential,Wed May 21 00:00:00 EDT 2008,166357,38.636748,-121.4221594431 GREEN TREE DR,SACRAMENTO,95823,CA,3,2,1477,Residential,Wed May 21 00:00:00 EDT 2008,168000,38.499954,-121.4544699417 SARA ST,ELK GROVE,95624,CA,3,2,1188,Residential,Wed May 21 00:00:00 EDT 2008,170000,38.415518,-121.3705278299 HALBRITE WAY,SACRAMENTO,95828,CA,4,2,1590,Residential,Wed May 21 00:00:00 EDT 2008,173000,38.473814,-121.47223 KALLIE KAY LN,SACRAMENTO,95823,CA,3,2,1463,Residential,Wed May 21 00:00:00 EDT 2008,174250,38.477553,-121.4194638156 STEINBECK WAY,SACRAMENTO,95828,CA,4,2,1714,Residential,Wed May 21 00:00:00 EDT 2008,174313,38.474853,-121.4063267957 VALLEY GREEN DR,SACRAMENTO,95823,CA,3,2,1185,Residential,Wed May 21 00:00:00 EDT 2008,178480,38.465184,-121.4349251122 WILD POPPY CT,GALT,95632,CA,3,2,1406,Residential,Wed May 21 00:00:00 EDT 2008,178760,38.287789,-121.2947154520 BOMARK WAY,SACRAMENTO,95842,CA,4,2,1943,Multi-Family,Wed May 21 00:00:00 EDT 2008,179580,38.665724,-121.3585769012 KIEFER BLVD,SACRAMENTO,95826,CA,3,2,1172,Residential,Wed May 21 00:00:00 EDT 2008,181000,38.547011,-121.3662175332 SANDSTONE ST,CARMICHAEL,95608,CA,3,1,1152,Residential,Wed May 21 00:00:00 EDT 2008,181872,38.662105,-121.3139455993 SAWYER CIR,SACRAMENTO,95823,CA,4,3,1851,Residential,Wed May 21 00:00:00 EDT 2008,182587,38.4473,-121.4352184844 CLYDEBANK WAY,ANTELOPE,95843,CA,3,2,1215,Residential,Wed May 21 00:00:00 EDT 2008,182716,38.714609,-121.347887306 CAMELLIA WAY,GALT,95632,CA,3,2,1130,Residential,Wed May 21 00:00:00 EDT 2008,182750,38.260443,-121.2978649021 MADISON AVE,ORANGEVALE,95662,CA,4,2,1603,Residential,Wed May 21 00:00:00 EDT 2008,183200,38.664186,-121.217511404 6TH ST,GALT,95632,CA,3,1,1479,Residential,Wed May 21 00:00:00 EDT 2008,188741,38.251808,-121.3024938317 SUNNY CREEK WAY,SACRAMENTO,95823,CA,3,2,1420,Residential,Wed May 21 00:00:00 EDT 2008,189000,38.459041,-121.4246442617 BASS CT,SACRAMENTO,95826,CA,3,2,1280,Residential,Wed May 21 00:00:00 EDT 2008,192067,38.560767,-121.3774717005 TIANT WAY,ELK GROVE,95758,CA,3,2,1586,Residential,Wed May 21 00:00:00 EDT 2008,194000,38.422811,-121.4232857895 CABER WAY,ANTELOPE,95843,CA,3,2,1362,Residential,Wed May 21 00:00:00 EDT 2008,194818,38.711279,-121.3934497624 BOGEY CT,SACRAMENTO,95828,CA,4,4,2162,Multi-Family,Wed May 21 00:00:00 EDT 2008,195000,38.48009,-121.4151026930 HAMPTON COVE WAY,SACRAMENTO,95823,CA,3,2,1266,Residential,Wed May 21 00:00:00 EDT 2008,198000,38.44004,-121.4210128708 MESA BROOK WAY,ELK GROVE,95624,CA,4,2,1715,Residential,Wed May 21 00:00:00 EDT 2008,199500,38.44076,-121.385792120 GRANT LN,FOLSOM,95630,CA,3,2,1820,Residential,Wed May 21 00:00:00 EDT 2008,200000,38.687742,-121.171045907 ELLERSLEE DR,CARMICHAEL,95608,CA,3,1,936,Residential,Wed May 21 00:00:00 EDT 2008,200000,38.664468,-121.3268317 SERASPI CT,SACRAMENTO,95834,CA,0,0,0,Residential,Wed May 21 00:00:00 EDT 2008,206000,38.631481,-121.50188170 PENHOW CIR,SACRAMENTO,95834,CA,3,2,1511,Residential,Wed May 21 00:00:00 EDT 2008,208000,38.653439,-121.5351698345 STAR THISTLE WAY,SACRAMENTO,95823,CA,4,2,1590,Residential,Wed May 21 00:00:00 EDT 2008,212864,38.454349,-121.4392399080 FRESCA WAY,ELK GROVE,95758,CA,4,2,1596,Residential,Wed May 21 00:00:00 EDT 2008,221000,38.427818,-121.424026391 NATALINO CIR,SACRAMENTO,95835,CA,2,2,1341,Residential,Wed May 21 00:00:00 EDT 2008,221000,38.67307,-121.5063738373 BLACKMAN WAY,ELK GROVE,95624,CA,5,3,2136,Residential,Wed May 21 00:00:00 EDT 2008,223058,38.435436,-121.3945369837 CORTE DORADO CT,ELK GROVE,95624,CA,4,2,1616,Residential,Wed May 21 00:00:00 EDT 2008,227887,38.400676,-121.381015037 J PKWY,SACRAMENTO,95823,CA,3,2,1478,Residential,Wed May 21 00:00:00 EDT 2008,231477,38.491399,-121.44354710245 LOS PALOS DR,RANCHO CORDOVA,95670,CA,3,2,1287,Residential,Wed May 21 00:00:00 EDT 2008,234697,38.593699,-121.310896613 NAVION DR,CITRUS HEIGHTS,95621,CA,4,2,1277,Residential,Wed May 21 00:00:00 EDT 2008,235000,38.702855,-121.313082887 AZEVEDO DR,SACRAMENTO,95833,CA,4,2,1448,Residential,Wed May 21 00:00:00 EDT 2008,236000,38.618457,-121.5094399186 KINBRACE CT,SACRAMENTO,95829,CA,4,3,2235,Residential,Wed May 21 00:00:00 EDT 2008,236685,38.463355,-121.3589364243 MIDDLEBURY WAY,MATHER,95655,CA,3,2,2093,Residential,Wed May 21 00:00:00 EDT 2008,237800,38.547991,-121.2804831028 FALLON PLACE CT,RIO LINDA,95673,CA,3,2,1193,Residential,Wed May 21 00:00:00 EDT 2008,240122,38.693818,-121.4411534804 NORIKER DR,ELK GROVE,95757,CA,3,2,2163,Residential,Wed May 21 00:00:00 EDT 2008,242638,38.400974,-121.4484247713 HARVEST WOODS DR,SACRAMENTO,95828,CA,3,2,1269,Residential,Wed May 21 00:00:00 EDT 2008,244000,38.478198,-121.4129112866 KARITSA AVE,SACRAMENTO,95833,CA,0,0,0,Residential,Wed May 21 00:00:00 EDT 2008,244500,38.626671,-121.525976913 RICHEVE WAY,SACRAMENTO,95828,CA,3,1,958,Residential,Wed May 21 00:00:00 EDT 2008,244960,38.502519,-121.4207698636 TEGEA WAY,ELK GROVE,95624,CA,5,3,2508,Residential,Wed May 21 00:00:00 EDT 2008,245918,38.443832,-121.3820875448 MAIDSTONE WAY,CITRUS HEIGHTS,95621,CA,3,2,1305,Residential,Wed May 21 00:00:00 EDT 2008,250000,38.665395,-121.29328818 OLLIE CT,ELK GROVE,95758,CA,4,2,1591,Residential,Wed May 21 00:00:00 EDT 2008,250000,38.444909,-121.4123454010 ALEX LN,CARMICHAEL,95608,CA,2,2,1326,Condo,Wed May 21 00:00:00 EDT 2008,250134,38.637028,-121.3129634901 MILLNER WAY,ELK GROVE,95757,CA,3,2,1843,Residential,Wed May 21 00:00:00 EDT 2008,254200,38.38692,-121.4473494818 BRITTNEY LEE CT,SACRAMENTO,95841,CA,4,2,1921,Residential,Wed May 21 00:00:00 EDT 2008,254200,38.653917,-121.342185529 LAGUNA PARK DR,ELK GROVE,95758,CA,5,3,2790,Residential,Wed May 21 00:00:00 EDT 2008,258000,38.42568,-121.438062230 CANDELA CIR,SACRAMENTO,95835,CA,3,2,1541,Residential,Wed May 21 00:00:00 EDT 2008,260000,38.656251,-121.5475724900 71ST ST,SACRAMENTO,95820,CA,3,1,1018,Residential,Wed May 21 00:00:00 EDT 2008,260014,38.53151,-121.42108912209 CONSERVANCY WAY,RANCHO CORDOVA,95742,CA,0,0,0,Residential,Wed May 21 00:00:00 EDT 2008,263500,38.553867,-121.2191414236 NATOMAS CENTRAL DR,SACRAMENTO,95834,CA,3,2,1672,Condo,Wed May 21 00:00:00 EDT 2008,265000,38.648879,-121.5440235615 LUPIN LN,POLLOCK PINES,95726,CA,3,2,1380,Residential,Wed May 21 00:00:00 EDT 2008,265000,38.708315,-120.6038725625 JAMES WAY,SACRAMENTO,95822,CA,3,1,975,Residential,Wed May 21 00:00:00 EDT 2008,271742,38.523947,-121.4849467842 LAHONTAN CT,SACRAMENTO,95829,CA,4,3,2372,Residential,Wed May 21 00:00:00 EDT 2008,273750,38.472976,-121.3186336850 21ST ST,SACRAMENTO,95822,CA,3,2,1446,Residential,Wed May 21 00:00:00 EDT 2008,275086,38.502194,-121.4907952900 BLAIR RD,POLLOCK PINES,95726,CA,2,2,1284,Residential,Wed May 21 00:00:00 EDT 2008,280908,38.75485,-120.604762064 EXPEDITION WAY,SACRAMENTO,95832,CA,4,3,3009,Residential,Wed May 21 00:00:00 EDT 2008,280987,38.474099,-121.4907112912 NORCADE CIR,SACRAMENTO,95826,CA,8,4,3612,Multi-Family,Wed May 21 00:00:00 EDT 2008,282400,38.559505,-121.3648399507 SEA CLIFF WAY,ELK GROVE,95758,CA,4,2,2056,Residential,Wed May 21 00:00:00 EDT 2008,285000,38.410992,-121.4790438882 AUTUMN GOLD CT,ELK GROVE,95624,CA,4,2,1993,Residential,Wed May 21 00:00:00 EDT 2008,287417,38.4439,-121.372555322 WHITE LOTUS WAY,ELK GROVE,95757,CA,3,2,1857,Residential,Wed May 21 00:00:00 EDT 2008,291000,38.391538,-121.4425961838 CASTRO WAY,SACRAMENTO,95818,CA,2,1,1126,Residential,Wed May 21 00:00:00 EDT 2008,292024,38.556098,-121.49078710158 CRAWFORD WAY,SACRAMENTO,95827,CA,4,4,2213,Multi-Family,Wed May 21 00:00:00 EDT 2008,297000,38.5703,-121.3157357731 MASTERS ST,ELK GROVE,95758,CA,5,3,2494,Residential,Wed May 21 00:00:00 EDT 2008,297000,38.442031,-121.4108734925 PERCHERON DR,ELK GROVE,95757,CA,3,2,1843,Residential,Wed May 21 00:00:00 EDT 2008,298000,38.40154,-121.4476492010 PROMONTORY POINT LN,GOLD RIVER,95670,CA,2,2,1520,Residential,Wed May 21 00:00:00 EDT 2008,299000,38.62869,-121.2616694727 SAVOIE WAY,SACRAMENTO,95835,CA,5,3,2800,Residential,Wed May 21 00:00:00 EDT 2008,304037,38.658182,-121.5495218664 MAGNOLIA HILL WAY,ELK GROVE,95624,CA,4,2,2309,Residential,Wed May 21 00:00:00 EDT 2008,311000,38.442352,-121.3896759570 HARVEST ROSE WAY,SACRAMENTO,95827,CA,5,3,2367,Residential,Wed May 21 00:00:00 EDT 2008,315537,38.555993,-121.3403524359 CREGAN CT,RANCHO CORDOVA,95742,CA,5,4,3516,Residential,Wed May 21 00:00:00 EDT 2008,320000,38.545128,-121.2249225337 DUSTY ROSE WAY,RANCHO CORDOVA,95742,CA,0,0,0,Residential,Wed May 21 00:00:00 EDT 2008,320000,38.528575,-121.22868929 SUTTERS GOLD DR,SACRAMENTO,95826,CA,4,3,1914,Residential,Wed May 21 00:00:00 EDT 2008,328360,38.550848,-121.3702248025 PEERLESS AVE,ORANGEVALE,95662,CA,2,1,1690,Residential,Wed May 21 00:00:00 EDT 2008,334150,38.71147,-121.2162144620 WELERA WAY,ELK GROVE,95757,CA,3,3,2725,Residential,Wed May 21 00:00:00 EDT 2008,335750,38.398609,-121.4501489723 TERRAPIN CT,ELK GROVE,95757,CA,4,3,2354,Residential,Wed May 21 00:00:00 EDT 2008,335750,38.403492,-121.4302242115 SMOKESTACK WAY,SACRAMENTO,95833,CA,0,0,0,Residential,Wed May 21 00:00:00 EDT 2008,339500,38.602416,-121.542965100 REBECCA WAY,FOLSOM,95630,CA,3,2,2185,Residential,Wed May 21 00:00:00 EDT 2008,344250,38.68479,-121.1491999488 OAK VILLAGE WAY,ELK GROVE,95758,CA,4,2,1801,Residential,Wed May 21 00:00:00 EDT 2008,346210,38.41333,-121.4049998495 DARTFORD DR,SACRAMENTO,95823,CA,3,3,1961,Residential,Wed May 21 00:00:00 EDT 2008,347029,38.448507,-121.4213466708 PONTA DO SOL WAY,ELK GROVE,95757,CA,4,2,3134,Residential,Wed May 21 00:00:00 EDT 2008,347650,38.380635,-121.4255384143 SEA MEADOW WAY,SACRAMENTO,95823,CA,4,3,1915,Residential,Wed May 21 00:00:00 EDT 2008,351300,38.46534,-121.4575193020 RICHARDSON CIR,EL DORADO HILLS,95762,CA,3,2,0,Residential,Wed May 21 00:00:00 EDT 2008,352000,38.691299,-121.0817528082 LINDA ISLE LN,SACRAMENTO,95831,CA,0,0,0,Residential,Wed May 21 00:00:00 EDT 2008,370000,38.4772,-121.521515300 MURIETA SOUTH PKWY,RANCHO MURIETA,95683,CA,4,3,2734,Residential,Wed May 21 00:00:00 EDT 2008,370500,38.4874,-121.07512911215 SHARRMONT CT,WILTON,95693,CA,3,2,2110,Residential,Wed May 21 00:00:00 EDT 2008,372000,38.35062,-121.2283497105 DANBERG WAY,ELK GROVE,95757,CA,5,3,3164,Residential,Wed May 21 00:00:00 EDT 2008,375000,38.4019,-121.4203885579 JERRY LITELL WAY,SACRAMENTO,95835,CA,5,3,3599,Residential,Wed May 21 00:00:00 EDT 2008,381300,38.677126,-121.5005191050 FOXHALL WAY,SACRAMENTO,95831,CA,4,2,2054,Residential,Wed May 21 00:00:00 EDT 2008,381942,38.509819,-121.5196617837 ABBINGTON WAY,ANTELOPE,95843,CA,4,2,1830,Residential,Wed May 21 00:00:00 EDT 2008,387731,38.709873,-121.3394721300 F ST,SACRAMENTO,95814,CA,3,3,1627,Residential,Wed May 21 00:00:00 EDT 2008,391000,38.58355,-121.4872896801 RAWLEY WAY,ELK GROVE,95757,CA,4,3,3440,Residential,Wed May 21 00:00:00 EDT 2008,394470,38.408351,-121.4239251693 SHELTER COVE DR,GREENWOOD,95635,CA,3,2,2846,Residential,Wed May 21 00:00:00 EDT 2008,395000,38.945357,-120.9088229361 WADDELL LN,ELK GROVE,95624,CA,4,3,2359,Residential,Wed May 21 00:00:00 EDT 2008,400186,38.450829,-121.34992810 SEA FOAM CT,SACRAMENTO,95831,CA,3,3,2052,Residential,Wed May 21 00:00:00 EDT 2008,415000,38.487885,-121.5459476945 RIO TEJO WAY,ELK GROVE,95757,CA,5,3,3433,Residential,Wed May 21 00:00:00 EDT 2008,425000,38.385638,-121.4226164186 TULIP PARK WAY,RANCHO CORDOVA,95742,CA,5,3,3615,Residential,Wed May 21 00:00:00 EDT 2008,430000,38.550617,-121.235269278 DAIRY CT,ELK GROVE,95624,CA,0,0,0,Residential,Wed May 21 00:00:00 EDT 2008,445000,38.420338,-121.363757207 ORANGE BLOSSOM CIR Unit C,FOLSOM,95630,CA,5,3,2687,Residential,Wed May 21 00:00:00 EDT 2008,460000,38.646273,-121.1753226507 RIO DE ONAR WAY,ELK GROVE,95757,CA,4,3,2724,Residential,Wed May 21 00:00:00 EDT 2008,461000,38.38253,-121.4280077004 RAWLEY WAY,ELK GROVE,95757,CA,4,3,3440,Residential,Wed May 21 00:00:00 EDT 2008,489332,38.406421,-121.4220816503 RIO DE ONAR WAY,ELK GROVE,95757,CA,5,4,3508,Residential,Wed May 21 00:00:00 EDT 2008,510000,38.38253,-121.4280382217 APPALOOSA CT,FOLSOM,95630,CA,4,2,2462,Residential,Wed May 21 00:00:00 EDT 2008,539000,38.655167,-121.090178868 HILDEBRAND CIR,FOLSOM,95630,CA,0,0,0,Residential,Wed May 21 00:00:00 EDT 2008,585000,38.670947,-121.0977276030 PALERMO WAY,EL DORADO HILLS,95762,CA,4,3,0,Residential,Wed May 21 00:00:00 EDT 2008,600000,38.672761,-121.0503784070 REDONDO DR,EL DORADO HILLS,95762,CA,4,3,0,Residential,Wed May 21 00:00:00 EDT 2008,606238,38.666807,-121.064834004 CRESTA WAY,SACRAMENTO,95864,CA,3,3,2325,Residential,Wed May 21 00:00:00 EDT 2008,660000,38.591618,-121.370626315 JUMEL CT,EL DORADO HILLS,95762,CA,6,5,0,Residential,Wed May 21 00:00:00 EDT 2008,830000,38.669931,-121.059586272 LONGFORD DR Unit 1,CITRUS HEIGHTS,95621,CA,2,1,795,Condo,Tue May 20 00:00:00 EDT 2008,69000,38.680923,-121.3139453432 Y ST,SACRAMENTO,95817,CA,4,2,1099,Residential,Tue May 20 00:00:00 EDT 2008,70000,38.554967,-121.4680469512 EMERALD PARK DR Unit 3,ELK GROVE,95624,CA,2,1,840,Condo,Tue May 20 00:00:00 EDT 2008,71000,38.40573,-121.3698323132 CLAY ST,SACRAMENTO,95815,CA,2,1,800,Residential,Tue May 20 00:00:00 EDT 2008,78000,38.624678,-121.4392035221 38TH AVE,SACRAMENTO,95824,CA,2,1,746,Residential,Tue May 20 00:00:00 EDT 2008,78400,38.518044,-121.4435556112 HERMOSA ST,SACRAMENTO,95822,CA,3,1,1067,Residential,Tue May 20 00:00:00 EDT 2008,80000,38.515125,-121.480416483 ARCADE BLVD,SACRAMENTO,95815,CA,4,2,1316,Residential,Tue May 20 00:00:00 EDT 2008,89000,38.623571,-121.454884671 SONOMA AVE,SACRAMENTO,95815,CA,3,1,1337,Residential,Tue May 20 00:00:00 EDT 2008,90000,38.622953,-121.4501425980 79TH ST,SACRAMENTO,95824,CA,2,1,868,Residential,Tue May 20 00:00:00 EDT 2008,90000,38.518373,-121.4117797607 ELDER CREEK RD,SACRAMENTO,95824,CA,3,1,924,Residential,Tue May 20 00:00:00 EDT 2008,92000,38.51055,-121.4147685028 14TH AVE,SACRAMENTO,95820,CA,2,1,610,Residential,Tue May 20 00:00:00 EDT 2008,93675,38.53942,-121.44689414788 NATCHEZ CT,RANCHO MURIETA,95683,CA,0,0,0,Residential,Tue May 20 00:00:00 EDT 2008,97750,38.492287,-121.1000321069 ACACIA AVE,SACRAMENTO,95815,CA,2,1,1220,Residential,Tue May 20 00:00:00 EDT 2008,98000,38.621998,-121.4422385201 LAGUNA OAKS DR Unit 199,ELK GROVE,95758,CA,1,1,722,Condo,Tue May 20 00:00:00 EDT 2008,98000,38.423251,-121.4444893847 LAS PASAS WAY,SACRAMENTO,95864,CA,3,1,1643,Residential,Tue May 20 00:00:00 EDT 2008,99000,38.588672,-121.3739165201 LAGUNA OAKS DR Unit 172,ELK GROVE,95758,CA,1,1,722,Condo,Tue May 20 00:00:00 EDT 2008,100000,38.423251,-121.4444891121 CREEKSIDE WAY,GALT,95632,CA,3,1,1080,Residential,Tue May 20 00:00:00 EDT 2008,106716,38.241514,-121.3121995307 CABRILLO WAY,SACRAMENTO,95820,CA,3,1,1039,Residential,Tue May 20 00:00:00 EDT 2008,111000,38.52712,-121.4353483725 DON JULIO BLVD,NORTH HIGHLANDS,95660,CA,3,1,1051,Residential,Tue May 20 00:00:00 EDT 2008,111000,38.67895,-121.3794064803 MCCLOUD DR,SACRAMENTO,95842,CA,2,2,967,Residential,Tue May 20 00:00:00 EDT 2008,114800,38.682279,-121.35281710542 SILVERWOOD WAY,RANCHO CORDOVA,95670,CA,3,1,1098,Residential,Tue May 20 00:00:00 EDT 2008,120108,38.587156,-121.2957786318 39TH AVE,SACRAMENTO,95824,CA,3,1,1050,Residential,Tue May 20 00:00:00 EDT 2008,123225,38.518942,-121.430158211 MCDANIEL CIR,SACRAMENTO,95838,CA,3,2,1110,Residential,Tue May 20 00:00:00 EDT 2008,123750,38.636565,-121.4603833800 LYNHURST WAY,NORTH HIGHLANDS,95660,CA,3,1,888,Residential,Tue May 20 00:00:00 EDT 2008,125000,38.650445,-121.3748616139 HERMOSA ST,SACRAMENTO,95822,CA,3,2,1120,Residential,Tue May 20 00:00:00 EDT 2008,125000,38.514665,-121.4804112505 RHINE WAY,ELVERTA,95626,CA,3,2,1080,Residential,Tue May 20 00:00:00 EDT 2008,126000,38.717976,-121.4076843692 PAYNE WAY,NORTH HIGHLANDS,95660,CA,3,1,957,Residential,Tue May 20 00:00:00 EDT 2008,129000,38.66654,-121.378298604 MORRISON AVE,SACRAMENTO,95838,CA,2,1,952,Residential,Tue May 20 00:00:00 EDT 2008,134000,38.637678,-121.452476648 SANTA ANA AVE,SACRAMENTO,95838,CA,3,2,1211,Residential,Tue May 20 00:00:00 EDT 2008,135000,38.658478,-121.45040914 ASHLEY OAKS CT,SACRAMENTO,95815,CA,3,2,1264,Residential,Tue May 20 00:00:00 EDT 2008,135500,38.61779,-121.4367653174 NORTHVIEW DR,SACRAMENTO,95833,CA,3,1,1080,Residential,Tue May 20 00:00:00 EDT 2008,140000,38.623817,-121.477827840 TRANQUIL LN,GALT,95632,CA,3,2,1266,Residential,Tue May 20 00:00:00 EDT 2008,140000,38.270617,-121.2992055333 PRIMROSE DR Unit 19A,FAIR OAKS,95628,CA,2,2,994,Condo,Tue May 20 00:00:00 EDT 2008,142500,38.662785,-121.2762721035 MILLET WAY,SACRAMENTO,95834,CA,3,2,1202,Residential,Tue May 20 00:00:00 EDT 2008,143500,38.631056,-121.485085201 LAGUNA OAKS DR Unit 126,ELK GROVE,95758,CA,0,0,0,Condo,Tue May 20 00:00:00 EDT 2008,145000,38.423251,-121.4444893328 22ND AVE,SACRAMENTO,95820,CA,2,1,722,Residential,Tue May 20 00:00:00 EDT 2008,145000,38.532727,-121.4707838001 HARTWICK WAY,SACRAMENTO,95828,CA,4,2,1448,Residential,Tue May 20 00:00:00 EDT 2008,145000,38.488623,-121.4105827812 HARTWICK WAY,SACRAMENTO,95828,CA,3,2,1188,Residential,Tue May 20 00:00:00 EDT 2008,145000,38.488611,-121.4128084207 PAINTER WAY,NORTH HIGHLANDS,95660,CA,4,2,1183,Residential,Tue May 20 00:00:00 EDT 2008,146000,38.692915,-121.3674977458 WINKLEY WAY,SACRAMENTO,95822,CA,3,1,1320,Residential,Tue May 20 00:00:00 EDT 2008,148500,38.487444,-121.4913668354 SUNRISE WOODS WAY,SACRAMENTO,95828,CA,3,2,1117,Residential,Tue May 20 00:00:00 EDT 2008,149000,38.473288,-121.39638116 COTTONMILL CIR,SACRAMENTO,95828,CA,3,2,1364,Residential,Tue May 20 00:00:00 EDT 2008,150000,38.482876,-121.4059124660 CEDARWOOD WAY,SACRAMENTO,95823,CA,4,2,1310,Residential,Tue May 20 00:00:00 EDT 2008,150000,38.484834,-121.4493169254 HARROGATE WAY,ELK GROVE,95758,CA,2,2,1006,Residential,Tue May 20 00:00:00 EDT 2008,152000,38.420138,-121.4121796716 TAREYTON WAY,CITRUS HEIGHTS,95621,CA,3,2,1104,Residential,Tue May 20 00:00:00 EDT 2008,156000,38.693724,-121.3071692028 ROBERT WAY,SACRAMENTO,95825,CA,2,1,810,Residential,Tue May 20 00:00:00 EDT 2008,156000,38.609982,-121.4192639346 AIZENBERG CIR,ELK GROVE,95624,CA,2,2,1123,Residential,Tue May 20 00:00:00 EDT 2008,156000,38.41875,-121.3700194524 LOCH HAVEN WAY,SACRAMENTO,95842,CA,2,1,904,Residential,Tue May 20 00:00:00 EDT 2008,157788,38.67273,-121.3596457140 BLUE SPRINGS WAY,CITRUS HEIGHTS,95621,CA,3,2,1156,Residential,Tue May 20 00:00:00 EDT 2008,161653,38.720653,-121.3022414631 11TH AVE,SACRAMENTO,95820,CA,2,1,1321,Residential,Tue May 20 00:00:00 EDT 2008,161829,38.541965,-121.4521323228 BAGGAN CT,ANTELOPE,95843,CA,3,2,1392,Residential,Tue May 20 00:00:00 EDT 2008,165000,38.715346,-121.3881638515 DARTFORD DR,SACRAMENTO,95823,CA,3,2,1439,Residential,Tue May 20 00:00:00 EDT 2008,168000,38.448288,-121.4207194500 TIPPWOOD WAY,SACRAMENTO,95842,CA,3,2,1159,Residential,Tue May 20 00:00:00 EDT 2008,169000,38.69951,-121.3599892460 EL ROCCO WAY,RANCHO CORDOVA,95670,CA,3,2,1671,Residential,Tue May 20 00:00:00 EDT 2008,175000,38.591477,-121.315348244 SUNBIRD WAY,SACRAMENTO,95823,CA,3,2,1740,Residential,Tue May 20 00:00:00 EDT 2008,176250,38.457654,-121.4313815841 VALLEY VALE WAY,SACRAMENTO,95823,CA,3,2,1265,Residential,Tue May 20 00:00:00 EDT 2008,179000,38.461283,-121.4343227863 CRESTLEIGH CT,ANTELOPE,95843,CA,2,2,1007,Residential,Tue May 20 00:00:00 EDT 2008,180000,38.710889,-121.3588767129 SPRINGMONT DR,ELK GROVE,95758,CA,3,2,1716,Residential,Tue May 20 00:00:00 EDT 2008,180400,38.417649,-121.4202948284 RED FOX WAY,ELK GROVE,95758,CA,4,2,1685,Residential,Tue May 20 00:00:00 EDT 2008,182000,38.417182,-121.3972312219 EL CANTO CIR,RANCHO CORDOVA,95670,CA,4,2,1829,Residential,Tue May 20 00:00:00 EDT 2008,184500,38.592383,-121.3186698907 GEMWOOD WAY,ELK GROVE,95758,CA,3,2,1555,Residential,Tue May 20 00:00:00 EDT 2008,185000,38.435471,-121.4411735925 MALEVILLE AVE,CARMICHAEL,95608,CA,4,2,1120,Residential,Tue May 20 00:00:00 EDT 2008,189000,38.666564,-121.3257177031 CANEVALLEY CIR,CITRUS HEIGHTS,95621,CA,3,2,1137,Residential,Tue May 20 00:00:00 EDT 2008,194000,38.718693,-121.3036193949 WILDROSE WAY,SACRAMENTO,95826,CA,3,1,1174,Residential,Tue May 20 00:00:00 EDT 2008,195000,38.543697,-121.3666834437 MITCHUM CT,ANTELOPE,95843,CA,3,2,1393,Residential,Tue May 20 00:00:00 EDT 2008,200000,38.704407,-121.361132778 KAWEAH CT,CAMERON PARK,95682,CA,3,1,0,Residential,Tue May 20 00:00:00 EDT 2008,201000,38.694052,-120.9955891636 ALLENWOOD CIR,LINCOLN,95648,CA,4,2,0,Residential,Tue May 20 00:00:00 EDT 2008,202500,38.879192,-121.3094778151 QUAIL RIDGE CT,SACRAMENTO,95828,CA,3,2,1289,Residential,Tue May 20 00:00:00 EDT 2008,205000,38.461296,-121.3908584899 WIND CREEK DR,SACRAMENTO,95838,CA,4,2,1799,Residential,Tue May 20 00:00:00 EDT 2008,205000,38.655887,-121.4461192370 BIG CANYON CREEK RD,PLACERVILLE,95667,CA,3,2,0,Residential,Tue May 20 00:00:00 EDT 2008,205000,38.74458,-120.7942546049 HAMBURG WAY,SACRAMENTO,95823,CA,4,3,1953,Residential,Tue May 20 00:00:00 EDT 2008,205000,38.443253,-121.4319924232 71ST ST,SACRAMENTO,95820,CA,2,1,723,Residential,Tue May 20 00:00:00 EDT 2008,207000,38.536741,-121.421153361 BOW MAR CT,CAMERON PARK,95682,CA,2,2,0,Residential,Tue May 20 00:00:00 EDT 2008,210000,38.69437,-120.9966021889 COLD SPRINGS RD,PLACERVILLE,95667,CA,2,1,948,Residential,Tue May 20 00:00:00 EDT 2008,211500,38.739774,-120.8602435805 HIMALAYA WAY,CITRUS HEIGHTS,95621,CA,4,2,1578,Residential,Tue May 20 00:00:00 EDT 2008,215000,38.696489,-121.3285557944 SYLVAN OAK WAY,CITRUS HEIGHTS,95610,CA,3,2,1317,Residential,Tue May 20 00:00:00 EDT 2008,215000,38.710388,-121.2610963139 SPOONWOOD WAY Unit 1,SACRAMENTO,95833,CA,0,0,0,Residential,Tue May 20 00:00:00 EDT 2008,215500,38.626582,-121.521516217 LEOLA WAY,SACRAMENTO,95824,CA,3,1,1360,Residential,Tue May 20 00:00:00 EDT 2008,222381,38.513066,-121.4519092340 HURLEY WAY,SACRAMENTO,95825,CA,0,0,0,Condo,Tue May 20 00:00:00 EDT 2008,225000,38.588816,-121.4085493035 BRUNNET LN,SACRAMENTO,95833,CA,3,2,1522,Residential,Tue May 20 00:00:00 EDT 2008,225000,38.624762,-121.5227753025 EL PRADO WAY,SACRAMENTO,95825,CA,4,2,1751,Residential,Tue May 20 00:00:00 EDT 2008,225000,38.606603,-121.3941479387 GRANITE FALLS CT,ELK GROVE,95624,CA,3,2,1465,Residential,Tue May 20 00:00:00 EDT 2008,225000,38.419214,-121.3485339257 CALDERA WAY,SACRAMENTO,95826,CA,4,2,1605,Residential,Tue May 20 00:00:00 EDT 2008,228000,38.55821,-121.355022441 ARLINGDALE CIR,RIO LINDA,95673,CA,4,2,1475,Residential,Tue May 20 00:00:00 EDT 2008,229665,38.702893,-121.4549492284 LOS ROBLES RD,MEADOW VISTA,95722,CA,3,1,1216,Residential,Tue May 20 00:00:00 EDT 2008,230000,39.008159,-121.036238164 CHENIN BLANC LN,FAIR OAKS,95628,CA,2,2,1315,Residential,Tue May 20 00:00:00 EDT 2008,230000,38.665644,-121.2599694620 CHAMBERLIN CIR,ELK GROVE,95757,CA,3,2,1567,Residential,Tue May 20 00:00:00 EDT 2008,230000,38.390557,-121.4498055340 BIRK WAY,SACRAMENTO,95835,CA,3,2,1776,Residential,Tue May 20 00:00:00 EDT 2008,234000,38.672495,-121.51525151 ANJOU CIR,SACRAMENTO,95835,CA,3,2,2187,Residential,Tue May 20 00:00:00 EDT 2008,235000,38.661658,-121.5406332125 22ND AVE,SACRAMENTO,95822,CA,3,1,1291,Residential,Tue May 20 00:00:00 EDT 2008,236250,38.534596,-121.493121611 BLOSSOM ROCK LN,FOLSOM,95630,CA,0,0,0,Condo,Tue May 20 00:00:00 EDT 2008,240000,38.6457,-121.11978830 ADUR RD,ELK GROVE,95624,CA,0,0,0,Residential,Tue May 20 00:00:00 EDT 2008,242000,38.43742,-121.3728767344 BUTTERBALL WAY,SACRAMENTO,95842,CA,3,2,1503,Residential,Tue May 20 00:00:00 EDT 2008,245000,38.699489,-121.3618288219 GWINHURST CIR,SACRAMENTO,95828,CA,4,3,2491,Residential,Tue May 20 00:00:00 EDT 2008,245000,38.459711,-121.3842833240 S ST,SACRAMENTO,95816,CA,2,1,1269,Residential,Tue May 20 00:00:00 EDT 2008,245000,38.562296,-121.467489221 PICASSO CIR,SACRAMENTO,95835,CA,0,0,0,Residential,Tue May 20 00:00:00 EDT 2008,250000,38.676658,-121.5281285706 GREENACRES WAY,ORANGEVALE,95662,CA,3,2,1176,Residential,Tue May 20 00:00:00 EDT 2008,250000,38.669882,-121.2135336900 LONICERA DR,ORANGEVALE,95662,CA,4,2,1456,Residential,Tue May 20 00:00:00 EDT 2008,250000,38.692199,-121.250975419 DAWNRIDGE RD,ROSEVILLE,95678,CA,3,2,1498,Residential,Tue May 20 00:00:00 EDT 2008,250000,38.725283,-121.2979535312 MARBURY WAY,ANTELOPE,95843,CA,3,2,1574,Residential,Tue May 20 00:00:00 EDT 2008,255000,38.710221,-121.3416516344 BONHAM CIR,CITRUS HEIGHTS,95610,CA,5,4,2085,Multi-Family,Tue May 20 00:00:00 EDT 2008,256054,38.682358,-121.2728768207 YORKTON WAY,SACRAMENTO,95829,CA,3,2,2170,Residential,Tue May 20 00:00:00 EDT 2008,257729,38.45967,-121.3604617922 MANSELL WAY,ELK GROVE,95758,CA,4,2,1595,Residential,Tue May 20 00:00:00 EDT 2008,260000,38.409634,-121.4107875712 MELBURY CIR,ANTELOPE,95843,CA,3,2,1567,Residential,Tue May 20 00:00:00 EDT 2008,261000,38.705849,-121.334701632 NEWBRIDGE LN,LINCOLN,95648,CA,4,2,0,Residential,Tue May 20 00:00:00 EDT 2008,261800,38.879084,-121.2985861570 GLIDDEN AVE,SACRAMENTO,95822,CA,4,2,1253,Residential,Tue May 20 00:00:00 EDT 2008,264469,38.482704,-121.5004338108 FILIFERA WAY,ANTELOPE,95843,CA,4,3,1768,Residential,Tue May 20 00:00:00 EDT 2008,265000,38.717042,-121.35468230 BANKSIDE WAY,SACRAMENTO,95835,CA,0,0,0,Residential,Tue May 20 00:00:00 EDT 2008,270000,38.676937,-121.5292445342 CALABRIA WAY,SACRAMENTO,95835,CA,4,3,2030,Residential,Tue May 20 00:00:00 EDT 2008,270000,38.671807,-121.49827447 NAPONEE CT,SACRAMENTO,95835,CA,3,2,1531,Residential,Tue May 20 00:00:00 EDT 2008,270000,38.665704,-121.5290964236 ADRIATIC SEA WAY,SACRAMENTO,95834,CA,0,0,0,Residential,Tue May 20 00:00:00 EDT 2008,270000,38.647961,-121.5431628864 REMBRANT CT,ELK GROVE,95624,CA,4,3,1653,Residential,Tue May 20 00:00:00 EDT 2008,275000,38.435288,-121.3757039455 SEA CLIFF WAY,ELK GROVE,95758,CA,4,2,2056,Residential,Tue May 20 00:00:00 EDT 2008,275000,38.411522,-121.4814069720 LITTLE HARBOR WAY,ELK GROVE,95624,CA,4,3,2494,Residential,Tue May 20 00:00:00 EDT 2008,280000,38.404934,-121.3524058806 PHOENIX AVE,FAIR OAKS,95628,CA,3,2,1450,Residential,Tue May 20 00:00:00 EDT 2008,286013,38.660322,-121.2301013578 LOGGERHEAD WAY,SACRAMENTO,95834,CA,4,2,2169,Residential,Tue May 20 00:00:00 EDT 2008,292000,38.633028,-121.5267551416 LOCKHART WAY,ROSEVILLE,95747,CA,3,2,1440,Residential,Tue May 20 00:00:00 EDT 2008,292000,38.752399,-121.3303285413 BUENA VENTURA WAY,FAIR OAKS,95628,CA,3,2,1527,Residential,Tue May 20 00:00:00 EDT 2008,293993,38.664552,-121.25593737 WHITE BIRCH CT,ROSEVILLE,95678,CA,3,2,1401,Residential,Tue May 20 00:00:00 EDT 2008,294000,38.776327,-121.284514405 MARLIN SPIKE WAY,SACRAMENTO,95838,CA,3,2,1411,Residential,Tue May 20 00:00:00 EDT 2008,296769,38.65783,-121.4568421102 CHESLEY LN,LINCOLN,95648,CA,4,4,0,Residential,Tue May 20 00:00:00 EDT 2008,297500,38.864864,-121.31398811281 STANFORD COURT LN Unit 604,GOLD RIVER,95670,CA,0,0,0,Condo,Tue May 20 00:00:00 EDT 2008,300000,38.625289,-121.2602867320 6TH ST,RIO LINDA,95673,CA,3,1,1284,Residential,Tue May 20 00:00:00 EDT 2008,300000,38.700553,-121.452223993 MANTON CT,GALT,95632,CA,4,3,2307,Residential,Tue May 20 00:00:00 EDT 2008,300000,38.272942,-121.2891484487 PANORAMA DR,PLACERVILLE,95667,CA,3,2,1329,Residential,Tue May 20 00:00:00 EDT 2008,300000,38.694559,-120.8481575651 OVERLEAF WAY,SACRAMENTO,95835,CA,4,2,1910,Residential,Tue May 20 00:00:00 EDT 2008,300500,38.677454,-121.4947912015 PROMONTORY POINT LN,GOLD RIVER,95670,CA,3,2,1981,Residential,Tue May 20 00:00:00 EDT 2008,305000,38.628732,-121.2611493224 PARKHAM DR,ROSEVILLE,95747,CA,0,0,0,Residential,Tue May 20 00:00:00 EDT 2008,306500,38.772771,-121.36487715 VANESSA PL,SACRAMENTO,95835,CA,0,0,0,Residential,Tue May 20 00:00:00 EDT 2008,312500,38.668692,-121.545491312 RENISON LN,LINCOLN,95648,CA,5,3,0,Residential,Tue May 20 00:00:00 EDT 2008,315000,38.866409,-121.3084858 RIVER RAFT CT,SACRAMENTO,95823,CA,4,2,2205,Residential,Tue May 20 00:00:00 EDT 2008,319789,38.447353,-121.4349692251 LAMPLIGHT LN,LINCOLN,95648,CA,2,2,1449,Residential,Tue May 20 00:00:00 EDT 2008,330000,38.849924,-121.275729106 FARHAM DR,FOLSOM,95630,CA,3,2,1258,Residential,Tue May 20 00:00:00 EDT 2008,330000,38.667834,-121.1685785405 NECTAR CIR,ELK GROVE,95757,CA,3,2,2575,Residential,Tue May 20 00:00:00 EDT 2008,331000,38.387014,-121.4409675411 10TH AVE,SACRAMENTO,95820,CA,2,1,539,Residential,Tue May 20 00:00:00 EDT 2008,334000,38.542727,-121.4424493512 RAINSONG CIR,RANCHO CORDOVA,95670,CA,4,3,2208,Residential,Tue May 20 00:00:00 EDT 2008,336000,38.573488,-121.2828091106 55TH ST,SACRAMENTO,95819,CA,3,1,1108,Residential,Tue May 20 00:00:00 EDT 2008,339000,38.563805,-121.436395411 ILLSLEY WAY,FOLSOM,95630,CA,4,2,1595,Residential,Tue May 20 00:00:00 EDT 2008,339000,38.652002,-121.129504796 BUTTERCUP CIR,GALT,95632,CA,4,2,2159,Residential,Tue May 20 00:00:00 EDT 2008,345000,38.279581,-121.3008281230 SANDRA CIR,PLACERVILLE,95667,CA,4,3,2295,Residential,Tue May 20 00:00:00 EDT 2008,350000,38.738141,-120.784145318 ANACAPA DR,ROSEVILLE,95678,CA,3,2,1838,Residential,Tue May 20 00:00:00 EDT 2008,356000,38.782094,-121.2971333975 SHINING STAR DR,SACRAMENTO,95823,CA,4,2,1900,Residential,Tue May 20 00:00:00 EDT 2008,361745,38.487409,-121.4614131620 BASLER ST,SACRAMENTO,95811,CA,4,2,1718,Residential,Tue May 20 00:00:00 EDT 2008,361948,38.591822,-121.4786449688 NATURE TRAIL WAY,ELK GROVE,95757,CA,5,3,3389,Residential,Tue May 20 00:00:00 EDT 2008,370000,38.405224,-121.4792755924 TANUS CIR,ROCKLIN,95677,CA,4,2,0,Residential,Tue May 20 00:00:00 EDT 2008,380000,38.778691,-121.2042929629 CEDAR OAK WAY,ELK GROVE,95757,CA,5,4,3260,Residential,Tue May 20 00:00:00 EDT 2008,385000,38.405527,-121.4317463429 FERNBROOK CT,CAMERON PARK,95682,CA,3,2,2016,Residential,Tue May 20 00:00:00 EDT 2008,399000,38.664225,-121.0071732121 HANNAH WAY,ROCKLIN,95765,CA,4,2,2607,Residential,Tue May 20 00:00:00 EDT 2008,402000,38.805749,-121.28093110104 ANNIE ST,ELK GROVE,95757,CA,4,3,2724,Residential,Tue May 20 00:00:00 EDT 2008,406026,38.390465,-121.4434791092 MAUGHAM CT,GALT,95632,CA,5,4,3746,Residential,Tue May 20 00:00:00 EDT 2008,420000,38.271646,-121.2868485404 ALMOND FALLS WAY,RANCHO CORDOVA,95742,CA,0,0,0,Residential,Tue May 20 00:00:00 EDT 2008,425000,38.527502,-121.2334926306 CONEJO,RANCHO MURIETA,95683,CA,4,2,3192,Residential,Tue May 20 00:00:00 EDT 2008,425000,38.512602,-121.08723314 CASA VATONI PL,SACRAMENTO,95834,CA,0,0,0,Residential,Tue May 20 00:00:00 EDT 2008,433500,38.650221,-121.5517041456 EAGLESFIELD LN,LINCOLN,95648,CA,4,3,0,Residential,Tue May 20 00:00:00 EDT 2008,436746,38.857635,-121.3113754100 BOTHWELL CIR,EL DORADO HILLS,95762,CA,5,3,0,Residential,Tue May 20 00:00:00 EDT 2008,438700,38.679136,-121.034329427 21ST ST,SACRAMENTO,95811,CA,2,1,1247,Residential,Tue May 20 00:00:00 EDT 2008,445000,38.582604,-121.475761044 GALSTON DR,FOLSOM,95630,CA,4,2,2581,Residential,Tue May 20 00:00:00 EDT 2008,450000,38.676306,-121.099544440 SYCAMORE AVE,SACRAMENTO,95841,CA,3,1,2068,Residential,Tue May 20 00:00:00 EDT 2008,460000,38.646374,-121.3536581032 SOUZA DR,EL DORADO HILLS,95762,CA,3,2,0,Residential,Tue May 20 00:00:00 EDT 2008,460000,38.668239,-121.0644379760 LAZULITE CT,ELK GROVE,95624,CA,4,3,3992,Residential,Tue May 20 00:00:00 EDT 2008,460000,38.403609,-121.335541241 LANFRANCO CIR,SACRAMENTO,95835,CA,4,4,3397,Residential,Tue May 20 00:00:00 EDT 2008,465000,38.665696,-121.5494375559 NORTHBOROUGH DR,SACRAMENTO,95835,CA,5,3,3881,Residential,Tue May 20 00:00:00 EDT 2008,471750,38.677225,-121.5196872125 BIG SKY DR,ROCKLIN,95765,CA,5,3,0,Residential,Tue May 20 00:00:00 EDT 2008,480000,38.801637,-121.2787982109 HAMLET PL,CARMICHAEL,95608,CA,2,2,1598,Residential,Tue May 20 00:00:00 EDT 2008,484000,38.602754,-121.3293269970 STATE HIGHWAY 193,PLACERVILLE,95667,CA,4,3,1929,Residential,Tue May 20 00:00:00 EDT 2008,485000,38.787877,-120.8166762901 PINTAIL WAY,ELK GROVE,95757,CA,4,3,3070,Residential,Tue May 20 00:00:00 EDT 2008,495000,38.398488,-121.473424201 FIRESTONE DR,ROSEVILLE,95678,CA,0,0,0,Residential,Tue May 20 00:00:00 EDT 2008,500500,38.770153,-121.3000391740 HIGH ST,AUBURN,95603,CA,3,3,0,Residential,Tue May 20 00:00:00 EDT 2008,504000,38.891935,-121.084342733 DANA LOOP,EL DORADO HILLS,95762,CA,0,0,0,Residential,Tue May 20 00:00:00 EDT 2008,541000,38.628459,-121.0550789741 SADDLEBRED CT,WILTON,95693,CA,0,0,0,Residential,Tue May 20 00:00:00 EDT 2008,560000,38.408841,-121.1980397756 TIGERWOODS DR,SACRAMENTO,95829,CA,5,3,3984,Residential,Tue May 20 00:00:00 EDT 2008,572500,38.47643,-121.3092435709 RIVER OAK WAY,CARMICHAEL,95608,CA,4,2,2222,Residential,Tue May 20 00:00:00 EDT 2008,582000,38.602461,-121.3309792981 WRINGER DR,ROSEVILLE,95661,CA,4,3,3838,Residential,Tue May 20 00:00:00 EDT 2008,613401,38.735373,-121.2270728616 ROCKPORTE CT,ROSEVILLE,95747,CA,4,2,0,Residential,Tue May 20 00:00:00 EDT 2008,614000,38.742118,-121.3599094128 HILL ST,FAIR OAKS,95628,CA,5,5,2846,Residential,Tue May 20 00:00:00 EDT 2008,680000,38.64167,-121.2620991409 47TH ST,SACRAMENTO,95819,CA,5,2,2484,Residential,Tue May 20 00:00:00 EDT 2008,699000,38.563244,-121.4468763935 EL MONTE DR,LOOMIS,95650,CA,4,4,1624,Residential,Tue May 20 00:00:00 EDT 2008,839000,38.813337,-121.1333485840 WALERGA RD,SACRAMENTO,95842,CA,2,1,840,Condo,Mon May 19 00:00:00 EDT 2008,40000,38.673678,-121.357471923 FULTON AVE,SACRAMENTO,95825,CA,1,1,484,Condo,Mon May 19 00:00:00 EDT 2008,48000,38.582279,-121.401482261 REDONDO AVE,SACRAMENTO,95815,CA,3,1,970,Residential,Mon May 19 00:00:00 EDT 2008,61500,38.620685,-121.4605394030 BROADWAY,SACRAMENTO,95817,CA,2,1,623,Residential,Mon May 19 00:00:00 EDT 2008,62050,38.546798,-121.4600383660 22ND AVE,SACRAMENTO,95820,CA,2,1,932,Residential,Mon May 19 00:00:00 EDT 2008,65000,38.532718,-121.467473924 HIGH ST,SACRAMENTO,95838,CA,2,1,796,Residential,Mon May 19 00:00:00 EDT 2008,65000,38.638797,-121.4350494734 14TH AVE,SACRAMENTO,95820,CA,2,1,834,Residential,Mon May 19 00:00:00 EDT 2008,68000,38.539447,-121.4508584734 14TH AVE,SACRAMENTO,95820,CA,2,1,834,Residential,Mon May 19 00:00:00 EDT 2008,68000,38.539447,-121.4508585050 RHODE ISLAND DR Unit 4,SACRAMENTO,95841,CA,2,1,924,Condo,Mon May 19 00:00:00 EDT 2008,77000,38.658739,-121.3335614513 GREENHOLME DR,SACRAMENTO,95842,CA,2,1,795,Condo,Mon May 19 00:00:00 EDT 2008,82732,38.669104,-121.3590083845 ELM ST,SACRAMENTO,95838,CA,3,1,1250,Residential,Mon May 19 00:00:00 EDT 2008,84000,38.637337,-121.4328353908 17TH AVE,SACRAMENTO,95820,CA,2,1,984,Residential,Mon May 19 00:00:00 EDT 2008,84675,38.53728,-121.4635317109 CHANDLER DR,SACRAMENTO,95828,CA,3,1,1013,Residential,Mon May 19 00:00:00 EDT 2008,85000,38.497237,-121.4241877541 SKELTON WAY,SACRAMENTO,95822,CA,3,1,1012,Residential,Mon May 19 00:00:00 EDT 2008,90000,38.484274,-121.4888519058 MONTOYA ST,SACRAMENTO,95826,CA,2,1,795,Condo,Mon May 19 00:00:00 EDT 2008,90000,38.559144,-121.3683871016 CONGRESS AVE,SACRAMENTO,95838,CA,2,2,918,Residential,Mon May 19 00:00:00 EDT 2008,91000,38.630151,-121.442789540 MORRISON AVE,SACRAMENTO,95838,CA,3,1,1082,Residential,Mon May 19 00:00:00 EDT 2008,95000,38.637704,-121.4539465303 JERRETT WAY,SACRAMENTO,95842,CA,2,1,964,Residential,Mon May 19 00:00:00 EDT 2008,97500,38.663282,-121.3596312820 DEL PASO BLVD,SACRAMENTO,95815,CA,4,2,1404,Multi-Family,Mon May 19 00:00:00 EDT 2008,100000,38.617718,-121.4400893715 TALLYHO DR Unit 78HIGH,SACRAMENTO,95826,CA,1,1,625,Condo,Mon May 19 00:00:00 EDT 2008,100000,38.544627,-121.357966013 ROWAN WAY,CITRUS HEIGHTS,95621,CA,2,1,888,Residential,Mon May 19 00:00:00 EDT 2008,101000,38.675893,-121.29632987 PONDEROSA LN,SACRAMENTO,95815,CA,4,2,1120,Residential,Mon May 19 00:00:00 EDT 2008,102750,38.622243,-121.4578633732 LANKERSHIM WAY,NORTH HIGHLANDS,95660,CA,3,1,1331,Residential,Mon May 19 00:00:00 EDT 2008,112500,38.68972,-121.3783992216 DUNLAP DR,SACRAMENTO,95821,CA,3,1,1014,Residential,Mon May 19 00:00:00 EDT 2008,113000,38.623738,-121.413053503 21ST AVE,SACRAMENTO,95820,CA,4,2,1448,Residential,Mon May 19 00:00:00 EDT 2008,114000,38.53361,-121.469308523 EXCHANGE ST,SACRAMENTO,95838,CA,3,1,966,Residential,Mon May 19 00:00:00 EDT 2008,114000,38.659414,-121.454088101 PORT ROYALE WAY,SACRAMENTO,95823,CA,2,1,779,Residential,Mon May 19 00:00:00 EDT 2008,114750,38.463929,-121.4386678020 WALERGA RD,ANTELOPE,95843,CA,2,2,836,Condo,Mon May 19 00:00:00 EDT 2008,115000,38.71607,-121.364468167 VALLEY OAK DR,ROSEVILLE,95678,CA,2,2,1100,Condo,Mon May 19 00:00:00 EDT 2008,115000,38.732429,-121.2880697876 BURLINGTON WAY,SACRAMENTO,95832,CA,3,1,1174,Residential,Mon May 19 00:00:00 EDT 2008,116100,38.470093,-121.4683473726 JONKO AVE,NORTH HIGHLANDS,95660,CA,3,2,1207,Residential,Mon May 19 00:00:00 EDT 2008,119250,38.656131,-121.3772657342 GIGI PL,SACRAMENTO,95828,CA,4,4,1995,Multi-Family,Mon May 19 00:00:00 EDT 2008,120000,38.490704,-121.4101762610 PHYLLIS AVE,SACRAMENTO,95820,CA,2,1,804,Residential,Mon May 19 00:00:00 EDT 2008,120000,38.53105,-121.4795744200 COMMERCE WAY Unit 711,SACRAMENTO,95834,CA,2,2,958,Condo,Mon May 19 00:00:00 EDT 2008,120000,38.647523,-121.5232174621 COUNTRY SCENE WAY,SACRAMENTO,95823,CA,3,2,1366,Residential,Mon May 19 00:00:00 EDT 2008,120108,38.470187,-121.4481495380 VILLAGE WOOD DR,SACRAMENTO,95823,CA,2,2,901,Residential,Mon May 19 00:00:00 EDT 2008,121500,38.454949,-121.4405782621 EVERGREEN ST,SACRAMENTO,95815,CA,3,1,696,Residential,Mon May 19 00:00:00 EDT 2008,121725,38.613103,-121.444085201 CARLO CT,GALT,95632,CA,3,2,1080,Residential,Mon May 19 00:00:00 EDT 2008,122000,38.24227,-121.310326743 21ST ST,SACRAMENTO,95822,CA,3,2,1104,Residential,Mon May 19 00:00:00 EDT 2008,123000,38.50372,-121.4906573128 VIA GRANDE,SACRAMENTO,95825,CA,2,1,972,Residential,Mon May 19 00:00:00 EDT 2008,125000,38.598321,-121.391612847 BELGRADE WAY,SACRAMENTO,95833,CA,4,2,1390,Residential,Mon May 19 00:00:00 EDT 2008,125573,38.617173,-121.4825417741 MILLDALE CIR,ELVERTA,95626,CA,4,2,1354,Residential,Mon May 19 00:00:00 EDT 2008,126714,38.705834,-121.439199013 CASALS ST,SACRAMENTO,95826,CA,2,1,795,Condo,Mon May 19 00:00:00 EDT 2008,126960,38.557045,-121.37167227 MAHAN CT Unit 1,ROSEVILLE,95678,CA,2,1,780,Condo,Mon May 19 00:00:00 EDT 2008,127000,38.749723,-121.270087349 FLETCHER FARM DR,SACRAMENTO,95828,CA,4,2,1587,Residential,Mon May 19 00:00:00 EDT 2008,127500,38.49069,-121.3826197226 LARCHMONT DR,NORTH HIGHLANDS,95660,CA,3,2,1209,Residential,Mon May 19 00:00:00 EDT 2008,130000,38.699269,-121.3763344114 35TH AVE,SACRAMENTO,95824,CA,2,1,1139,Residential,Mon May 19 00:00:00 EDT 2008,133105,38.520941,-121.459355617 M ST,RIO LINDA,95673,CA,2,2,1690,Residential,Mon May 19 00:00:00 EDT 2008,136500,38.691104,-121.4518327032 FAIR OAKS BLVD,CARMICHAEL,95608,CA,3,2,1245,Condo,Mon May 19 00:00:00 EDT 2008,139500,38.628563,-121.3282972421 SANTINA WAY,ELVERTA,95626,CA,3,2,1416,Residential,Mon May 19 00:00:00 EDT 2008,140000,38.71865,-121.4077632368 CRAIG AVE,SACRAMENTO,95832,CA,3,2,1300,Residential,Mon May 19 00:00:00 EDT 2008,140800,38.47807,-121.481142123 AMANDA WAY,SACRAMENTO,95822,CA,3,2,1120,Residential,Mon May 19 00:00:00 EDT 2008,145000,38.484896,-121.4869487620 DARLA WAY,SACRAMENTO,95828,CA,4,2,1590,Residential,Mon May 19 00:00:00 EDT 2008,147000,38.478502,-121.4035178344 FIELDPOPPY CIR,SACRAMENTO,95828,CA,3,2,1407,Residential,Mon May 19 00:00:00 EDT 2008,149600,38.479083,-121.4007023624 20TH AVE,SACRAMENTO,95820,CA,5,2,1516,Residential,Mon May 19 00:00:00 EDT 2008,150000,38.534508,-121.46790710001 WOODCREEK OAKS BLVD Unit 1415,ROSEVILLE,95747,CA,2,2,0,Condo,Mon May 19 00:00:00 EDT 2008,150000,38.795529,-121.3288192848 PROVO WAY,SACRAMENTO,95822,CA,3,2,1646,Residential,Mon May 19 00:00:00 EDT 2008,150000,38.489759,-121.4747546045 EHRHARDT AVE,SACRAMENTO,95823,CA,3,2,1676,Residential,Mon May 19 00:00:00 EDT 2008,155000,38.457157,-121.4330651223 LAMBERTON CIR,SACRAMENTO,95838,CA,3,2,1370,Residential,Mon May 19 00:00:00 EDT 2008,155435,38.646677,-121.4375731223 LAMBERTON CIR,SACRAMENTO,95838,CA,3,2,1370,Residential,Mon May 19 00:00:00 EDT 2008,155500,38.646677,-121.4375736000 BIRCHGLADE WAY,CITRUS HEIGHTS,95621,CA,4,2,1351,Residential,Mon May 19 00:00:00 EDT 2008,158000,38.70166,-121.3232497204 THOMAS DR,NORTH HIGHLANDS,95660,CA,3,2,1152,Residential,Mon May 19 00:00:00 EDT 2008,158000,38.697898,-121.3776878363 LANGTREE WAY,SACRAMENTO,95823,CA,3,2,1452,Residential,Mon May 19 00:00:00 EDT 2008,160000,38.45356,-121.4359591675 VERNON ST Unit 8,ROSEVILLE,95678,CA,2,1,990,Residential,Mon May 19 00:00:00 EDT 2008,160000,38.734136,-121.2996396632 IBEX WOODS CT,CITRUS HEIGHTS,95621,CA,2,2,1162,Residential,Mon May 19 00:00:00 EDT 2008,164000,38.720868,-121.309855117 EVCAR WAY,RIO LINDA,95673,CA,3,2,1182,Residential,Mon May 19 00:00:00 EDT 2008,164000,38.687659,-121.46336485 LAGUNA MIRAGE LN,ELK GROVE,95758,CA,2,2,1112,Residential,Mon May 19 00:00:00 EDT 2008,165000,38.42465,-121.430137746 MOOSE CREEK WAY,GALT,95632,CA,3,2,1100,Residential,Mon May 19 00:00:00 EDT 2008,167000,38.283085,-121.3020718306 CURLEW CT,CITRUS HEIGHTS,95621,CA,4,2,1280,Residential,Mon May 19 00:00:00 EDT 2008,167293,38.715781,-121.2985198306 CURLEW CT,CITRUS HEIGHTS,95621,CA,4,2,1280,Residential,Mon May 19 00:00:00 EDT 2008,167293,38.715781,-121.2985195217 ARGO WAY,SACRAMENTO,95820,CA,3,1,1039,Residential,Mon May 19 00:00:00 EDT 2008,168000,38.52774,-121.4336697108 HEATHER TREE DR,SACRAMENTO,95842,CA,3,2,1159,Residential,Mon May 19 00:00:00 EDT 2008,170000,38.695677,-121.360222956 DAVENPORT WAY,SACRAMENTO,95833,CA,4,2,1917,Residential,Mon May 19 00:00:00 EDT 2008,170000,38.620687,-121.48261910062 LINCOLN VILLAGE DR,SACRAMENTO,95827,CA,3,2,1520,Residential,Mon May 19 00:00:00 EDT 2008,170000,38.564,-121.320023332 PALIN AVE,GALT,95632,CA,3,2,1204,Residential,Mon May 19 00:00:00 EDT 2008,174000,38.260467,-121.3026364649 FREEWAY CIR,SACRAMENTO,95841,CA,3,2,1120,Residential,Mon May 19 00:00:00 EDT 2008,178000,38.658734,-121.3571968593 DERLIN WAY,SACRAMENTO,95823,CA,3,2,1436,Residential,Mon May 19 00:00:00 EDT 2008,180000,38.447585,-121.4266279273 PREMIER WAY,SACRAMENTO,95826,CA,3,2,1451,Residential,Mon May 19 00:00:00 EDT 2008,180000,38.55992,-121.3525398032 DUSENBERG CT,SACRAMENTO,95828,CA,4,2,1638,Residential,Mon May 19 00:00:00 EDT 2008,180000,38.466499,-121.3811197110 STELLA LN Unit 15,CARMICHAEL,95608,CA,2,2,1000,Condo,Mon May 19 00:00:00 EDT 2008,182000,38.637396,-121.3000551786 PIEDMONT WAY,ROSEVILLE,95661,CA,3,1,1152,Residential,Mon May 19 00:00:00 EDT 2008,188325,38.72748,-121.2565371347 HIDALGO CIR,ROSEVILLE,95747,CA,3,2,1154,Residential,Mon May 19 00:00:00 EDT 2008,191500,38.747878,-121.311279212 CAPPUCINO WAY,SACRAMENTO,95838,CA,3,2,1353,Residential,Mon May 19 00:00:00 EDT 2008,192000,38.657811,-121.4653275938 WOODBRIAR WAY,CITRUS HEIGHTS,95621,CA,3,2,1329,Residential,Mon May 19 00:00:00 EDT 2008,192700,38.706152,-121.3253993801 WILDROSE WAY,SACRAMENTO,95826,CA,3,1,1356,Residential,Mon May 19 00:00:00 EDT 2008,195000,38.544368,-121.369979508 SAMUEL WAY,SACRAMENTO,95838,CA,3,2,1505,Residential,Mon May 19 00:00:00 EDT 2008,197654,38.645689,-121.4527666128 CARL SANDBURG CIR,SACRAMENTO,95842,CA,3,1,1009,Residential,Mon May 19 00:00:00 EDT 2008,198000,38.681541,-121.3556161 KENNELFORD CIR,SACRAMENTO,95823,CA,3,2,1144,Residential,Mon May 19 00:00:00 EDT 2008,200345,38.46452,-121.427606909 SINGINGWOOD RD,SACRAMENTO,95864,CA,2,1,930,Residential,Mon May 19 00:00:00 EDT 2008,203000,38.581471,-121.388396671 FOXWOOD CT,SACRAMENTO,95841,CA,4,2,1766,Residential,Mon May 19 00:00:00 EDT 2008,207000,38.687943,-121.3288838165 AYN RAND CT,SACRAMENTO,95828,CA,4,3,1940,Residential,Mon May 19 00:00:00 EDT 2008,208000,38.468639,-121.4032659474 VILLAGE TREE DR,ELK GROVE,95758,CA,4,2,1776,Residential,Mon May 19 00:00:00 EDT 2008,210000,38.413947,-121.4082767213 CALVIN DR,CITRUS HEIGHTS,95621,CA,3,1,1258,Residential,Mon May 19 00:00:00 EDT 2008,212000,38.698154,-121.2983758167 DERBY PARK CT,SACRAMENTO,95828,CA,4,2,1872,Residential,Mon May 19 00:00:00 EDT 2008,213675,38.460492,-121.3733796344 LAGUNA MIRAGE LN,ELK GROVE,95758,CA,2,2,1112,Residential,Mon May 19 00:00:00 EDT 2008,213697,38.423963,-121.4288752945 RED HAWK WAY,SACRAMENTO,95833,CA,4,2,1856,Residential,Mon May 19 00:00:00 EDT 2008,215000,38.619675,-121.4969033228 I ST,SACRAMENTO,95816,CA,4,3,1939,Residential,Mon May 19 00:00:00 EDT 2008,215000,38.573844,-121.462839308 ATKINSON ST,ROSEVILLE,95678,CA,3,1,998,Residential,Mon May 19 00:00:00 EDT 2008,215100,38.746794,-121.29971624 HOVEY WAY,ROSEVILLE,95678,CA,3,2,1758,Residential,Mon May 19 00:00:00 EDT 2008,217500,38.756149,-121.306479110 COPPER LEAF WAY,SACRAMENTO,95838,CA,3,2,2142,Residential,Mon May 19 00:00:00 EDT 2008,218000,38.658466,-121.4606617535 ALMA VISTA WAY,SACRAMENTO,95831,CA,2,1,950,Residential,Mon May 19 00:00:00 EDT 2008,220000,38.48403,-121.5076417423 WILSALL CT,ELK GROVE,95758,CA,4,3,1739,Residential,Mon May 19 00:00:00 EDT 2008,221000,38.417026,-121.4168218629 VIA ALTA WAY,ELK GROVE,95624,CA,3,2,1516,Residential,Mon May 19 00:00:00 EDT 2008,222900,38.398245,-121.3806153318 DAVIDSON DR,ANTELOPE,95843,CA,3,1,988,Residential,Mon May 19 00:00:00 EDT 2008,223139,38.705753,-121.388917913 COBDEN CT,GALT,95632,CA,4,2,1555,Residential,Mon May 19 00:00:00 EDT 2008,225500,38.282001,-121.2959024419 79TH ST,SACRAMENTO,95820,CA,3,2,1212,Residential,Mon May 19 00:00:00 EDT 2008,228327,38.534827,-121.4125453012 SPOONWOOD WAY,SACRAMENTO,95833,CA,4,2,1871,Residential,Mon May 19 00:00:00 EDT 2008,230000,38.62478,-121.5234748728 CRYSTAL RIVER WAY,SACRAMENTO,95828,CA,3,2,1302,Residential,Mon May 19 00:00:00 EDT 2008,230000,38.47547,-121.3800554709 AMBER LN Unit 1,SACRAMENTO,95841,CA,2,1,756,Condo,Mon May 19 00:00:00 EDT 2008,230522,38.657789,-121.3549944508 OLD DAIRY DR,ANTELOPE,95843,CA,4,3,2026,Residential,Mon May 19 00:00:00 EDT 2008,231200,38.72286,-121.358939312 RIVER ISLE WAY,SACRAMENTO,95831,CA,3,2,1375,Residential,Mon May 19 00:00:00 EDT 2008,232000,38.49026,-121.550527301 OLIVADI WAY,SACRAMENTO,95834,CA,2,2,1250,Condo,Mon May 19 00:00:00 EDT 2008,232500,38.644406,-121.5490495636 25TH ST,SACRAMENTO,95822,CA,3,1,1058,Residential,Mon May 19 00:00:00 EDT 2008,233641,38.523828,-121.4811398721 SPRUCE RIDGE WAY,ANTELOPE,95843,CA,3,2,1187,Residential,Mon May 19 00:00:00 EDT 2008,234000,38.727657,-121.3910287461 WINDBRIDGE DR,SACRAMENTO,95831,CA,2,2,1324,Residential,Mon May 19 00:00:00 EDT 2008,234500,38.48797,-121.5302298101 LEMON COVE CT,SACRAMENTO,95828,CA,4,3,1936,Residential,Mon May 19 00:00:00 EDT 2008,235000,38.462981,-121.40828810949 SCOTSMAN WAY,RANCHO CORDOVA,95670,CA,5,4,2382,Multi-Family,Mon May 19 00:00:00 EDT 2008,236000,38.603686,-121.277844617 WILLOW CREEK DR,FOLSOM,95630,CA,3,2,1427,Residential,Mon May 19 00:00:00 EDT 2008,236073,38.679626,-121.1426093301 PARK DR Unit 1914,SACRAMENTO,95835,CA,3,2,1678,Condo,Mon May 19 00:00:00 EDT 2008,238000,38.665296,-121.531993709 CIMMARON CT,GALT,95632,CA,4,2,1798,Residential,Mon May 19 00:00:00 EDT 2008,238861,38.277177,-121.3037473305 RIO ROCA CT,ANTELOPE,95843,CA,4,3,2652,Residential,Mon May 19 00:00:00 EDT 2008,239700,38.725079,-121.3876989080 BEDROCK CT,SACRAMENTO,95829,CA,4,2,1816,Residential,Mon May 19 00:00:00 EDT 2008,240000,38.456939,-121.362965100 TOURMALINE CIR,SACRAMENTO,95834,CA,5,3,3076,Residential,Mon May 19 00:00:00 EDT 2008,240000,38.63437,-121.5107796411 RED BIRCH WAY,ELK GROVE,95758,CA,4,2,1844,Residential,Mon May 19 00:00:00 EDT 2008,241000,38.43461,-121.4293164867 LAGUNA DR,SACRAMENTO,95823,CA,3,2,1306,Residential,Mon May 19 00:00:00 EDT 2008,245000,38.46179,-121.4453713662 RIVER DR,SACRAMENTO,95833,CA,4,3,2447,Residential,Mon May 19 00:00:00 EDT 2008,246000,38.604969,-121.542556943 WOLFGRAM WAY,SACRAMENTO,95828,CA,4,2,1176,Residential,Mon May 19 00:00:00 EDT 2008,247234,38.489215,-121.41954677 RINETTI WAY,RIO LINDA,95673,CA,4,2,1182,Residential,Mon May 19 00:00:00 EDT 2008,247480,38.687021,-121.4631511316 I ST,RIO LINDA,95673,CA,3,1,1160,Residential,Mon May 19 00:00:00 EDT 2008,249862,38.683674,-121.4352042130 CATHERWOOD WAY,SACRAMENTO,95835,CA,3,2,1424,Residential,Mon May 19 00:00:00 EDT 2008,251000,38.675506,-121.5109878304 JUGLANS DR,ORANGEVALE,95662,CA,4,2,1574,Residential,Mon May 19 00:00:00 EDT 2008,252155,38.691829,-121.2490335308 MARBURY WAY,ANTELOPE,95843,CA,3,2,1830,Residential,Mon May 19 00:00:00 EDT 2008,254172,38.710221,-121.3417079182 LAKEMONT DR,ELK GROVE,95624,CA,4,2,1724,Residential,Mon May 19 00:00:00 EDT 2008,258000,38.451353,-121.3587762231 COUNTRY VILLA CT,AUBURN,95603,CA,2,2,1255,Condo,Mon May 19 00:00:00 EDT 2008,260000,38.931671,-121.0978628491 CRYSTAL WALK CIR,ELK GROVE,95758,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,261000,38.416916,-121.407554361 MAHONIA CIR,SACRAMENTO,95835,CA,4,3,2175,Residential,Mon May 19 00:00:00 EDT 2008,261000,38.676172,-121.5097613427 LA CADENA WAY,SACRAMENTO,95835,CA,4,2,1904,Residential,Mon May 19 00:00:00 EDT 2008,261000,38.681194,-121.537351955 BIG SUR CT,EL DORADO HILLS,95762,CA,4,2,1808,Residential,Mon May 19 00:00:00 EDT 2008,262500,38.664347,-121.07652911826 DIONYSUS WAY,RANCHO CORDOVA,95742,CA,4,2,2711,Residential,Mon May 19 00:00:00 EDT 2008,266000,38.551046,-121.2394115847 DEL CAMPO LN,CARMICHAEL,95608,CA,3,1,1713,Residential,Mon May 19 00:00:00 EDT 2008,266000,38.671995,-121.3243395635 FOXVIEW WAY,ELK GROVE,95757,CA,3,2,1457,Residential,Mon May 19 00:00:00 EDT 2008,270000,38.395256,-121.43824910372 VIA CINTA CT,ELK GROVE,95757,CA,4,3,2724,Residential,Mon May 19 00:00:00 EDT 2008,274425,38.380089,-121.4281866286 LONETREE BLVD,ROCKLIN,95765,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,274500,38.805036,-121.2936087744 SOUTHBREEZE DR,SACRAMENTO,95828,CA,3,2,1468,Residential,Mon May 19 00:00:00 EDT 2008,275336,38.476932,-121.3783492242 ABLE WAY,SACRAMENTO,95835,CA,4,3,2550,Residential,Mon May 19 00:00:00 EDT 2008,277980,38.666074,-121.5097431042 STARBROOK DR,GALT,95632,CA,4,2,1928,Residential,Mon May 19 00:00:00 EDT 2008,280000,38.285611,-121.2930631219 G ST,SACRAMENTO,95814,CA,3,3,1922,Residential,Mon May 19 00:00:00 EDT 2008,284686,38.582818,-121.4890966220 OPUS CT,CITRUS HEIGHTS,95621,CA,3,2,1343,Residential,Mon May 19 00:00:00 EDT 2008,284893,38.715853,-121.3170955419 HAVENHURST CIR,ROCKLIN,95677,CA,3,2,1510,Residential,Mon May 19 00:00:00 EDT 2008,285000,38.786746,-121.209957220 OLD AIRPORT RD,AUBURN,95603,CA,2,2,960,Multi-Family,Mon May 19 00:00:00 EDT 2008,285000,38.939802,-121.0545754622 MEYER WAY,CARMICHAEL,95608,CA,4,2,1559,Residential,Mon May 19 00:00:00 EDT 2008,285000,38.64913,-121.3106674885 SUMMIT VIEW DR,EL DORADO,95623,CA,3,2,1624,Residential,Mon May 19 00:00:00 EDT 2008,289000,38.673285,-120.87917626 JEANROSS CT,SACRAMENTO,95832,CA,5,3,2992,Residential,Mon May 19 00:00:00 EDT 2008,295000,38.473162,-121.4910854800 MAPLEPLAIN AVE,ELK GROVE,95758,CA,4,2,2109,Residential,Mon May 19 00:00:00 EDT 2008,296000,38.432848,-121.44923710629 BASIE WAY,RANCHO CORDOVA,95670,CA,4,2,1524,Residential,Mon May 19 00:00:00 EDT 2008,296056,38.579,-121.2926278612 WILLOW GROVE WAY,SACRAMENTO,95828,CA,3,2,1248,Residential,Mon May 19 00:00:00 EDT 2008,297359,38.464994,-121.38696262 DE FER CIR,SACRAMENTO,95823,CA,4,2,1876,Residential,Mon May 19 00:00:00 EDT 2008,299940,38.49254,-121.4633162513 OLD KENMARE RD,LINCOLN,95648,CA,5,3,0,Residential,Mon May 19 00:00:00 EDT 2008,304000,38.847396,-121.2595863253 ABOTO WAY,RANCHO CORDOVA,95670,CA,4,3,1851,Residential,Mon May 19 00:00:00 EDT 2008,305000,38.57727,-121.2855913072 VILLAGE PLAZA DR,ROSEVILLE,95747,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,307000,38.773094,-121.365905251 CHANGO CIR,SACRAMENTO,95835,CA,4,2,2218,Residential,Mon May 19 00:00:00 EDT 2008,311328,38.68237,-121.5391478205 WEYBURN CT,SACRAMENTO,95828,CA,3,2,1394,Residential,Mon May 19 00:00:00 EDT 2008,313138,38.47316,-121.4038938788 LA MARGARITA WAY,SACRAMENTO,95828,CA,3,2,1410,Residential,Mon May 19 00:00:00 EDT 2008,316630,38.468185,-121.3756945912 DEEPDALE WAY,ELK GROVE,95758,CA,5,3,3468,Residential,Mon May 19 00:00:00 EDT 2008,320000,38.439565,-121.4366064712 PISMO BEACH DR,ANTELOPE,95843,CA,5,3,2346,Residential,Mon May 19 00:00:00 EDT 2008,320000,38.707705,-121.3541534741 PACIFIC PARK DR,ANTELOPE,95843,CA,5,3,2347,Residential,Mon May 19 00:00:00 EDT 2008,325000,38.709299,-121.353056310 GROTH CIR,SACRAMENTO,95834,CA,4,2,1659,Residential,Mon May 19 00:00:00 EDT 2008,328578,38.638764,-121.5318276121 WILD FOX CT,ELK GROVE,95757,CA,3,3,2442,Residential,Mon May 19 00:00:00 EDT 2008,331000,38.406758,-121.43166912241 CANYONLANDS DR,RANCHO CORDOVA,95742,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,331500,38.557293,-121.21761129 COOL FOUNTAIN CT,SACRAMENTO,95833,CA,4,2,2155,Residential,Mon May 19 00:00:00 EDT 2008,340000,38.606906,-121.54132907 RIO ROBLES AVE,SACRAMENTO,95838,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,344755,38.664765,-121.4450068909 BILLFISH WAY,SACRAMENTO,95828,CA,3,2,1810,Residential,Mon May 19 00:00:00 EDT 2008,345746,38.475433,-121.3725846232 GUS WAY,ELK GROVE,95757,CA,4,2,2789,Residential,Mon May 19 00:00:00 EDT 2008,351000,38.388129,-121.43117200 OAKWILDE ST,GALT,95632,CA,4,2,1606,Residential,Mon May 19 00:00:00 EDT 2008,353767,38.2535,-121.318121033 PARK STREAM DR,GALT,95632,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,355000,38.287785,-121.289903200 ALLAIRE CIR,SACRAMENTO,95835,CA,4,2,2166,Residential,Mon May 19 00:00:00 EDT 2008,356035,38.68318,-121.534841322 SUTTER WALK,SACRAMENTO,95816,CA,0,0,0,Condo,Mon May 19 00:00:00 EDT 2008,360000,38.53805,-121.50475479 NICKMAN WAY,SACRAMENTO,95835,CA,4,2,1871,Residential,Mon May 19 00:00:00 EDT 2008,360552,38.672966,-121.5027482103 BURBERRY WAY,SACRAMENTO,95835,CA,3,2,1800,Residential,Mon May 19 00:00:00 EDT 2008,362305,38.67342,-121.5085422450 SAN JOSE WAY,SACRAMENTO,95817,CA,3,1,1683,Residential,Mon May 19 00:00:00 EDT 2008,365000,38.553596,-121.4594837641 ROSEHALL DR,ROSEVILLE,95678,CA,3,2,0,Residential,Mon May 19 00:00:00 EDT 2008,367554,38.791617,-121.2861471336 LAYSAN TEAL DR,ROSEVILLE,95747,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,368500,38.796121,-121.3199632802 BLACK OAK DR,ROCKLIN,95765,CA,2,2,1596,Residential,Mon May 19 00:00:00 EDT 2008,370000,38.837006,-121.2320242113 FALL TRAIL CT,PLACERVILLE,95667,CA,4,2,0,Residential,Mon May 19 00:00:00 EDT 2008,371086,38.733155,-120.74803910112 LAMBEAU CT,ELK GROVE,95757,CA,3,2,1179,Residential,Mon May 19 00:00:00 EDT 2008,378000,38.390328,-121.4480226313 CASTRO VERDE WAY,ELK GROVE,95757,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,383000,38.381102,-121.429013622 CURTIS DR,SACRAMENTO,95818,CA,3,1,1639,Residential,Mon May 19 00:00:00 EDT 2008,388000,38.541735,-121.48009811817 OPAL RIDGE WAY,RANCHO CORDOVA,95742,CA,5,3,3281,Residential,Mon May 19 00:00:00 EDT 2008,395100,38.551083,-121.237476170 LAGOMARSINO WAY,SACRAMENTO,95819,CA,3,2,1697,Residential,Mon May 19 00:00:00 EDT 2008,400000,38.574894,-121.4358062743 DEAKIN PL,EL DORADO HILLS,95762,CA,3,2,0,Residential,Mon May 19 00:00:00 EDT 2008,400000,38.69288,-121.0735513361 ALDER CANYON WAY,ANTELOPE,95843,CA,4,3,2085,Residential,Mon May 19 00:00:00 EDT 2008,408431,38.727649,-121.3856562148 RANCH VIEW DR,ROCKLIN,95765,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,413000,38.837455,-121.289337398 LINDLEY DR,SACRAMENTO,95815,CA,4,2,1744,Multi-Family,Mon May 19 00:00:00 EDT 2008,416767,38.622359,-121.4575823013 BRIDLEWOOD DR,EL DORADO HILLS,95762,CA,4,3,0,Residential,Mon May 19 00:00:00 EDT 2008,420000,38.675519,-121.015862169 BAURER CIR,FOLSOM,95630,CA,4,3,1939,Residential,Mon May 19 00:00:00 EDT 2008,423000,38.66695,-121.1207292809 LOON CT,CAMERON PARK,95682,CA,4,2,0,Residential,Mon May 19 00:00:00 EDT 2008,423000,38.687072,-121.0047291315 KONDOS AVE,SACRAMENTO,95814,CA,2,3,1788,Residential,Mon May 19 00:00:00 EDT 2008,427500,38.571943,-121.4921064966 CHARTER RD,ROCKLIN,95765,CA,3,2,1691,Residential,Mon May 19 00:00:00 EDT 2008,430922,38.82553,-121.2546989516 LAGUNA LAKE WAY,ELK GROVE,95758,CA,4,2,2002,Residential,Mon May 19 00:00:00 EDT 2008,445000,38.411258,-121.4313485201 BLOSSOM RANCH DR,ELK GROVE,95757,CA,4,4,4303,Residential,Mon May 19 00:00:00 EDT 2008,450000,38.399436,-121.4440413027 PALMATE WAY,SACRAMENTO,95834,CA,5,3,4246,Residential,Mon May 19 00:00:00 EDT 2008,452000,38.628955,-121.529269500 WINCHESTER CT,ROSEVILLE,95661,CA,3,2,2274,Residential,Mon May 19 00:00:00 EDT 2008,470000,38.73988,-121.2489295746 GELSTON WAY,EL DORADO HILLS,95762,CA,4,3,0,Residential,Mon May 19 00:00:00 EDT 2008,471000,38.677015,-121.0340836935 ELM TREE LN,ORANGEVALE,95662,CA,4,4,3056,Residential,Mon May 19 00:00:00 EDT 2008,475000,38.693041,-121.232949605 GOLF COURSE LN,ELK GROVE,95758,CA,3,3,2503,Residential,Mon May 19 00:00:00 EDT 2008,484500,38.409689,-121.446059719 BAYWOOD CT,EL DORADO HILLS,95762,CA,5,3,0,Residential,Mon May 19 00:00:00 EDT 2008,487500,38.647598,-121.0778015954 TANUS CIR,ROCKLIN,95677,CA,3,3,0,Residential,Mon May 19 00:00:00 EDT 2008,488750,38.777585,-121.2036100 CHELSEA CT,FOLSOM,95630,CA,3,2,1905,Residential,Mon May 19 00:00:00 EDT 2008,500000,38.69435,-121.1772591500 ORANGE HILL LN,PENRYN,95663,CA,3,2,1320,Residential,Mon May 19 00:00:00 EDT 2008,506688,38.862708,-121.162092408 KIRKWOOD CT,LINCOLN,95648,CA,2,2,0,Residential,Mon May 19 00:00:00 EDT 2008,512000,38.861615,-121.268691732 TUSCAN GROVE CIR,ROSEVILLE,95747,CA,5,3,0,Residential,Mon May 19 00:00:00 EDT 2008,520000,38.796683,-121.3425552049 EMPIRE MINE CIR,GOLD RIVER,95670,CA,4,2,3037,Residential,Mon May 19 00:00:00 EDT 2008,528000,38.629299,-121.2490219360 MAGOS RD,WILTON,95693,CA,5,2,3741,Residential,Mon May 19 00:00:00 EDT 2008,579093,38.416809,-121.240628104 CATLIN CT,FOLSOM,95630,CA,4,3,2660,Residential,Mon May 19 00:00:00 EDT 2008,636000,38.684459,-121.1459354734 GIBBONS DR,CARMICHAEL,95608,CA,4,3,3357,Residential,Mon May 19 00:00:00 EDT 2008,668365,38.63558,-121.3536394629 DORCHESTER LN,GRANITE BAY,95746,CA,5,3,2896,Residential,Mon May 19 00:00:00 EDT 2008,676200,38.723545,-121.2160252400 COUNTRYSIDE DR,PLACERVILLE,95667,CA,3,2,2025,Residential,Mon May 19 00:00:00 EDT 2008,677048,38.737452,-120.91096312901 FURLONG DR,WILTON,95693,CA,5,3,3788,Residential,Mon May 19 00:00:00 EDT 2008,691659,38.413535,-121.1882116222 CALLE MONTALVO CIR,GRANITE BAY,95746,CA,5,3,3670,Residential,Mon May 19 00:00:00 EDT 2008,760000,38.779435,-121.14667620 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.885327,-121.28941224 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.885132,-121.28940528 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.884936,-121.28939732 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.884741,-121.2893936 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.884599,-121.28940640 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.884535,-121.28961944 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.88459,-121.28983548 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.884667,-121.28989652 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.88478,-121.28991168 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.885236,-121.28992872 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.88535,-121.28992676 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.885464,-121.28992280 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.885578,-121.28991984 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.885692,-121.28991588 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.885806,-121.28991192 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.88592,-121.28990896 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.886024,-121.289859100 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.886091,-121.289744434 1ST ST,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.88653,-121.2894063 E ST,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.884692,-121.29028811 E ST,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.884879,-121.29025719 E ST,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.885017,-121.29026227 E ST,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.885173,-121.2902735 E ST,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.885328,-121.29027543 E ST,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.885483,-121.29027751 E ST,LINCOLN,95648,CA,4,2,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.885638,-121.29027959 E ST,LINCOLN,95648,CA,3,2,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.885794,-121.29028175 E ST,LINCOLN,95648,CA,3,2,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.886104,-121.29028563 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.885093,-121.289932398 1ST ST,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.88653,-121.288952386 1ST ST,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.886528,-121.288869374 1ST ST,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.886525,-121.288787116 CRYSTALWOOD WAY,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.886282,-121.289586108 CRYSTALWOOD WAY,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.886282,-121.289646100 CRYSTALWOOD WAY,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.886282,-121.28970655 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.884865,-121.28992251 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.884752,-121.28990747 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.884638,-121.28989343 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.884568,-121.28978439 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.884546,-121.28956235 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.884645,-121.28939731 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.88479,-121.28939227 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.884985,-121.28939923 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.885181,-121.28940619 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.885376,-121.28941415 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.885571,-121.2894217 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.885962,-121.2894367 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.885962,-121.2894363 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.886093,-121.2895848208 WOODYARD WAY,CITRUS HEIGHTS,95621,CA,3,2,1166,Residential,Fri May 16 00:00:00 EDT 2008,30000,38.715322,-121.314787113 RINETTI WAY,RIO LINDA,95673,CA,0,0,0,Residential,Fri May 16 00:00:00 EDT 2008,30000,38.687172,-121.46393315 LOORZ CT,SACRAMENTO,95823,CA,2,1,838,Residential,Fri May 16 00:00:00 EDT 2008,55422,38.471646,-121.4351585805 DOTMAR WAY,NORTH HIGHLANDS,95660,CA,2,1,904,Residential,Fri May 16 00:00:00 EDT 2008,63000,38.672642,-121.3803432332 CAMBRIDGE ST,SACRAMENTO,95815,CA,2,1,1032,Residential,Fri May 16 00:00:00 EDT 2008,65000,38.608085,-121.4496513812 BELDEN ST,SACRAMENTO,95838,CA,2,1,904,Residential,Fri May 16 00:00:00 EDT 2008,65000,38.636833,-121.441643348 40TH ST,SACRAMENTO,95817,CA,2,1,1080,Residential,Fri May 16 00:00:00 EDT 2008,65000,38.544162,-121.460652127 QUASAR CIR,SACRAMENTO,95822,CA,2,2,990,Residential,Fri May 16 00:00:00 EDT 2008,66500,38.493504,-121.4753043812 CYPRESS ST,SACRAMENTO,95838,CA,2,1,900,Residential,Fri May 16 00:00:00 EDT 2008,71000,38.636877,-121.4449485821 64TH ST,SACRAMENTO,95824,CA,2,1,861,Residential,Fri May 16 00:00:00 EDT 2008,75000,38.521202,-121.4281468248 CENTER PKWY,SACRAMENTO,95823,CA,2,1,906,Condo,Fri May 16 00:00:00 EDT 2008,77000,38.459002,-121.4287941171 SONOMA AVE,SACRAMENTO,95815,CA,2,1,1011,Residential,Fri May 16 00:00:00 EDT 2008,85000,38.6238,-121.4398724250 ARDWELL WAY,SACRAMENTO,95823,CA,3,2,1089,Residential,Fri May 16 00:00:00 EDT 2008,95625,38.466938,-121.4556313104 CLAY ST,SACRAMENTO,95815,CA,2,1,832,Residential,Fri May 16 00:00:00 EDT 2008,96140,38.62391,-121.4392086063 LAND PARK DR,SACRAMENTO,95822,CA,2,1,800,Condo,Fri May 16 00:00:00 EDT 2008,104250,38.517029,-121.5138094738 OAKHOLLOW DR,SACRAMENTO,95842,CA,4,2,1292,Residential,Fri May 16 00:00:00 EDT 2008,105000,38.679598,-121.3560351401 STERLING ST,SACRAMENTO,95822,CA,2,1,810,Residential,Fri May 16 00:00:00 EDT 2008,108000,38.520319,-121.5047273715 DIDCOT CIR,SACRAMENTO,95838,CA,4,2,1064,Residential,Fri May 16 00:00:00 EDT 2008,109000,38.635232,-121.4600982426 RASHAWN DR,RANCHO CORDOVA,95670,CA,2,1,911,Residential,Fri May 16 00:00:00 EDT 2008,115000,38.610852,-121.2732784800 WESTLAKE PKWY Unit 410,SACRAMENTO,95835,CA,1,1,846,Condo,Fri May 16 00:00:00 EDT 2008,115000,38.658812,-121.5423453409 VIRGO ST,SACRAMENTO,95827,CA,3,2,1320,Residential,Fri May 16 00:00:00 EDT 2008,115500,38.563402,-121.3277471110 PINEDALE AVE,SACRAMENTO,95838,CA,3,2,1410,Residential,Fri May 16 00:00:00 EDT 2008,115620,38.660173,-121.4402162361 LA LOMA DR,RANCHO CORDOVA,95670,CA,3,2,1115,Residential,Fri May 16 00:00:00 EDT 2008,116000,38.59368,-121.3160541455 64TH AVE,SACRAMENTO,95822,CA,3,2,1169,Residential,Fri May 16 00:00:00 EDT 2008,122000,38.492177,-121.5033927328 SPRINGMAN ST,SACRAMENTO,95822,CA,3,2,1164,Residential,Fri May 16 00:00:00 EDT 2008,122500,38.491991,-121.477636119 SAINT MARIE CIR,SACRAMENTO,95823,CA,4,2,1341,Residential,Fri May 16 00:00:00 EDT 2008,123000,38.481454,-121.44664412 COSTA BRASE CT,SACRAMENTO,95838,CA,3,2,1219,Residential,Fri May 16 00:00:00 EDT 2008,124000,38.655554,-121.4642756813 SCOTER WAY,SACRAMENTO,95842,CA,4,2,1127,Residential,Fri May 16 00:00:00 EDT 2008,124000,38.69043,-121.3610356548 GRAYLOCK LN,NORTH HIGHLANDS,95660,CA,3,2,1272,Residential,Fri May 16 00:00:00 EDT 2008,124413,38.686061,-121.3699491630 GLIDDEN AVE,SACRAMENTO,95822,CA,4,2,1253,Residential,Fri May 16 00:00:00 EDT 2008,125000,38.482717,-121.4996837825 DALEWOODS WAY,SACRAMENTO,95828,CA,3,2,1120,Residential,Fri May 16 00:00:00 EDT 2008,130000,38.477297,-121.4115134073 TRESLER AVE,NORTH HIGHLANDS,95660,CA,2,2,1118,Residential,Fri May 16 00:00:00 EDT 2008,131750,38.659016,-121.3704574288 DYMIC WAY,SACRAMENTO,95838,CA,4,3,1890,Residential,Fri May 16 00:00:00 EDT 2008,137721,38.646541,-121.4411391158 SAN IGNACIO WAY,SACRAMENTO,95833,CA,3,2,1260,Residential,Fri May 16 00:00:00 EDT 2008,137760,38.623045,-121.4862794904 J PKWY,SACRAMENTO,95823,CA,3,2,1400,Residential,Fri May 16 00:00:00 EDT 2008,138000,38.487297,-121.442952931 HOWE AVE,SACRAMENTO,95821,CA,3,1,1264,Residential,Fri May 16 00:00:00 EDT 2008,140000,38.619012,-121.4153295531 JANSEN DR,SACRAMENTO,95824,CA,3,1,1060,Residential,Fri May 16 00:00:00 EDT 2008,145000,38.522015,-121.4387137836 ORCHARD WOODS CIR,SACRAMENTO,95828,CA,2,2,1132,Residential,Fri May 16 00:00:00 EDT 2008,145000,38.47955,-121.4108674055 DEERBROOK DR,SACRAMENTO,95823,CA,3,2,1466,Residential,Fri May 16 00:00:00 EDT 2008,150000,38.472117,-121.4595899937 BURLINE ST,SACRAMENTO,95827,CA,3,2,1092,Residential,Fri May 16 00:00:00 EDT 2008,150000,38.559641,-121.323166948 MIRADOR WAY,SACRAMENTO,95828,CA,4,2,1628,Residential,Fri May 16 00:00:00 EDT 2008,151000,38.493484,-121.420354909 RUGER CT,SACRAMENTO,95842,CA,3,2,960,Residential,Fri May 16 00:00:00 EDT 2008,155000,38.68747,-121.3492347204 KERSTEN ST,CITRUS HEIGHTS,95621,CA,3,2,1075,Residential,Fri May 16 00:00:00 EDT 2008,155800,38.695863,-121.3008143150 ROSEMONT DR,SACRAMENTO,95826,CA,3,2,1428,Residential,Fri May 16 00:00:00 EDT 2008,156142,38.554927,-121.355218200 STEINBECK WAY,SACRAMENTO,95828,CA,4,2,1358,Residential,Fri May 16 00:00:00 EDT 2008,158000,38.474854,-121.4047268198 STEVENSON AVE,SACRAMENTO,95828,CA,6,4,2475,Multi-Family,Fri May 16 00:00:00 EDT 2008,159900,38.465271,-121.404266824 OLIVE TREE WAY,CITRUS HEIGHTS,95610,CA,3,2,1410,Residential,Fri May 16 00:00:00 EDT 2008,160000,38.689239,-121.2677373536 SUN MAIDEN WAY,ANTELOPE,95843,CA,3,2,1711,Residential,Fri May 16 00:00:00 EDT 2008,161500,38.70968,-121.3823284517 OLYMPIAD WAY,SACRAMENTO,95826,CA,4,2,1483,Residential,Fri May 16 00:00:00 EDT 2008,161600,38.536751,-121.359154925 COBDEN CT,GALT,95632,CA,3,2,1140,Residential,Fri May 16 00:00:00 EDT 2008,162000,38.282047,-121.2958128225 SCOTTSDALE DR,SACRAMENTO,95828,CA,4,2,1549,Residential,Fri May 16 00:00:00 EDT 2008,165000,38.487864,-121.4024768758 LEMAS RD,SACRAMENTO,95828,CA,3,2,1410,Residential,Fri May 16 00:00:00 EDT 2008,165000,38.467487,-121.3770556121 ALPINESPRING WAY,ELK GROVE,95758,CA,3,2,1240,Residential,Fri May 16 00:00:00 EDT 2008,167293,38.434075,-121.4326235937 YORK GLEN WAY,SACRAMENTO,95842,CA,5,2,1712,Residential,Fri May 16 00:00:00 EDT 2008,168000,38.677003,-121.3544546417 SUNNYFIELD WAY,SACRAMENTO,95823,CA,4,2,1580,Residential,Fri May 16 00:00:00 EDT 2008,168000,38.449153,-121.4282724008 GREY LIVERY WAY,ANTELOPE,95843,CA,3,2,1669,Residential,Fri May 16 00:00:00 EDT 2008,168750,38.71846,-121.3708628920 ROSETTA CIR,SACRAMENTO,95826,CA,3,1,1029,Residential,Fri May 16 00:00:00 EDT 2008,168750,38.544374,-121.3708748300 LICHEN DR,CITRUS HEIGHTS,95621,CA,3,1,1103,Residential,Fri May 16 00:00:00 EDT 2008,170000,38.71641,-121.3062398884 AMBERJACK WAY,SACRAMENTO,95828,CA,3,2,2161,Residential,Fri May 16 00:00:00 EDT 2008,170250,38.479343,-121.3725534480 VALLEY HI DR,SACRAMENTO,95823,CA,3,2,1650,Residential,Fri May 16 00:00:00 EDT 2008,173000,38.466781,-121.4509552250 FOREBAY RD,POLLOCK PINES,95726,CA,3,1,1320,Residential,Fri May 16 00:00:00 EDT 2008,175000,38.77491,-120.5975993529 FABERGE WAY,SACRAMENTO,95826,CA,3,2,1200,Residential,Fri May 16 00:00:00 EDT 2008,176095,38.553275,-121.3462181792 DAWNELLE WAY,SACRAMENTO,95835,CA,3,2,1170,Residential,Fri May 16 00:00:00 EDT 2008,176250,38.68271,-121.5016977800 TABARE CT,CITRUS HEIGHTS,95621,CA,3,2,1199,Residential,Fri May 16 00:00:00 EDT 2008,178000,38.70799,-121.3029798531 HERMITAGE WAY,SACRAMENTO,95823,CA,4,2,1695,Residential,Fri May 16 00:00:00 EDT 2008,179000,38.448452,-121.4285362421 BERRYWOOD DR,RANCHO CORDOVA,95670,CA,3,2,1157,Residential,Fri May 16 00:00:00 EDT 2008,180000,38.60868,-121.278491005 MORENO WAY,SACRAMENTO,95838,CA,3,2,1410,Residential,Fri May 16 00:00:00 EDT 2008,180000,38.646206,-121.4427671675 VERNON ST Unit 24,ROSEVILLE,95678,CA,3,2,1174,Residential,Fri May 16 00:00:00 EDT 2008,180000,38.734136,-121.29963924 WINDCHIME CT,SACRAMENTO,95823,CA,3,2,1593,Residential,Fri May 16 00:00:00 EDT 2008,181000,38.44617,-121.427824540 HARLING CT,RIO LINDA,95673,CA,3,2,1093,Residential,Fri May 16 00:00:00 EDT 2008,182000,38.68279,-121.4535091207 CRESCENDO DR,ROSEVILLE,95678,CA,3,2,1770,Residential,Fri May 16 00:00:00 EDT 2008,182587,38.72446,-121.2928297577 EDDYLEE WAY,SACRAMENTO,95822,CA,4,2,1436,Residential,Fri May 16 00:00:00 EDT 2008,185074,38.48291,-121.4915098369 FOPPIANO WAY,SACRAMENTO,95829,CA,3,2,1124,Residential,Fri May 16 00:00:00 EDT 2008,185833,38.453839,-121.3579198817 SAWTELLE WAY,SACRAMENTO,95826,CA,4,2,1139,Residential,Fri May 16 00:00:00 EDT 2008,186785,38.565322,-121.3742511910 BONAVISTA WAY,SACRAMENTO,95832,CA,3,2,1638,Residential,Fri May 16 00:00:00 EDT 2008,187000,38.476048,-121.4949618 TIDE CT,SACRAMENTO,95833,CA,3,2,1328,Residential,Fri May 16 00:00:00 EDT 2008,188335,38.609864,-121.4923048952 ROCKY CREEK CT,ELK GROVE,95758,CA,3,2,1273,Residential,Fri May 16 00:00:00 EDT 2008,190000,38.431239,-121.44001435 EXCHANGE ST,SACRAMENTO,95838,CA,3,1,1082,Residential,Fri May 16 00:00:00 EDT 2008,190000,38.659434,-121.45523610105 MONTE VALLO CT,SACRAMENTO,95827,CA,4,2,1578,Residential,Fri May 16 00:00:00 EDT 2008,190000,38.573917,-121.3169163930 ANNABELLE AVE,ROSEVILLE,95661,CA,2,1,796,Residential,Fri May 16 00:00:00 EDT 2008,190000,38.727609,-121.2264944854 TANGERINE AVE,SACRAMENTO,95823,CA,3,2,1386,Residential,Fri May 16 00:00:00 EDT 2008,191250,38.478239,-121.4463262909 SHAWN WAY,RANCHO CORDOVA,95670,CA,3,2,1452,Residential,Fri May 16 00:00:00 EDT 2008,193000,38.589925,-121.2990594290 BLACKFORD WAY,SACRAMENTO,95823,CA,3,2,1513,Residential,Fri May 16 00:00:00 EDT 2008,193500,38.470494,-121.4541625890 TT TRAK,FORESTHILL,95631,CA,0,0,0,Residential,Fri May 16 00:00:00 EDT 2008,194818,39.020808,-120.8215187015 WOODSIDE DR,SACRAMENTO,95842,CA,4,2,1578,Residential,Fri May 16 00:00:00 EDT 2008,195000,38.693071,-121.3323656019 CHESHIRE WAY,CITRUS HEIGHTS,95610,CA,4,3,1736,Residential,Fri May 16 00:00:00 EDT 2008,195000,38.676437,-121.2791653330 VILLAGE CT,CAMERON PARK,95682,CA,2,2,0,Residential,Fri May 16 00:00:00 EDT 2008,195000,38.690504,-120.9962452561 VERNA WAY,SACRAMENTO,95821,CA,3,1,1473,Residential,Fri May 16 00:00:00 EDT 2008,195000,38.611055,-121.3699643522 22ND AVE,SACRAMENTO,95820,CA,3,1,1150,Residential,Fri May 16 00:00:00 EDT 2008,198000,38.532725,-121.4690782880 CANDIDO DR,SACRAMENTO,95833,CA,3,2,1127,Residential,Fri May 16 00:00:00 EDT 2008,199900,38.618019,-121.5102156908 PIN OAK CT,FAIR OAKS,95628,CA,3,1,1144,Residential,Fri May 16 00:00:00 EDT 2008,200000,38.66424,-121.3036755733 ANGELINA AVE,CARMICHAEL,95608,CA,3,1,972,Residential,Fri May 16 00:00:00 EDT 2008,201000,38.622634,-121.3308467849 BONNY DOWNS WAY,ELK GROVE,95758,CA,4,2,2306,Residential,Fri May 16 00:00:00 EDT 2008,204918,38.42139,-121.4113398716 LONGSPUR WAY,ANTELOPE,95843,CA,3,2,1479,Residential,Fri May 16 00:00:00 EDT 2008,205000,38.724083,-121.35846320 EL DORADO ST,EL DORADO,95623,CA,2,1,1040,Residential,Fri May 16 00:00:00 EDT 2008,205000,38.678758,-120.8441182328 DOROTHY JUNE WAY,SACRAMENTO,95838,CA,3,2,1430,Residential,Fri May 16 00:00:00 EDT 2008,205878,38.641727,-121.4127031986 DANVERS WAY,SACRAMENTO,95832,CA,4,2,1800,Residential,Fri May 16 00:00:00 EDT 2008,207000,38.47723,-121.4925687901 GAZELLE TRAIL WAY,ANTELOPE,95843,CA,4,2,1953,Residential,Fri May 16 00:00:00 EDT 2008,207744,38.71174,-121.3426756080 BRIDGECROSS DR,SACRAMENTO,95835,CA,3,2,1120,Residential,Fri May 16 00:00:00 EDT 2008,209000,38.681952,-121.50500920 GROTH CIR,SACRAMENTO,95834,CA,3,2,1232,Residential,Fri May 16 00:00:00 EDT 2008,210000,38.640807,-121.5335221900 DANBROOK DR,SACRAMENTO,95835,CA,1,1,984,Condo,Fri May 16 00:00:00 EDT 2008,210944,38.668433,-121.503471140 VENTO CT,ROSEVILLE,95678,CA,3,2,0,Condo,Fri May 16 00:00:00 EDT 2008,212500,38.793533,-121.2896858442 KEUSMAN ST,ELK GROVE,95758,CA,4,2,2329,Residential,Fri May 16 00:00:00 EDT 2008,213750,38.449651,-121.4147049552 SUNLIGHT LN,ELK GROVE,95758,CA,3,2,1351,Residential,Fri May 16 00:00:00 EDT 2008,215000,38.410561,-121.4043272733 YUMA CT,CAMERON PARK,95682,CA,2,2,0,Residential,Fri May 16 00:00:00 EDT 2008,215000,38.691215,-120.9949491407 TIFFANY CIR,ROSEVILLE,95661,CA,4,1,1376,Residential,Fri May 16 00:00:00 EDT 2008,215000,38.736392,-121.2664636 CRESTVIEW DR,DIAMOND SPRINGS,95619,CA,3,2,1300,Residential,Fri May 16 00:00:00 EDT 2008,216033,38.688255,-120.8102351528 HESKET WAY,SACRAMENTO,95825,CA,4,2,1566,Residential,Fri May 16 00:00:00 EDT 2008,220000,38.593598,-121.4036372327 32ND ST,SACRAMENTO,95817,CA,2,1,1115,Residential,Fri May 16 00:00:00 EDT 2008,220000,38.557433,-121.470341833 2ND AVE,SACRAMENTO,95818,CA,2,1,1032,Residential,Fri May 16 00:00:00 EDT 2008,220000,38.556818,-121.4906697252 CARRIAGE DR,CITRUS HEIGHTS,95621,CA,4,2,1419,Residential,Fri May 16 00:00:00 EDT 2008,220000,38.698058,-121.2948939815 PASO FINO WAY,ELK GROVE,95757,CA,3,2,1261,Residential,Fri May 16 00:00:00 EDT 2008,220000,38.404888,-121.4439985532 ENGLE RD,CARMICHAEL,95608,CA,2,2,1637,Residential,Fri May 16 00:00:00 EDT 2008,220702,38.63173,-121.3352861139 CLINTON RD,SACRAMENTO,95825,CA,4,2,1776,Multi-Family,Fri May 16 00:00:00 EDT 2008,221250,38.585291,-121.4068249176 SAGE GLEN WAY,ELK GROVE,95758,CA,3,2,1338,Residential,Fri May 16 00:00:00 EDT 2008,222000,38.423913,-121.4391159967 HATHERTON WAY,ELK GROVE,95757,CA,0,0,0,Residential,Fri May 16 00:00:00 EDT 2008,222500,38.3052,-121.40339264 BOULDER RIVER WAY,ELK GROVE,95624,CA,5,2,2254,Residential,Fri May 16 00:00:00 EDT 2008,222750,38.421713,-121.345191320 GROTH CIR,SACRAMENTO,95834,CA,3,2,1441,Residential,Fri May 16 00:00:00 EDT 2008,225000,38.638882,-121.531883137 GUNNISON AVE,SACRAMENTO,95838,CA,4,2,1991,Residential,Fri May 16 00:00:00 EDT 2008,225000,38.650729,-121.4664838209 RIVALLO WAY,SACRAMENTO,95829,CA,4,3,2126,Residential,Fri May 16 00:00:00 EDT 2008,228750,38.459524,-121.35018637 PERIWINKLE CIR,ELK GROVE,95624,CA,3,2,1094,Residential,Fri May 16 00:00:00 EDT 2008,229000,38.443184,-121.3643883425 MEADOW WAY,ROCKLIN,95677,CA,3,2,1462,Residential,Fri May 16 00:00:00 EDT 2008,230095,38.798028,-121.235364107 JARVIS CIR,SACRAMENTO,95834,CA,5,3,2258,Residential,Fri May 16 00:00:00 EDT 2008,232500,38.639891,-121.5376032319 THORES ST,RANCHO CORDOVA,95670,CA,3,2,1074,Residential,Fri May 16 00:00:00 EDT 2008,233000,38.59675,-121.3127168935 MOUNTAIN HOME CT,ELK GROVE,95624,CA,4,2,2111,Residential,Fri May 16 00:00:00 EDT 2008,233500,38.38751,-121.3702762566 SERENATA WAY,SACRAMENTO,95835,CA,3,2,1686,Residential,Fri May 16 00:00:00 EDT 2008,239000,38.671556,-121.5209164085 COUNTRY DR,ANTELOPE,95843,CA,4,3,1915,Residential,Fri May 16 00:00:00 EDT 2008,240000,38.706209,-121.3695099297 TROUT WAY,ELK GROVE,95624,CA,4,2,2367,Residential,Fri May 16 00:00:00 EDT 2008,240000,38.420637,-121.3757987 ARCHIBALD CT,SACRAMENTO,95823,CA,3,2,1962,Residential,Fri May 16 00:00:00 EDT 2008,240971,38.443305,-121.43529611130 EEL RIVER CT,RANCHO CORDOVA,95670,CA,2,2,1406,Residential,Fri May 16 00:00:00 EDT 2008,242000,38.625932,-121.2715178323 REDBANK WAY,SACRAMENTO,95829,CA,3,2,1789,Residential,Fri May 16 00:00:00 EDT 2008,243450,38.455753,-121.34927316 BRONCO CREEK CT,SACRAMENTO,95835,CA,4,2,1876,Residential,Fri May 16 00:00:00 EDT 2008,243500,38.674226,-121.5254978316 NORTHAM DR,ANTELOPE,95843,CA,3,2,1235,Residential,Fri May 16 00:00:00 EDT 2008,246544,38.720767,-121.3766784240 WINJE DR,ANTELOPE,95843,CA,4,2,2504,Residential,Fri May 16 00:00:00 EDT 2008,246750,38.70884,-121.3595593569 SODA WAY,SACRAMENTO,95834,CA,0,0,0,Residential,Fri May 16 00:00:00 EDT 2008,247000,38.631139,-121.5018795118 ROBANDER ST,CARMICHAEL,95608,CA,3,2,1676,Residential,Fri May 16 00:00:00 EDT 2008,247000,38.657267,-121.3103525976 KYLENCH CT,CITRUS HEIGHTS,95621,CA,3,2,1367,Residential,Fri May 16 00:00:00 EDT 2008,249000,38.708966,-121.324679247 DELAIR WAY,ELK GROVE,95758,CA,4,3,1899,Residential,Fri May 16 00:00:00 EDT 2008,249000,38.422241,-121.4580229054 DESCENDANT DR,ELK GROVE,95758,CA,3,2,1636,Residential,Fri May 16 00:00:00 EDT 2008,250000,38.428852,-121.4156283450 WHITNOR CT,SACRAMENTO,95821,CA,3,2,1828,Residential,Fri May 16 00:00:00 EDT 2008,250000,38.627698,-121.3696986288 LONETREE BLVD,ROCKLIN,95765,CA,0,0,0,Residential,Fri May 16 00:00:00 EDT 2008,250000,38.804993,-121.2936099355 MATADOR WAY,SACRAMENTO,95826,CA,4,2,1438,Residential,Fri May 16 00:00:00 EDT 2008,252000,38.555633,-121.3506918671 SUMMER SUN WAY,ELK GROVE,95624,CA,3,2,1451,Residential,Fri May 16 00:00:00 EDT 2008,255000,38.442845,-121.3732721890 GENEVA PL,SACRAMENTO,95825,CA,3,1,1520,Residential,Fri May 16 00:00:00 EDT 2008,255000,38.599449,-121.4003051813 AVENIDA MARTINA,ROSEVILLE,95747,CA,3,2,1506,Residential,Fri May 16 00:00:00 EDT 2008,255000,38.776649,-121.339589191 BARNHART CIR,SACRAMENTO,95835,CA,4,2,2605,Residential,Fri May 16 00:00:00 EDT 2008,257200,38.675594,-121.5158786221 GREEN TOP WAY,ORANGEVALE,95662,CA,3,2,1196,Residential,Fri May 16 00:00:00 EDT 2008,260000,38.679409,-121.2191072298 PRIMROSE LN,LINCOLN,95648,CA,3,2,1621,Residential,Fri May 16 00:00:00 EDT 2008,260000,38.89918,-121.3225145635 LOS PUEBLOS WAY,SACRAMENTO,95835,CA,3,2,1811,Residential,Fri May 16 00:00:00 EDT 2008,263500,38.679191,-121.53762210165 LOFTON WAY,ELK GROVE,95757,CA,3,2,1540,Residential,Fri May 16 00:00:00 EDT 2008,266510,38.387708,-121.4365221251 GREEN RAVINE DR,LINCOLN,95648,CA,4,2,0,Residential,Fri May 16 00:00:00 EDT 2008,267750,38.88156,-121.3013436001 SHOO FLY RD,PLACERVILLE,95667,CA,0,0,0,Residential,Fri May 16 00:00:00 EDT 2008,270000,38.813546,-120.8092543040 PARKHAM DR,ROSEVILLE,95747,CA,0,0,0,Residential,Fri May 16 00:00:00 EDT 2008,271000,38.770835,-121.3669962674 TAM O SHANTER DR,EL DORADO HILLS,95762,CA,4,2,0,Residential,Fri May 16 00:00:00 EDT 2008,272700,38.695801,-121.0792166007 MARYBELLE LN,SHINGLE SPRINGS,95682,CA,0,0,0,Unkown,Fri May 16 00:00:00 EDT 2008,275000,38.64347,-120.8881839949 NESTLING CIR,ELK GROVE,95757,CA,3,2,1543,Residential,Fri May 16 00:00:00 EDT 2008,275000,38.397455,-121.4683912915 HOLDREGE WAY,SACRAMENTO,95835,CA,5,3,2494,Residential,Fri May 16 00:00:00 EDT 2008,276000,38.663728,-121.5258332678 BRIARTON DR,LINCOLN,95648,CA,3,2,1650,Residential,Fri May 16 00:00:00 EDT 2008,276500,38.844116,-121.274806294 SPARROW DR,GALT,95632,CA,4,3,2214,Residential,Fri May 16 00:00:00 EDT 2008,278000,38.258976,-121.3212662987 DIORITE WAY,SACRAMENTO,95835,CA,5,3,2280,Residential,Fri May 16 00:00:00 EDT 2008,279000,38.667332,-121.5282766326 APPIAN WAY,CARMICHAEL,95608,CA,3,2,1443,Residential,Fri May 16 00:00:00 EDT 2008,280000,38.66266,-121.3168586905 COBALT WAY,CITRUS HEIGHTS,95621,CA,4,2,1582,Residential,Fri May 16 00:00:00 EDT 2008,280000,38.691393,-121.3052158986 HAFLINGER WAY,ELK GROVE,95757,CA,3,2,1857,Residential,Fri May 16 00:00:00 EDT 2008,285000,38.397923,-121.4502192916 BABSON DR,ELK GROVE,95758,CA,3,2,1735,Residential,Fri May 16 00:00:00 EDT 2008,288000,38.417191,-121.47389710133 NEBBIOLO CT,ELK GROVE,95624,CA,4,3,2096,Residential,Fri May 16 00:00:00 EDT 2008,289000,38.391085,-121.3472311103 COMMONS DR,SACRAMENTO,95825,CA,3,2,1720,Residential,Fri May 16 00:00:00 EDT 2008,290000,38.567865,-121.4106994636 TEAL BAY CT,ANTELOPE,95843,CA,4,2,2160,Residential,Fri May 16 00:00:00 EDT 2008,290000,38.704554,-121.3547531524 YOUNGS AVE,SACRAMENTO,95838,CA,4,2,1382,Residential,Fri May 16 00:00:00 EDT 2008,293996,38.644927,-121.43054865 CONRAD CT,PLACERVILLE,95667,CA,3,2,0,Residential,Fri May 16 00:00:00 EDT 2008,294000,38.729993,-120.8024588463 TERRACOTTA CT,ELK GROVE,95624,CA,4,2,1721,Residential,Fri May 16 00:00:00 EDT 2008,294173,38.450548,-121.3630025747 KING RD,LOOMIS,95650,CA,4,2,1328,Residential,Fri May 16 00:00:00 EDT 2008,295000,38.825096,-121.1984328253 KEEGAN WAY,ELK GROVE,95624,CA,0,0,0,Residential,Fri May 16 00:00:00 EDT 2008,298000,38.446286,-121.4008179204 TROUT WAY,ELK GROVE,95624,CA,4,2,1982,Residential,Fri May 16 00:00:00 EDT 2008,298000,38.422221,-121.3757991828 2ND AVE,SACRAMENTO,95818,CA,2,1,1144,Residential,Fri May 16 00:00:00 EDT 2008,299000,38.556844,-121.4907691113 COMMONS DR,SACRAMENTO,95825,CA,2,2,1623,Residential,Fri May 16 00:00:00 EDT 2008,300000,38.567795,-121.4107032341 BIG STRIKE TRL,COOL,95614,CA,3,2,1457,Residential,Fri May 16 00:00:00 EDT 2008,300000,38.905927,-120.9751699452 RED SPRUCE WAY,ELK GROVE,95624,CA,6,3,2555,Residential,Fri May 16 00:00:00 EDT 2008,300000,38.404505,-121.3469385776 TERRACE DR,ROCKLIN,95765,CA,3,2,1577,Residential,Fri May 16 00:00:00 EDT 2008,300567,38.800539,-121.2609795908 MCLEAN DR,ELK GROVE,95757,CA,5,3,2592,Residential,Fri May 16 00:00:00 EDT 2008,303000,38.38912,-121.4343898215 PEREGRINE WAY,CITRUS HEIGHTS,95610,CA,3,2,1401,Residential,Fri May 16 00:00:00 EDT 2008,305000,38.715493,-121.262931104 HILLSDALE LN,LINCOLN,95648,CA,4,2,0,Residential,Fri May 16 00:00:00 EDT 2008,306000,38.865017,-121.323022949 PANAMA AVE,CARMICHAEL,95608,CA,3,2,1502,Residential,Fri May 16 00:00:00 EDT 2008,310000,38.618369,-121.3261871356 HARTLEY WAY,FOLSOM,95630,CA,3,2,1327,Residential,Fri May 16 00:00:00 EDT 2008,310000,38.651617,-121.131674633 HANISCH DR,ROSEVILLE,95678,CA,4,3,1800,Residential,Fri May 16 00:00:00 EDT 2008,310000,38.76349,-121.27588163 ANGEL ISLAND CIR,SACRAMENTO,95831,CA,4,2,2169,Residential,Fri May 16 00:00:00 EDT 2008,311518,38.490408,-121.5476641571 WILD OAK LN,LINCOLN,95648,CA,5,3,2457,Residential,Fri May 16 00:00:00 EDT 2008,312000,38.844144,-121.2741745222 COPPER SUNSET WAY,RANCHO CORDOVA,95742,CA,0,0,0,Residential,Fri May 16 00:00:00 EDT 2008,313000,38.529181,-121.2247555601 SPINDRIFT LN,ORANGEVALE,95662,CA,4,2,2004,Residential,Fri May 16 00:00:00 EDT 2008,315000,38.668289,-121.192316652 FIFTEEN MILE DR,ROSEVILLE,95678,CA,4,3,2212,Residential,Fri May 16 00:00:00 EDT 2008,315000,38.775872,-121.2988647921 DOE TRAIL WAY,ANTELOPE,95843,CA,5,3,3134,Residential,Fri May 16 00:00:00 EDT 2008,315000,38.711927,-121.3436084204 LUSK DR,SACRAMENTO,95864,CA,3,2,1360,Residential,Fri May 16 00:00:00 EDT 2008,315000,38.606569,-121.3684245321 DELTA DR,ROCKLIN,95765,CA,4,2,0,Residential,Fri May 16 00:00:00 EDT 2008,315000,38.815493,-121.2629085608 ROSEDALE WAY,SACRAMENTO,95822,CA,3,2,1276,Residential,Fri May 16 00:00:00 EDT 2008,320000,38.525115,-121.5186893372 BERETANIA WAY,SACRAMENTO,95834,CA,4,3,2962,Residential,Fri May 16 00:00:00 EDT 2008,322000,38.64977,-121.534482422 STEFANIE DR,ROCKLIN,95765,CA,4,2,1888,Residential,Fri May 16 00:00:00 EDT 2008,325000,38.82273,-121.264243232 PARKHAM DR,ROSEVILLE,95747,CA,0,0,0,Residential,Fri May 16 00:00:00 EDT 2008,325500,38.772821,-121.364821448 ELMWOOD CT,ROSEVILLE,95678,CA,3,2,0,Residential,Fri May 16 00:00:00 EDT 2008,326951,38.771917,-121.3044391214 DAWNWOOD DR,GALT,95632,CA,3,2,1548,Residential,Fri May 16 00:00:00 EDT 2008,328370,38.290119,-121.2860231440 EMERALD LN,LINCOLN,95648,CA,2,2,0,Residential,Fri May 16 00:00:00 EDT 2008,330000,38.861864,-121.2674783349 CORVINA DR,RANCHO CORDOVA,95670,CA,4,3,2109,Residential,Fri May 16 00:00:00 EDT 2008,330000,38.580545,-121.27901610254 JULIANA WAY,SACRAMENTO,95827,CA,4,2,2484,Residential,Fri May 16 00:00:00 EDT 2008,331200,38.56803,-121.309966149 OPUS CIR,SACRAMENTO,95834,CA,4,3,2258,Residential,Fri May 16 00:00:00 EDT 2008,332000,38.6354,-121.53499580 REGENCY PARK CIR,SACRAMENTO,95835,CA,3,3,2212,Residential,Fri May 16 00:00:00 EDT 2008,334000,38.674864,-121.49585544 CAMAS CT,ORANGEVALE,95662,CA,3,2,1616,Residential,Fri May 16 00:00:00 EDT 2008,335000,38.667703,-121.2094565102 ARCHCREST WAY,SACRAMENTO,95835,CA,4,2,2372,Residential,Fri May 16 00:00:00 EDT 2008,341000,38.66841,-121.4946395725 BALFOR RD,ROCKLIN,95765,CA,5,3,2606,Residential,Fri May 16 00:00:00 EDT 2008,346375,38.807816,-121.2700087697 ROSEHALL DR,ROSEVILLE,95678,CA,5,3,0,Residential,Fri May 16 00:00:00 EDT 2008,347225,38.79218,-121.285954821 HUTSON WAY,ELK GROVE,95757,CA,5,3,2877,Residential,Fri May 16 00:00:00 EDT 2008,349000,38.386239,-121.4481594509 WINJE DR,ANTELOPE,95843,CA,3,2,2960,Residential,Fri May 16 00:00:00 EDT 2008,350000,38.709513,-121.3593571965 LAURELHURST LN,LINCOLN,95648,CA,2,2,0,Residential,Fri May 16 00:00:00 EDT 2008,350000,38.853869,-121.2717426709 ROSE BRIDGE DR,ROSEVILLE,95678,CA,3,2,2172,Residential,Fri May 16 00:00:00 EDT 2008,350000,38.792461,-121.275711281 SPYGLASS HL,ROSEVILLE,95678,CA,3,2,2100,Condo,Fri May 16 00:00:00 EDT 2008,350000,38.762153,-121.2834517709 RIVER VILLAGE DR,SACRAMENTO,95831,CA,3,2,1795,Residential,Fri May 16 00:00:00 EDT 2008,351000,38.483212,-121.540194165 BRISBANE CIR,EL DORADO HILLS,95762,CA,3,2,0,Residential,Fri May 16 00:00:00 EDT 2008,356200,38.686067,-121.073413506 BEDFORD CT,ROSEVILLE,95661,CA,4,2,2295,Residential,Fri May 16 00:00:00 EDT 2008,360000,38.733985,-121.2367669048 PINTO CANYON WAY,ROSEVILLE,95747,CA,4,3,2577,Residential,Fri May 16 00:00:00 EDT 2008,367463,38.792493,-121.3318992274 IVY BRIDGE DR,ROSEVILLE,95747,CA,0,0,0,Residential,Fri May 16 00:00:00 EDT 2008,375000,38.778561,-121.36200814004 WALNUT AVE,WALNUT GROVE,95690,CA,3,1,1727,Residential,Fri May 16 00:00:00 EDT 2008,380000,38.247659,-121.5151296905 FRANKFORT CT,ELK GROVE,95758,CA,3,2,1485,Residential,Fri May 16 00:00:00 EDT 2008,380578,38.429139,-121.4234443621 WINTUN DR,CARMICHAEL,95608,CA,3,2,1655,Residential,Fri May 16 00:00:00 EDT 2008,386222,38.629929,-121.323086201 KIRKLAND CT,LINCOLN,95648,CA,0,0,0,Residential,Fri May 16 00:00:00 EDT 2008,389000,38.867125,-121.31908512075 APPLESBURY CT,RANCHO CORDOVA,95742,CA,0,0,0,Residential,Fri May 16 00:00:00 EDT 2008,390000,38.5357,-121.22491975 SIDESADDLE WAY,ROSEVILLE,95661,CA,3,2,2049,Residential,Fri May 16 00:00:00 EDT 2008,395500,38.737872,-121.2490255420 ALMOND FALLS WAY,RANCHO CORDOVA,95742,CA,0,0,0,Residential,Fri May 16 00:00:00 EDT 2008,396000,38.527384,-121.2335319677 PILLITERI CT,ELK GROVE,95757,CA,5,3,2875,Residential,Fri May 16 00:00:00 EDT 2008,397000,38.405571,-121.4451861515 EL CAMINO VERDE DR,LINCOLN,95648,CA,0,0,0,Residential,Fri May 16 00:00:00 EDT 2008,400000,38.904869,-121.32075556 PLATT CIR,EL DORADO HILLS,95762,CA,4,2,2199,Residential,Fri May 16 00:00:00 EDT 2008,400000,38.656299,-121.0797831792 DIAMOND WOODS CIR,ROSEVILLE,95747,CA,4,3,0,Residential,Fri May 16 00:00:00 EDT 2008,412500,38.808581,-121.327851124 PERKINS WAY,SACRAMENTO,95818,CA,2,1,1304,Residential,Fri May 16 00:00:00 EDT 2008,413500,38.551611,-121.5044374748 SALEM WAY,CARMICHAEL,95608,CA,3,2,2334,Residential,Fri May 16 00:00:00 EDT 2008,415000,38.634111,-121.3533761484 RADCLIFFE WAY,AUBURN,95603,CA,4,3,2278,Residential,Fri May 16 00:00:00 EDT 2008,420454,38.935579,-121.07901851 AIKEN WAY,SACRAMENTO,95819,CA,3,1,1493,Residential,Fri May 16 00:00:00 EDT 2008,425000,38.579326,-121.442522818 KNOLLWOOD DR,CAMERON PARK,95682,CA,3,2,0,Residential,Fri May 16 00:00:00 EDT 2008,425000,38.669805,-120.9990071536 STONEY CROSS LN,LINCOLN,95648,CA,0,0,0,Residential,Fri May 16 00:00:00 EDT 2008,433500,38.860007,-121.310946509 CASTILLIAN CT,ROSEVILLE,95747,CA,5,3,0,Residential,Fri May 16 00:00:00 EDT 2008,438000,38.804773,-121.341195700 HUNTER PL,FOLSOM,95630,CA,5,3,2787,Residential,Fri May 16 00:00:00 EDT 2008,441000,38.66051,-121.1636891240 FAY CIR,SACRAMENTO,95831,CA,5,3,2824,Residential,Fri May 16 00:00:00 EDT 2008,445000,38.506371,-121.5144561113 SANDWICK WAY,FOLSOM,95630,CA,4,3,3261,Residential,Fri May 16 00:00:00 EDT 2008,446000,38.673882,-121.1050773108 DELWOOD WAY,SACRAMENTO,95821,CA,4,2,2053,Residential,Fri May 16 00:00:00 EDT 2008,450000,38.621566,-121.3708823212 CORNICHE LN,ROSEVILLE,95661,CA,4,3,2379,Residential,Fri May 16 00:00:00 EDT 2008,455000,38.750577,-121.2327682159 BECKETT DR,EL DORADO HILLS,95762,CA,3,2,0,Residential,Fri May 16 00:00:00 EDT 2008,460000,38.680092,-121.0364674320 FOUR SEASONS RD,PLACERVILLE,95667,CA,3,2,0,Residential,Fri May 16 00:00:00 EDT 2008,475000,38.690867,-120.6936416401 MARSHALL RD,GARDEN VALLEY,95633,CA,3,2,0,Residential,Fri May 16 00:00:00 EDT 2008,490000,38.84255,-120.87542089 BECKETT DR,EL DORADO HILLS,95762,CA,4,2,0,Residential,Fri May 16 00:00:00 EDT 2008,493000,38.681778,-121.0358386196 EDGEHILL DR,EL DORADO HILLS,95762,CA,5,4,0,Residential,Fri May 16 00:00:00 EDT 2008,508000,38.676131,-121.038931200 HILLSFORD CT,ROSEVILLE,95747,CA,0,0,0,Residential,Fri May 16 00:00:00 EDT 2008,511000,38.780051,-121.3787188217 PLUMERIA AVE,FAIR OAKS,95628,CA,3,2,3173,Residential,Fri May 16 00:00:00 EDT 2008,525000,38.650735,-121.2586284841 VILLAGE GREEN DR,EL DORADO HILLS,95762,CA,4,3,0,Residential,Fri May 16 00:00:00 EDT 2008,533000,38.664066,-121.0567353863 LAS PASAS WAY,SACRAMENTO,95864,CA,3,1,1348,Residential,Fri May 16 00:00:00 EDT 2008,545000,38.588936,-121.373606820 DANA CT,AUBURN,95603,CA,4,3,0,Residential,Fri May 16 00:00:00 EDT 2008,560000,38.865246,-121.0948691165 37TH ST,SACRAMENTO,95816,CA,2,1,1252,Residential,Fri May 16 00:00:00 EDT 2008,575000,38.568438,-121.457854203 CASCADE FALLS DR,FOLSOM,95630,CA,4,3,3229,Residential,Fri May 16 00:00:00 EDT 2008,575000,38.703962,-121.18719880 IZILDA CT,SACRAMENTO,95829,CA,5,4,3863,Residential,Fri May 16 00:00:00 EDT 2008,598695,38.45326,-121.325731800 AVONDALE DR,ROSEVILLE,95747,CA,5,3,0,Residential,Fri May 16 00:00:00 EDT 2008,600000,38.798448,-121.3440544620 BROMWICH CT,ROCKLIN,95677,CA,4,3,0,Residential,Fri May 16 00:00:00 EDT 2008,600000,38.772672,-121.220232620 KESWICK CT,GRANITE BAY,95746,CA,4,3,2356,Residential,Fri May 16 00:00:00 EDT 2008,600000,38.732096,-121.2191424478 GREENBRAE RD,ROCKLIN,95677,CA,0,0,0,Residential,Fri May 16 00:00:00 EDT 2008,600000,38.781134,-121.2228018432 BRIGGS DR,ROSEVILLE,95747,CA,5,3,3579,Residential,Fri May 16 00:00:00 EDT 2008,610000,38.78861,-121.339495200 CRADLE MOUNTAIN CT,EL DORADO HILLS,95762,CA,0,0,0,Residential,Fri May 16 00:00:00 EDT 2008,622500,38.6478,-121.03092065 IMPRESSIONIST WAY,EL DORADO HILLS,95762,CA,0,0,0,Residential,Fri May 16 00:00:00 EDT 2008,680000,38.682961,-121.0332532982 ABERDEEN LN,EL DORADO HILLS,95762,CA,4,3,0,Residential,Fri May 16 00:00:00 EDT 2008,879000,38.706692,-121.0588699401 BARREL RACER CT,WILTON,95693,CA,4,3,4400,Residential,Fri May 16 00:00:00 EDT 2008,884790,38.415298,-121.1948583720 VISTA DE MADERA,LINCOLN,95648,CA,3,3,0,Residential,Fri May 16 00:00:00 EDT 2008,1551,38.851645,-121.23174214151 INDIO DR,SLOUGHHOUSE,95683,CA,3,4,5822,Residential,Fri May 16 00:00:00 EDT 2008,2000,38.490447,-121.1293377401 TOULON LN,SACRAMENTO,95828,CA,4,2,1512,Residential,Thu May 15 00:00:00 EDT 2008,56950,38.488628,-121.3877599127 NEWHALL DR Unit 34,SACRAMENTO,95826,CA,1,1,611,Condo,Thu May 15 00:00:00 EDT 2008,60000,38.542419,-121.3599045937 BAMFORD DR,SACRAMENTO,95823,CA,2,1,876,Residential,Thu May 15 00:00:00 EDT 2008,61000,38.471139,-121.4322555672 HILLSDALE BLVD,SACRAMENTO,95842,CA,2,1,933,Condo,Thu May 15 00:00:00 EDT 2008,62000,38.670467,-121.3597993920 39TH ST,SACRAMENTO,95820,CA,2,1,864,Residential,Thu May 15 00:00:00 EDT 2008,68566,38.539213,-121.46393701 JESSIE AVE,SACRAMENTO,95838,CA,2,1,1011,Residential,Thu May 15 00:00:00 EDT 2008,70000,38.643978,-121.44956283 ARCADE BLVD,SACRAMENTO,95815,CA,4,2,1158,Residential,Thu May 15 00:00:00 EDT 2008,80000,38.618716,-121.466327601 REGGINALD WAY,SACRAMENTO,95838,CA,3,2,1092,Residential,Thu May 15 00:00:00 EDT 2008,85500,38.64472,-121.452228550 DEL VERDE CIR,SACRAMENTO,95833,CA,2,1,956,Condo,Thu May 15 00:00:00 EDT 2008,92000,38.627147,-121.5007994113 DAYSTAR CT,SACRAMENTO,95824,CA,2,2,1139,Residential,Thu May 15 00:00:00 EDT 2008,93600,38.520469,-121.4586067374 TISDALE WAY,SACRAMENTO,95822,CA,3,1,1058,Residential,Thu May 15 00:00:00 EDT 2008,95000,38.488238,-121.4725613348 RIO LINDA BLVD,SACRAMENTO,95838,CA,3,2,1040,Residential,Thu May 15 00:00:00 EDT 2008,97750,38.628842,-121.4461273935 LIMESTONE WAY,SACRAMENTO,95823,CA,3,2,1354,Residential,Thu May 15 00:00:00 EDT 2008,104000,38.484374,-121.4631576208 GRATTAN WAY,NORTH HIGHLANDS,95660,CA,3,1,1051,Residential,Thu May 15 00:00:00 EDT 2008,105000,38.679279,-121.376615739 E WOODSIDE LN Unit E,SACRAMENTO,95825,CA,1,1,682,Condo,Thu May 15 00:00:00 EDT 2008,107666,38.578675,-121.4099514225 46TH AVE,SACRAMENTO,95824,CA,3,1,1161,Residential,Thu May 15 00:00:00 EDT 2008,109000,38.511893,-121.4576761434 BELL AVE,SACRAMENTO,95838,CA,3,1,1004,Residential,Thu May 15 00:00:00 EDT 2008,110000,38.647398,-121.4329145628 GEORGIA DR,NORTH HIGHLANDS,95660,CA,3,1,1229,Residential,Thu May 15 00:00:00 EDT 2008,110000,38.669587,-121.3798797629 BETH ST,SACRAMENTO,95832,CA,3,2,1249,Residential,Thu May 15 00:00:00 EDT 2008,112500,38.480126,-121.4878692277 BABETTE WAY,SACRAMENTO,95832,CA,3,2,1161,Residential,Thu May 15 00:00:00 EDT 2008,114800,38.479593,-121.484346561 WEATHERFORD WAY,SACRAMENTO,95823,CA,3,1,1010,Residential,Thu May 15 00:00:00 EDT 2008,116000,38.465551,-121.426613035 ESTEPA DR Unit 5C,CAMERON PARK,95682,CA,0,0,0,Condo,Thu May 15 00:00:00 EDT 2008,119000,38.681393,-120.9967135136 CABOT CIR,SACRAMENTO,95820,CA,4,2,1462,Residential,Thu May 15 00:00:00 EDT 2008,121500,38.528479,-121.4118067730 ROBINETTE RD,SACRAMENTO,95828,CA,3,2,1269,Residential,Thu May 15 00:00:00 EDT 2008,122000,38.47709,-121.41056987 LACAM CIR,SACRAMENTO,95820,CA,2,2,1188,Residential,Thu May 15 00:00:00 EDT 2008,123675,38.532359,-121.411671691 NOGALES ST,SACRAMENTO,95838,CA,4,2,1570,Residential,Thu May 15 00:00:00 EDT 2008,126854,38.631925,-121.4277753118 42ND ST,SACRAMENTO,95817,CA,3,2,1093,Residential,Thu May 15 00:00:00 EDT 2008,127059,38.546091,-121.4577457517 50TH AVE,SACRAMENTO,95828,CA,3,1,962,Residential,Thu May 15 00:00:00 EDT 2008,128687,38.507339,-121.4162674071 EVALITA WAY,SACRAMENTO,95823,CA,3,2,1089,Residential,Thu May 15 00:00:00 EDT 2008,129500,38.466388,-121.4588617928 36TH AVE,SACRAMENTO,95824,CA,3,2,1127,Residential,Thu May 15 00:00:00 EDT 2008,130000,38.52049,-121.4113836631 DEMARET DR,SACRAMENTO,95822,CA,4,2,1309,Residential,Thu May 15 00:00:00 EDT 2008,131750,38.506382,-121.4835747043 9TH AVE,RIO LINDA,95673,CA,2,1,970,Residential,Thu May 15 00:00:00 EDT 2008,132000,38.695589,-121.44413397 KENNELFORD CIR,SACRAMENTO,95823,CA,3,2,1144,Residential,Thu May 15 00:00:00 EDT 2008,134000,38.462376,-121.4265562636 TRONERO WAY,RANCHO CORDOVA,95670,CA,3,1,1000,Residential,Thu May 15 00:00:00 EDT 2008,134000,38.593049,-121.303041530 TOPANGA LN Unit 204,LINCOLN,95648,CA,0,0,0,Condo,Thu May 15 00:00:00 EDT 2008,138000,38.88415,-121.2702773604 KODIAK WAY,ANTELOPE,95843,CA,3,2,1206,Residential,Thu May 15 00:00:00 EDT 2008,142000,38.706175,-121.3797762149 COTTAGE WAY,SACRAMENTO,95825,CA,3,1,1285,Residential,Thu May 15 00:00:00 EDT 2008,143012,38.603593,-121.4170118632 PRAIRIEWOODS DR,SACRAMENTO,95828,CA,3,2,1543,Residential,Thu May 15 00:00:00 EDT 2008,145846,38.477563,-121.384382612 STONE BLVD,WEST SACRAMENTO,95691,CA,2,1,884,Residential,Thu May 15 00:00:00 EDT 2008,147000,38.563084,-121.5355794180 12TH AVE,SACRAMENTO,95817,CA,3,1,1019,Residential,Thu May 15 00:00:00 EDT 2008,148750,38.54117,-121.4581298025 ARROYO VISTA DR,SACRAMENTO,95823,CA,4,2,1392,Residential,Thu May 15 00:00:00 EDT 2008,150000,38.46654,-121.4190295754 WALERGA RD Unit 4,SACRAMENTO,95842,CA,2,1,924,Condo,Thu May 15 00:00:00 EDT 2008,150454,38.672567,-121.3567548 LA ROCAS CT,SACRAMENTO,95823,CA,3,2,1217,Residential,Thu May 15 00:00:00 EDT 2008,151087,38.46616,-121.4482838636 LONGSPUR WAY,ANTELOPE,95843,CA,3,2,1670,Residential,Thu May 15 00:00:00 EDT 2008,157296,38.725873,-121.358561941 EXPEDITION WAY,SACRAMENTO,95832,CA,3,2,1302,Residential,Thu May 15 00:00:00 EDT 2008,157500,38.473775,-121.4937774351 TURNBRIDGE DR,SACRAMENTO,95823,CA,3,2,1488,Residential,Thu May 15 00:00:00 EDT 2008,160000,38.502034,-121.4560276513 HOLIDAY WAY,NORTH HIGHLANDS,95660,CA,3,2,1373,Residential,Thu May 15 00:00:00 EDT 2008,160000,38.685361,-121.3769388321 MISTLETOE WAY,CITRUS HEIGHTS,95621,CA,4,2,1381,Residential,Thu May 15 00:00:00 EDT 2008,161250,38.717738,-121.3083225920 VALLEY GLEN WAY,SACRAMENTO,95823,CA,3,2,1265,Residential,Thu May 15 00:00:00 EDT 2008,164000,38.462821,-121.4331352601 SAN FERNANDO WAY,SACRAMENTO,95818,CA,2,1,881,Residential,Thu May 15 00:00:00 EDT 2008,165000,38.556178,-121.476256501 POPLAR AVE,WEST SACRAMENTO,95691,CA,0,0,0,Residential,Thu May 15 00:00:00 EDT 2008,165000,38.584526,-121.5346098008 SAINT HELENA CT,SACRAMENTO,95829,CA,4,2,1608,Residential,Thu May 15 00:00:00 EDT 2008,165750,38.467012,-121.3599696517 DONEGAL DR,CITRUS HEIGHTS,95621,CA,3,1,1344,Residential,Thu May 15 00:00:00 EDT 2008,166000,38.681554,-121.3129341001 RIO NORTE WAY,SACRAMENTO,95834,CA,3,2,1202,Residential,Thu May 15 00:00:00 EDT 2008,169000,38.634292,-121.485106604 P ST,LINCOLN,95648,CA,3,2,1104,Residential,Thu May 15 00:00:00 EDT 2008,170000,38.893168,-121.30539810001 WOODCREEK OAKS BLVD Unit 815,ROSEVILLE,95747,CA,2,2,0,Condo,Thu May 15 00:00:00 EDT 2008,170000,38.795529,-121.3288197351 GIGI PL,SACRAMENTO,95828,CA,4,2,1859,Multi-Family,Thu May 15 00:00:00 EDT 2008,170000,38.490606,-121.4101737740 DIXIE LOU ST,SACRAMENTO,95832,CA,3,2,1232,Residential,Thu May 15 00:00:00 EDT 2008,170000,38.475853,-121.4770397342 DAVE ST,SACRAMENTO,95828,CA,3,1,1638,Residential,Thu May 15 00:00:00 EDT 2008,170725,38.490822,-121.4016437687 HOWERTON DR,SACRAMENTO,95831,CA,2,2,1177,Residential,Thu May 15 00:00:00 EDT 2008,171750,38.480859,-121.53974526 KAMSON CT,SACRAMENTO,95833,CA,3,2,1582,Residential,Thu May 15 00:00:00 EDT 2008,172000,38.622794,-121.4991737045 PEEVEY CT,SACRAMENTO,95823,CA,2,2,904,Residential,Thu May 15 00:00:00 EDT 2008,173056,38.502254,-121.4514448916 GABLES MILL PL,ELK GROVE,95758,CA,3,2,1340,Residential,Thu May 15 00:00:00 EDT 2008,174000,38.433919,-121.4223471140 EDMONTON DR,SACRAMENTO,95833,CA,3,2,1204,Residential,Thu May 15 00:00:00 EDT 2008,174250,38.62457,-121.4869138879 APPLE PEAR CT,ELK GROVE,95624,CA,4,2,1477,Residential,Thu May 15 00:00:00 EDT 2008,176850,38.44574,-121.37259 WIND CT,SACRAMENTO,95823,CA,4,2,1497,Residential,Thu May 15 00:00:00 EDT 2008,179500,38.45073,-121.4275288570 SHERATON DR,FAIR OAKS,95628,CA,3,1,960,Residential,Thu May 15 00:00:00 EDT 2008,185000,38.667254,-121.2407081550 TOPANGA LN Unit 207,LINCOLN,95648,CA,0,0,0,Condo,Thu May 15 00:00:00 EDT 2008,188000,38.88417,-121.2702221080 RIO NORTE WAY,SACRAMENTO,95834,CA,3,2,1428,Residential,Thu May 15 00:00:00 EDT 2008,188700,38.634335,-121.4860985501 VALLETTA WAY,SACRAMENTO,95820,CA,3,1,1039,Residential,Thu May 15 00:00:00 EDT 2008,189000,38.530144,-121.437495624 MEMORY LN,FAIR OAKS,95628,CA,3,1,1529,Residential,Thu May 15 00:00:00 EDT 2008,189000,38.66745,-121.23646622 WILLOWLEAF DR,CITRUS HEIGHTS,95621,CA,4,3,1892,Residential,Thu May 15 00:00:00 EDT 2008,189836,38.699714,-121.31163527 MEGAN CT,SACRAMENTO,95838,CA,4,2,1887,Residential,Thu May 15 00:00:00 EDT 2008,190000,38.649258,-121.4653086601 WOODMORE OAKS DR,ORANGEVALE,95662,CA,3,2,1294,Residential,Thu May 15 00:00:00 EDT 2008,191250,38.687006,-121.2543191973 DANVERS WAY,SACRAMENTO,95832,CA,3,2,1638,Residential,Thu May 15 00:00:00 EDT 2008,191675,38.477568,-121.4925748001 ARROYO VISTA DR,SACRAMENTO,95823,CA,3,2,1677,Residential,Thu May 15 00:00:00 EDT 2008,195500,38.46734,-121.4198437409 VOYAGER WAY,CITRUS HEIGHTS,95621,CA,3,1,1073,Residential,Thu May 15 00:00:00 EDT 2008,198000,38.700717,-121.3133815 CROSSWIND DR,SACRAMENTO,95838,CA,3,2,1231,Residential,Thu May 15 00:00:00 EDT 2008,200000,38.651386,-121.450425509 LAGUNA CREST WAY,ELK GROVE,95758,CA,3,2,1175,Residential,Thu May 15 00:00:00 EDT 2008,200000,38.42442,-121.4403578424 MERRY HILL WAY,ELK GROVE,95624,CA,3,2,1416,Residential,Thu May 15 00:00:00 EDT 2008,200000,38.452075,-121.3664611525 PENNSYLVANIA AVE,WEST SACRAMENTO,95691,CA,0,0,0,Residential,Thu May 15 00:00:00 EDT 2008,200100,38.569943,-121.5275395954 BRIDGECROSS DR,SACRAMENTO,95835,CA,3,2,1358,Residential,Thu May 15 00:00:00 EDT 2008,201528,38.68197,-121.5000258789 SEQUOIA WOOD CT,ELK GROVE,95624,CA,4,2,1609,Residential,Thu May 15 00:00:00 EDT 2008,204750,38.438818,-121.374436600 SILVERTHORNE CIR,SACRAMENTO,95842,CA,4,3,1968,Residential,Thu May 15 00:00:00 EDT 2008,205000,38.68607,-121.3423692221 2ND AVE,SACRAMENTO,95818,CA,2,2,1089,Residential,Thu May 15 00:00:00 EDT 2008,205000,38.555781,-121.4853313230 SMATHERS WAY,CARMICHAEL,95608,CA,3,2,1296,Residential,Thu May 15 00:00:00 EDT 2008,205900,38.623372,-121.3476655209 LAGUNA CREST WAY,ELK GROVE,95758,CA,2,2,1189,Residential,Thu May 15 00:00:00 EDT 2008,207000,38.424421,-121.443915416 LEITCH AVE,SACRAMENTO,95815,CA,2,1,795,Residential,Thu May 15 00:00:00 EDT 2008,207973,38.612694,-121.4566692100 BEATTY WAY,ROSEVILLE,95747,CA,3,2,1371,Residential,Thu May 15 00:00:00 EDT 2008,208250,38.737882,-121.3081426920 GILLINGHAM WAY,NORTH HIGHLANDS,95660,CA,3,1,1310,Residential,Thu May 15 00:00:00 EDT 2008,208318,38.694279,-121.37339582 WILDFLOWER DR,GALT,95632,CA,3,2,1262,Residential,Thu May 15 00:00:00 EDT 2008,209347,38.259708,-121.3116168652 BANTON CIR,ELK GROVE,95624,CA,4,2,1740,Residential,Thu May 15 00:00:00 EDT 2008,211500,38.444,-121.3709938428 MISTY PASS WAY,ANTELOPE,95843,CA,3,2,1517,Residential,Thu May 15 00:00:00 EDT 2008,212000,38.722959,-121.3471157958 ROSEVIEW WAY,SACRAMENTO,95828,CA,3,2,1450,Residential,Thu May 15 00:00:00 EDT 2008,213000,38.467836,-121.4103669020 LUKEN CT,ELK GROVE,95624,CA,3,2,1416,Residential,Thu May 15 00:00:00 EDT 2008,216000,38.451398,-121.3666147809 VALLECITOS WAY,SACRAMENTO,95828,CA,3,1,888,Residential,Thu May 15 00:00:00 EDT 2008,216021,38.508217,-121.4112078445 OLD AUBURN RD,CITRUS HEIGHTS,95610,CA,3,2,1882,Residential,Thu May 15 00:00:00 EDT 2008,219000,38.715423,-121.24674310085 ATKINS DR,ELK GROVE,95757,CA,3,2,1302,Residential,Thu May 15 00:00:00 EDT 2008,219794,38.390893,-121.4378219185 CERROLINDA CIR,ELK GROVE,95758,CA,3,2,1418,Residential,Thu May 15 00:00:00 EDT 2008,220000,38.424497,-121.4265959197 CORTINA CIR,ROSEVILLE,95678,CA,3,2,0,Condo,Thu May 15 00:00:00 EDT 2008,220000,38.793152,-121.2900255429 HESPER WAY,CARMICHAEL,95608,CA,4,2,1319,Residential,Thu May 15 00:00:00 EDT 2008,220000,38.665104,-121.3159011178 WARMWOOD CT,GALT,95632,CA,4,2,1770,Residential,Thu May 15 00:00:00 EDT 2008,220000,38.289544,-121.2846074900 ELUDE CT,SACRAMENTO,95842,CA,4,2,1627,Residential,Thu May 15 00:00:00 EDT 2008,223000,38.69674,-121.3505193557 SODA WAY,SACRAMENTO,95834,CA,0,0,0,Residential,Thu May 15 00:00:00 EDT 2008,224000,38.631026,-121.5018793528 SAINT GEORGE DR,SACRAMENTO,95821,CA,3,1,1040,Residential,Thu May 15 00:00:00 EDT 2008,224000,38.629468,-121.3764457381 WASHBURN WAY,NORTH HIGHLANDS,95660,CA,3,1,960,Residential,Thu May 15 00:00:00 EDT 2008,224252,38.70355,-121.3751032181 WINTERHAVEN CIR,CAMERON PARK,95682,CA,3,2,0,Residential,Thu May 15 00:00:00 EDT 2008,224500,38.69757,-120.9957397540 HICKORY AVE,ORANGEVALE,95662,CA,3,1,1456,Residential,Thu May 15 00:00:00 EDT 2008,225000,38.703056,-121.2352215024 CHAMBERLIN CIR,ELK GROVE,95757,CA,3,2,1450,Residential,Thu May 15 00:00:00 EDT 2008,228000,38.389756,-121.4462462400 INVERNESS DR,LINCOLN,95648,CA,3,2,1358,Residential,Thu May 15 00:00:00 EDT 2008,229027,38.897814,-121.3246915 BISHOPGATE CT,SACRAMENTO,95823,CA,4,2,1329,Residential,Thu May 15 00:00:00 EDT 2008,229500,38.467936,-121.4454775601 REXLEIGH DR,SACRAMENTO,95823,CA,4,2,1715,Residential,Thu May 15 00:00:00 EDT 2008,230000,38.445342,-121.4415041909 YARNELL WAY,ELK GROVE,95758,CA,3,2,1262,Residential,Thu May 15 00:00:00 EDT 2008,230000,38.417382,-121.4843259169 GARLINGTON CT,SACRAMENTO,95829,CA,4,3,2280,Residential,Thu May 15 00:00:00 EDT 2008,232425,38.457679,-121.359626932 RUSKUT WAY,SACRAMENTO,95823,CA,3,2,1477,Residential,Thu May 15 00:00:00 EDT 2008,234000,38.499893,-121.458897933 DAFFODIL WAY,CITRUS HEIGHTS,95610,CA,3,2,1216,Residential,Thu May 15 00:00:00 EDT 2008,235000,38.708824,-121.2568038304 RED FOX WAY,ELK GROVE,95758,CA,4,2,1685,Residential,Thu May 15 00:00:00 EDT 2008,235301,38.417,-121.3974243882 YELLOWSTONE LN,EL DORADO HILLS,95762,CA,3,2,1362,Residential,Thu May 15 00:00:00 EDT 2008,235738,38.655245,-121.075915"; }, + thumbnail_uri: function () { return null; } + } + + , + "fig1.svg": { + name: "fig1.svg", + filename: "fig1.svg", + path: "fig1.svg", + size: "28.3 kB", + caption: "

This is a caption with a link.

\n", + job_properties: { + rule: "a", + wildcards: "", + params: "" + }, + data_uri: function () { return "data:image/svg+xml;charset=utf8;filename=fig1.svg;base64,<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" width="800px" height="600px" viewBox="0 0 800 600" enable-background="new 0 0 800 600" xml:space="preserve">  <image id="image0" width="800" height="600" x="0" y="0"
    xlink:href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAyAAAAJYCAYAAACadoJwAAAABGdBTUEAALGPC/xhBQAAACBjSFJN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" />
</svg>
"; }, + thumbnail_uri: function () { return null; } + } + + , + "testmodel.fig2.png": { + name: "testmodel.fig2.png", + filename: "testmodel.fig2.png", + path: "testmodel.fig2.png", + size: "9.1 kB", + caption: "

Some math \u2211ii2.

\n", + job_properties: { + rule: "b", + wildcards: "model=testmodel", + params: "" + }, + data_uri: function () { return "data:image/png;charset=utf8;filename=testmodel.fig2.png;base64,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"; }, + thumbnail_uri: function () { return null; } + } + + +}; \ No newline at end of file diff --git a/playground/react/rulegraph.js b/playground/react/rulegraph.js new file mode 100644 index 000000000..8c9225d58 --- /dev/null +++ b/playground/react/rulegraph.js @@ -0,0 +1,142 @@ +var rulegraph_spec = { + "$schema": "https://vega.github.io/schema/vega/v5.json", + "padding": 0, + + "signals": [ + { "name": "cx", "update": "width / 2" }, + { "name": "cy", "update": "height / 2" } + ], + + "data": [ + { + "name": "node-data", + "values": [{ 'rule': 'c', 'fx': 10, 'fy': 0 }, { 'rule': 'd', 'fx': 10, 'fy': 50 }, { 'rule': 'e', 'fx': 10, 'fy': 100 }, { 'rule': 'a', 'fx': 10, 'fy': 150 }, { 'rule': 'b', 'fx': 10, 'fy': 200 }, { 'rule': 'all', 'fx': 10, 'fy': 250 }] + }, + { + "name": "link-data", + "values": [{ 'target': 3, 'source': 0, 'value': 1 }, { 'target': 3, 'source': 0, 'value': 1 }, { 'target': 3, 'source': 0, 'value': 1 }, { 'target': 3, 'source': 0, 'value': 1 }, { 'target': 3, 'source': 0, 'value': 1 }, { 'target': 3, 'source': 0, 'value': 1 }, { 'target': 3, 'source': 0, 'value': 1 }, { 'target': 3, 'source': 0, 'value': 1 }, { 'target': 3, 'source': 0, 'value': 1 }, { 'target': 3, 'source': 0, 'value': 1 }, { 'target': 4, 'source': 0, 'value': 1 }, { 'target': 4, 'source': 0, 'value': 1 }, { 'target': 4, 'source': 0, 'value': 1 }, { 'target': 4, 'source': 0, 'value': 1 }, { 'target': 4, 'source': 0, 'value': 1 }, { 'target': 4, 'source': 0, 'value': 1 }, { 'target': 4, 'source': 0, 'value': 1 }, { 'target': 4, 'source': 0, 'value': 1 }, { 'target': 4, 'source': 0, 'value': 1 }, { 'target': 4, 'source': 0, 'value': 1 }, { 'target': 5, 'source': 3, 'value': 1 }, { 'target': 5, 'source': 1, 'value': 1 }, { 'target': 5, 'source': 2, 'value': 1 }] + }, + { + "name": "link-data-direct", + "values": [{ 'target': 5, 'source': 4, 'value': 1 }] + } + ], + + "scales": [ + { + "name": "color", + "type": "ordinal", + "range": { "scheme": "category20c" } + }, + { + "name": "x", + "type": "linear" + }, + { + "name": "y", + "type": "linear" + } + ], + + "marks": [ + { + "name": "nodes", + "type": "symbol", + "zindex": 1, + "from": { "data": "node-data" }, + "encode": { + "enter": { + "fill": { "scale": "color", "field": "rule" }, + "x": { "field": "fx", "scale": "x" }, + "y": { "field": "fy", "scale": "y" }, + "tooltip": { "value": "Click to show rule details." } + }, + "update": { + "size": { "value": 70 } + }, + "hover": { + "size": { "value": 140 } + } + }, + + "transform": [ + { + "type": "force", + "iterations": 1, + "static": true, + "forces": [ + { + "force": "link", + "links": "link-data" + } + ] + }, + { + "type": "force", + "iterations": 1, + "static": true, + "forces": [ + { + "force": "link", + "links": "link-data-direct" + } + ] + } + ] + }, + { + "name": "labels", + "type": "text", + "zindex": 2, + "from": { "data": "node-data" }, + "encode": { + "enter": { + "fill": { "value": "black" }, + "fontWeight": { "value": "normal" }, + "text": { "field": "rule" }, + "x": { "field": "fx", "scale": "x" }, + "y": { "field": "fy", "scale": "y" }, + "dx": { "value": -5 }, + "dy": { "value": -5 }, + "align": { "value": "right" } + } + } + }, + { + "type": "path", + "from": { "data": "link-data-direct" }, + "interactive": false, + "encode": { + "update": { + "stroke": { "value": "#ccc" }, + "strokeWidth": { "value": 1.0 } + } + }, + "transform": [ + { + "type": "linkpath", "shape": "diagonal", + "sourceX": "datum.source.x", "sourceY": "datum.source.y", + "targetX": "datum.target.x", "targetY": "datum.target.y" + } + ] + }, + { + "type": "path", + "from": { "data": "link-data" }, + "interactive": false, + "encode": { + "update": { + "stroke": { "value": "#ccc" }, + "strokeWidth": { "value": 1.0 } + } + }, + "transform": [ + { + "type": "linkpath", "shape": "curve", "orient": "horizontal", + "sourceX": "datum.source.x", "sourceY": "datum.source.y", + "targetX": "datum.target.x", "targetY": "datum.target.y" + } + ] + } + ] +}; \ No newline at end of file diff --git a/playground/react/runtimes.js b/playground/react/runtimes.js new file mode 100644 index 000000000..81b4cd85d --- /dev/null +++ b/playground/react/runtimes.js @@ -0,0 +1,15 @@ +var runtimes_spec = { + "$schema": "https://vega.github.io/schema/vega-lite/v3.json", + "description": "Runtimes of jobs.", + "data": { "values": [{ 'rule': 'a', 'runtime': 2.0280115604400635 }, { 'rule': 'c', 'runtime': 3.028017282485962 }, { 'rule': 'c', 'runtime': 3.020017147064209 }, { 'rule': 'c', 'runtime': 2.0160114765167236 }, { 'rule': 'c', 'runtime': 3.016017198562622 }, { 'rule': 'c', 'runtime': 1.0240058898925781 }, { 'rule': 'c', 'runtime': 3.016016960144043 }, { 'rule': 'c', 'runtime': 1.0160057544708252 }, { 'rule': 'c', 'runtime': 2.0120115280151367 }, { 'rule': 'c', 'runtime': 3.024017095565796 }, { 'rule': 'c', 'runtime': 1.0160057544708252 }, { 'rule': 'd', 'runtime': 1.0520060062408447 }, { 'rule': 'e', 'runtime': 0.012000083923339844 }] }, + "mark": "point", + "encoding": { + "x": { + "field": "runtime", "type": "quantitative", + "axis": { "title": "runtime [s]", "labelAngle": -90 }, + "scale": { "type": "log" } + }, + "y": { "field": "rule", "type": "nominal" }, + "color": { "value": "#007bff" } + } +}; \ No newline at end of file diff --git a/playground/react/timeline.js b/playground/react/timeline.js new file mode 100644 index 000000000..294a3e018 --- /dev/null +++ b/playground/react/timeline.js @@ -0,0 +1,20 @@ +var timeline_spec = { + "$schema": "https://vega.github.io/schema/vega-lite/v3.json", + "description": "Timeline of jobs.", + "data": { + "values": [{ 'rule': 'a', 'starttime': '2020-03-27T14:58:42.460061', 'endtime': '2020-03-27T14:58:44.488072' }, { 'rule': 'c', 'starttime': '2020-03-27T14:58:39.404043', 'endtime': '2020-03-27T14:58:42.432060' }, { 'rule': 'c', 'starttime': '2020-03-27T14:58:38.368037', 'endtime': '2020-03-27T14:58:41.388055' }, { 'rule': 'c', 'starttime': '2020-03-27T14:58:38.384037', 'endtime': '2020-03-27T14:58:40.400049' }, { 'rule': 'c', 'starttime': '2020-03-27T14:58:38.352037', 'endtime': '2020-03-27T14:58:41.368054' }, { 'rule': 'c', 'starttime': '2020-03-27T14:58:39.356043', 'endtime': '2020-03-27T14:58:40.380049' }, { 'rule': 'c', 'starttime': '2020-03-27T14:58:38.344037', 'endtime': '2020-03-27T14:58:41.360054' }, { 'rule': 'c', 'starttime': '2020-03-27T14:58:38.332037', 'endtime': '2020-03-27T14:58:39.348043' }, { 'rule': 'c', 'starttime': '2020-03-27T14:58:38.340037', 'endtime': '2020-03-27T14:58:40.352049' }, { 'rule': 'c', 'starttime': '2020-03-27T14:58:39.424043', 'endtime': '2020-03-27T14:58:42.448061' }, { 'rule': 'c', 'starttime': '2020-03-27T14:58:38.376037', 'endtime': '2020-03-27T14:58:39.392043' }, { 'rule': 'd', 'starttime': '2020-03-27T14:58:38.360037', 'endtime': '2020-03-27T14:58:39.412043' }, { 'rule': 'e', 'starttime': '2020-03-27T14:58:38.356037', 'endtime': '2020-03-27T14:58:38.368037' }] + }, + "mark": "point", + "encoding": { + "x": { + "field": "endtime", "type": "temporal", + "timeUnit": "yearmonthdatehoursminutes", + "axis": { + "labelAngle": -90, + "title": "creation date" + } + }, + "y": { "field": "rule", "type": "nominal" }, + "color": { "value": "#007bff" } + } +}; \ No newline at end of file From 82ebfde2aa6e921752a9eada5ea3c4d9b34cd636 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Johannes=20K=C3=B6ster?= Date: Wed, 9 Mar 2022 12:07:58 +0100 Subject: [PATCH 06/45] refactor --- playground/react/components/app.js | 16 ++++++-- playground/react/components/navbar.js | 55 +++++++++++++-------------- 2 files changed, 39 insertions(+), 32 deletions(-) diff --git a/playground/react/components/app.js b/playground/react/components/app.js index 0cba404fb..7f8ea7bbf 100644 --- a/playground/react/components/app.js +++ b/playground/react/components/app.js @@ -5,18 +5,28 @@ class App extends React.Component { constructor(props) { super(props); - this.state = { content: "rulegraph", ruleinfo: undefined }; + this.state = { navbarMode: "menu", content: "rulegraph", ruleinfo: undefined, category: undefined, subcategory: undefined, searchTerm: undefined, resultPath: undefined }; + this.setView = this.setView.bind(this); } render() { return [ - e(Navbar, { app: this, ruleinfo: this.state.ruleinfo }), + e(Navbar, { app: this }), e(ContentDisplay, { show: this.state.content }) ]; } setView(view) { - this.setState({ content: view.content, ruleinfo: view.ruleinfo }) + event.preventDefault(); + this.setState({ + navbarMode: view.mode || this.state.navbarMode, + content: view.content || this.state.content, + ruleinfo: view.ruleinfo, + category: view.category, + subcategory: view.subcategory, + searchTerm: view.searchTerm, + resultPath: view.resultPath + }) } } diff --git a/playground/react/components/navbar.js b/playground/react/components/navbar.js index 7ea053f84..bc2428e80 100644 --- a/playground/react/components/navbar.js +++ b/playground/react/components/navbar.js @@ -4,8 +4,6 @@ class Navbar extends React.Component { constructor(props) { super(props); - this.state = { mode: "menu", category: undefined, subcategory: undefined, searchTerm: undefined, resultPath: undefined }; - this.setView = this.setView.bind(this); } render() { @@ -40,26 +38,26 @@ class Navbar extends React.Component { } renderContent() { - let setView = this.setView; - switch (this.state.mode) { + let setView = this.props.app.setView; + switch (this.props.app.state.navbarMode) { case "menu": return e(Menu, { setView: setView, app: this.props.app }); case "category": - if (this.state.subcategory !== undefined) { - return e(Subcategory, { setView: setView, category: this.state.category, subcategory: this.state.subcategory }); + if (this.props.app.state.subcategory !== undefined) { + return e(Subcategory, { setView: setView, category: this.props.app.state.category, subcategory: this.props.app.state.subcategory }); } else { - return e(Category, { setView: setView, category: this.state.category }); + return e(Category, { setView: setView, category: this.props.app.state.category }); } case "searchresults": - return e(SearchResults, { setView: setView, searchTerm: this.state.searchTerm }); + return e(SearchResults, { setView: setView, searchTerm: this.props.app.state.searchTerm }); case "resultinfo": - return e(ResultInfo, { resultPath: this.state.resultPath }); + return e(ResultInfo, { resultPath: this.props.app.state.resultPath }); } } renderBreadcrumbs() { - let setView = this.setView; - switch (this.state.mode) { + let setView = this.props.app.setView; + switch (this.props.app.state.navbarMode) { case "menu": return e( Breadcrumbs, @@ -84,33 +82,37 @@ class Navbar extends React.Component { } getMenuBreadcrumb() { - let _this = this; - return { name: "menu", icon: "home", func: function () { _this.setView({ mode: "menu", category: undefined, subcategory: undefined }) } }; + let setView = this.props.app.setView; + return { name: "menu", icon: "home", func: function () { setView({ mode: "menu", category: undefined, subcategory: undefined }) } }; } getCategoryBreadcrumb() { - if (this.state.category === undefined) { + let category = this.props.app.state.category; + if (category === undefined) { return undefined; } let subcategory = undefined; - if (isSingleSubcategory(this.state.category)) { - subcategory = this.state.subcategory; + if (isSingleSubcategory(category)) { + subcategory = this.props.app.state.subcategory; } let _this = this; - let name = this.state.category; + let name = this.props.app.state.category; if (isSingleDefaultCategory()) { name = "Results"; } - return { name: name, func: function () { _this.setView({ mode: "category", category: _this.state.category, subcategory: subcategory }) } }; + let setView = this.props.app.setView; + return { name: name, func: function () { setView({ mode: "category", category: category, subcategory: subcategory }) } }; } getSubcategoryBreadcrumb() { - if (this.state.subcategory === undefined || isSingleSubcategory(this.state.category)) { + let subcategory = this.props.app.state.subcategory; + let category = this.props.app.state.category; + if (subcategory === undefined || isSingleSubcategory(category)) { return undefined; } - let _this = this; - return { name: this.state.subcategory, func: function () { _this.setView({ mode: "category", category: _this.state.category, subcategory: _this.state.subcategory }) } }; + let setView = this.props.app.setView; + return { name: this.props.app.state.subcategory, func: function () { setView({ mode: "category", category: category, subcategory: subcategory }) } }; } getResultBreadcrumb() { @@ -121,11 +123,11 @@ class Navbar extends React.Component { } getSearchResultsBreadcrumb() { - let searchTerm = this.state.searchTerm; + let searchTerm = this.props.app.state.searchTerm; if (searchTerm === undefined) { return undefined; } - let setView = this.setView; + let setView = this.props.app.setView; return { name: "Search results", func: function () { setView({ mode: "searchresults", searchTerm: searchTerm }) @@ -138,7 +140,7 @@ class Navbar extends React.Component { } getWidth() { - switch (this.state.mode) { + switch (this.props.app.state.navbarMode) { case "menu": return "w-1/5" case "category": @@ -147,9 +149,4 @@ class Navbar extends React.Component { return "w-3/4" } } - - setView(view) { - event.preventDefault(); - this.setState({ mode: view.mode, category: view.category, subcategory: view.subcategory, searchTerm: view.searchTerm, resultPath: view.resultPath }) - } } \ No newline at end of file From e257b9f90f2a129225e02553ebc737e0b9cf9350 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Johannes=20K=C3=B6ster?= Date: Wed, 9 Mar 2022 13:29:13 +0100 Subject: [PATCH 07/45] fixes and refactoring --- .../react/components/abstract_results.js | 2 +- playground/react/components/app.js | 6 +-- playground/react/components/breadcrumbs.js | 2 +- playground/react/components/category.js | 2 +- playground/react/components/content.js | 5 ++- playground/react/components/icon.js | 4 +- playground/react/components/menu.js | 2 +- playground/react/components/navbar.js | 23 +++++++++-- playground/react/components/result_info.js | 23 +++++------ .../{rulegraph.js => rule_graph.js} | 9 +++-- playground/react/components/rule_info.js | 40 +++++++++++++++++++ playground/react/index.html | 9 +++-- playground/react/rules.js | 20 ++++++++++ 13 files changed, 114 insertions(+), 33 deletions(-) rename playground/react/components/{rulegraph.js => rule_graph.js} (75%) create mode 100644 playground/react/components/rule_info.js create mode 100644 playground/react/rules.js diff --git a/playground/react/components/abstract_results.js b/playground/react/components/abstract_results.js index b69372ead..5abe08653 100644 --- a/playground/react/components/abstract_results.js +++ b/playground/react/components/abstract_results.js @@ -146,6 +146,6 @@ class AbstractResults extends React.Component { } showResultInfo(resultPath) { - this.props.setView({ mode: "resultinfo", resultPath: resultPath, category: this.getCategory(), subcategory: this.getSubcategory(), searchTerm: this.getSearchTerm() }); + this.props.setView({ navbarMode: "resultinfo", resultPath: resultPath, category: this.getCategory(), subcategory: this.getSubcategory(), searchTerm: this.getSearchTerm() }); } } \ No newline at end of file diff --git a/playground/react/components/app.js b/playground/react/components/app.js index 7f8ea7bbf..f00a390c3 100644 --- a/playground/react/components/app.js +++ b/playground/react/components/app.js @@ -11,15 +11,15 @@ class App extends React.Component { render() { return [ - e(Navbar, { app: this }), - e(ContentDisplay, { show: this.state.content }) + e(Navbar, { key: "navbar", app: this }), + e(ContentDisplay, { key: "content", app: this }) ]; } setView(view) { event.preventDefault(); this.setState({ - navbarMode: view.mode || this.state.navbarMode, + navbarMode: view.navbarMode || this.state.navbarMode, content: view.content || this.state.content, ruleinfo: view.ruleinfo, category: view.category, diff --git a/playground/react/components/breadcrumbs.js b/playground/react/components/breadcrumbs.js index 12a846bc6..49c5c6d7f 100644 --- a/playground/react/components/breadcrumbs.js +++ b/playground/react/components/breadcrumbs.js @@ -98,6 +98,6 @@ class Breadcrumbs extends React.Component { } showSearchResults() { - this.props.setView({ mode: "searchresults", searchTerm: this.state.searchTerm }) + this.props.setView({ navbarMode: "searchresults", searchTerm: this.state.searchTerm }) } } diff --git a/playground/react/components/category.js b/playground/react/components/category.js index 71121c0e6..fcf329f54 100644 --- a/playground/react/components/category.js +++ b/playground/react/components/category.js @@ -10,7 +10,7 @@ class Category extends AbstractMenu { } showSubcategory(subcategory) { - this.props.setView({ mode: "category", category: this.props.category, subcategory: subcategory }) + this.props.setView({ navbarMode: "category", category: this.props.category, subcategory: subcategory }) } getSubcategoryMenuitems() { diff --git a/playground/react/components/content.js b/playground/react/components/content.js index 87ef38a7f..1c9d80729 100644 --- a/playground/react/components/content.js +++ b/playground/react/components/content.js @@ -16,9 +16,10 @@ class ContentDisplay extends React.Component { } renderContent() { - switch (this.props.show) { + let setView = this.props.app.setView; + switch (this.props.app.state.content) { case "rulegraph": - return e(RuleGraph); + return e(RuleGraph, { setView: setView }); case "stats": return e(Stats) } diff --git a/playground/react/components/icon.js b/playground/react/components/icon.js index 707fa525c..4071f2739 100644 --- a/playground/react/components/icon.js +++ b/playground/react/components/icon.js @@ -32,11 +32,11 @@ class Icon extends React.Component { return e( "svg", { xmlns: "http://www.w3.org/2000/svg", className: `h-4 w-4 ${this.props.className}`, viewBox: "0 0 20 20", fill: "currentColor", }, - this.renderPath().map(function (item) { + this.renderPath().map(function (item, index) { return e( "path", - { fillRule: item.rule, clipRule: item.rule, d: item.path } + { fillRule: item.rule, clipRule: item.rule, d: item.path, key: index } ); }) ) diff --git a/playground/react/components/menu.js b/playground/react/components/menu.js index 25192915d..68e9c9b67 100644 --- a/playground/react/components/menu.js +++ b/playground/react/components/menu.js @@ -42,7 +42,7 @@ class Menu extends AbstractMenu { if (isSingleSubcategory(category)) { subcategory = Object.keys(categories[category])[0]; } - this.props.setView({ mode: "category", category: category, subcategory: subcategory }) + this.props.setView({ navbarMode: "category", category: category, subcategory: subcategory }) } getCategoryMenumitems() { diff --git a/playground/react/components/navbar.js b/playground/react/components/navbar.js index bc2428e80..93337d1a7 100644 --- a/playground/react/components/navbar.js +++ b/playground/react/components/navbar.js @@ -52,6 +52,8 @@ class Navbar extends React.Component { return e(SearchResults, { setView: setView, searchTerm: this.props.app.state.searchTerm }); case "resultinfo": return e(ResultInfo, { resultPath: this.props.app.state.resultPath }); + case "ruleinfo": + return e(RuleInfo, { rule: this.props.app.state.ruleinfo }); } } @@ -78,12 +80,25 @@ class Navbar extends React.Component { Breadcrumbs, { entries: [this.getMenuBreadcrumb(), this.getSearchResultsBreadcrumb()], setView: setView } ) + case "ruleinfo": + return e( + Breadcrumbs, + { entries: [this.getMenuBreadcrumb(), this.getRuleBreadcrumb(), this.getRuleinfoBreadcrumb()], setView: setView } + ) } } getMenuBreadcrumb() { let setView = this.props.app.setView; - return { name: "menu", icon: "home", func: function () { setView({ mode: "menu", category: undefined, subcategory: undefined }) } }; + return { name: "menu", icon: "home", func: function () { setView({ navbarMode: "menu", category: undefined, subcategory: undefined }) } }; + } + + getRuleBreadcrumb() { + return { name: "Rule", func: undefined } + } + + getRuleinfoBreadcrumb() { + return { name: this.props.app.state.ruleinfo, func: undefined } } getCategoryBreadcrumb() { @@ -102,7 +117,7 @@ class Navbar extends React.Component { name = "Results"; } let setView = this.props.app.setView; - return { name: name, func: function () { setView({ mode: "category", category: category, subcategory: subcategory }) } }; + return { name: name, func: function () { setView({ navbarMode: "category", category: category, subcategory: subcategory }) } }; } getSubcategoryBreadcrumb() { @@ -112,7 +127,7 @@ class Navbar extends React.Component { return undefined; } let setView = this.props.app.setView; - return { name: this.props.app.state.subcategory, func: function () { setView({ mode: "category", category: category, subcategory: subcategory }) } }; + return { name: this.props.app.state.subcategory, func: function () { setView({ navbarMode: "category", category: category, subcategory: subcategory }) } }; } getResultBreadcrumb() { @@ -130,7 +145,7 @@ class Navbar extends React.Component { let setView = this.props.app.setView; return { name: "Search results", func: function () { - setView({ mode: "searchresults", searchTerm: searchTerm }) + setView({ navbarMode: "searchresults", searchTerm: searchTerm }) } }; } diff --git a/playground/react/components/result_info.js b/playground/react/components/result_info.js index 8854643e0..4f8bc4473 100644 --- a/playground/react/components/result_info.js +++ b/playground/react/components/result_info.js @@ -24,11 +24,10 @@ class ResultInfo extends React.Component { return [ e( ListHeading, - { text: "Result" } + { text: "Result", key: "result" } ), e( - "li", - {}, + ListItem, e( "table", {}, @@ -70,11 +69,11 @@ class ResultInfo extends React.Component { return [ e( ListHeading, - { text: "Result" } + { text: "Result", key: "result" } ), e( - "li", - { className: "p-1" }, + ListItem, + { key: "path" }, this.props.resultPath ) ]; @@ -87,11 +86,12 @@ class ResultInfo extends React.Component { return [ e( ListHeading, - { text: "Description" } + { key: "caption-heading", text: "Description" } ), e( - "li", + ListItem, { + key: "caption", className: "p-1", dangerouslySetInnerHTML: { __html: caption } } @@ -106,11 +106,11 @@ class ResultInfo extends React.Component { return [ e( ListHeading, - { text: "Snakemake rule" } + { key: "rule-heading", text: "Snakemake rule" } ), e( ListItem, - {}, + { key: "rulename" }, this.getResult().job_properties.rule ) ] @@ -118,12 +118,11 @@ class ResultInfo extends React.Component { getParamsAndWildcards() { const jobProperties = this.getResult().job_properties; - console.log(jobProperties) if (jobProperties.params || jobProperties.wildcards) { let items = [ e( ListHeading, - { text: "Job parameters" } + { key: "params-heading", text: "Job parameters" } ), ]; if (jobProperties.wildcards) { diff --git a/playground/react/components/rulegraph.js b/playground/react/components/rule_graph.js similarity index 75% rename from playground/react/components/rulegraph.js rename to playground/react/components/rule_graph.js index 0d8c1768d..63ed76646 100644 --- a/playground/react/components/rulegraph.js +++ b/playground/react/components/rule_graph.js @@ -3,6 +3,7 @@ class RuleGraph extends React.Component { constructor(props) { super(props); + this.showRuleProperties = this.showRuleProperties.bind(this); } render() { @@ -24,8 +25,10 @@ class RuleGraph extends React.Component { }); } - - showRuleProperties() { - + showRuleProperties(rule) { + this.props.setView({ + navbarMode: "ruleinfo", + ruleinfo: rule + }); } } \ No newline at end of file diff --git a/playground/react/components/rule_info.js b/playground/react/components/rule_info.js new file mode 100644 index 000000000..5e3f60646 --- /dev/null +++ b/playground/react/components/rule_info.js @@ -0,0 +1,40 @@ +'use strict'; + +class RuleInfo extends React.Component { + constructor(props) { + super(props); + } + + render() { + let rule = rules[this.props.rule]; + return e( + "ol", + {}, + this.renderItems("Input", rule.input, {}, false), + this.renderItems("Output", rule.input), + this.renderItems("Software", rule.conda), + this.renderItems("Container", [rule.container]), + this.renderItems("Code", rule.code), + ) + } + + renderItems(heading, items, props = {}, margin = true) { + let headingProps = {}; + if (margin) { + headingProps = { className: "" } + } + return [ + e( + ListHeading, + { text: heading, ...headingProps } + ), + items.map(function (item) { + return e( + ListItem, + props, + item + ); + }) + ]; + } +} \ No newline at end of file diff --git a/playground/react/index.html b/playground/react/index.html index fd0c9706b..5060e0956 100644 --- a/playground/react/index.html +++ b/playground/react/index.html @@ -5,8 +5,9 @@ Snakemake Report @@ -27,6 +28,7 @@ + @@ -40,7 +42,8 @@ - + + diff --git a/playground/react/rules.js b/playground/react/rules.js new file mode 100644 index 000000000..4c6097bf7 --- /dev/null +++ b/playground/react/rules.js @@ -0,0 +1,20 @@ +var rules = { + "a": { + "input": [ + "x.txt", + "y.txt" + ], + "output": [ + "z.txt", + "y2.txt" + ], + "conda": [ + "bwa =0.74" + ], + "container": "docker://miniconda", + "code": [ + "codeblock1(1.4)", + "codeblock2(1.5)" + ] + } +} \ No newline at end of file From 1ee686f6a9ebcc182495574443ddac526dbae380 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Johannes=20K=C3=B6ster?= Date: Wed, 9 Mar 2022 14:09:56 +0100 Subject: [PATCH 08/45] image display --- .../react/components/abstract_results.js | 35 ++++++++++++++++++- playground/react/components/app.js | 13 +++---- playground/react/components/content.js | 5 +++ playground/react/components/result_info.js | 15 ++++++++ playground/react/results.js | 2 ++ 5 files changed, 63 insertions(+), 7 deletions(-) diff --git a/playground/react/components/abstract_results.js b/playground/react/components/abstract_results.js index 5abe08653..a2a6667d2 100644 --- a/playground/react/components/abstract_results.js +++ b/playground/react/components/abstract_results.js @@ -95,7 +95,7 @@ class AbstractResults extends React.Component { e( "div", { className: "inline-flex gap-1", role: "group" }, - _this.renderButton("eye", { href: entry.data_uri(), download: entry.name }), + _this.getViewButton(path, entry), _this.renderButton( "information-circle", { @@ -137,6 +137,35 @@ class AbstractResults extends React.Component { }) } + getViewButton(resultPath, entry) { + const mimeType = this.getResultMimeType(resultPath); + let setView = this.props.setView; + + let props = undefined; + + switch (mimeType) { + case "image/svg+xml": + case "image/png": + case "image/jpeg": + props = { + href: "#", + onClick: function () { + setView({ + content: "img", + contentPath: entry.data_uri() + }) + } + }; + break; + default: + props = { + href: entry.data_uri(), + download: entry.name + }; + } + return this.renderButton("eye", props); + } + renderButton(iconName, props) { return e( "a", @@ -148,4 +177,8 @@ class AbstractResults extends React.Component { showResultInfo(resultPath) { this.props.setView({ navbarMode: "resultinfo", resultPath: resultPath, category: this.getCategory(), subcategory: this.getSubcategory(), searchTerm: this.getSearchTerm() }); } + + getResultMimeType(resultPath) { + return results[resultPath].mime_type + } } \ No newline at end of file diff --git a/playground/react/components/app.js b/playground/react/components/app.js index f00a390c3..7fb5af454 100644 --- a/playground/react/components/app.js +++ b/playground/react/components/app.js @@ -5,7 +5,7 @@ class App extends React.Component { constructor(props) { super(props); - this.state = { navbarMode: "menu", content: "rulegraph", ruleinfo: undefined, category: undefined, subcategory: undefined, searchTerm: undefined, resultPath: undefined }; + this.state = { navbarMode: "menu", content: "rulegraph", ruleinfo: undefined, category: undefined, subcategory: undefined, searchTerm: undefined, resultPath: undefined, contentPath: undefined }; this.setView = this.setView.bind(this); } @@ -21,11 +21,12 @@ class App extends React.Component { this.setState({ navbarMode: view.navbarMode || this.state.navbarMode, content: view.content || this.state.content, - ruleinfo: view.ruleinfo, - category: view.category, - subcategory: view.subcategory, - searchTerm: view.searchTerm, - resultPath: view.resultPath + ruleinfo: view.ruleinfo || this.state.ruleinfo, + category: view.category || this.state.category, + subcategory: view.subcategory || this.state.subcategory, + searchTerm: view.searchTerm || this.state.searchTerm, + resultPath: view.resultPath || this.state.resultPath, + contentPath: view.contentPath || this.state.contentPath, }) } } diff --git a/playground/react/components/content.js b/playground/react/components/content.js index 1c9d80729..463f2a89d 100644 --- a/playground/react/components/content.js +++ b/playground/react/components/content.js @@ -22,6 +22,11 @@ class ContentDisplay extends React.Component { return e(RuleGraph, { setView: setView }); case "stats": return e(Stats) + case "img": + return e( + "img", + { src: this.props.app.state.contentPath } + ) } } } \ No newline at end of file diff --git a/playground/react/components/result_info.js b/playground/react/components/result_info.js index 4f8bc4473..6597dc72d 100644 --- a/playground/react/components/result_info.js +++ b/playground/react/components/result_info.js @@ -7,6 +7,7 @@ class ResultInfo extends React.Component { {}, this.getDescriptor(), this.getCaption(), + this.getSize(), this.getRule(), this.getParamsAndWildcards(), ) @@ -144,4 +145,18 @@ class ResultInfo extends React.Component { return []; } } + + getSize() { + return [ + e( + ListHeading, + { key: "size-heading", text: "Size" } + ), + e( + ListItem, + { key: "size" }, + this.getResult().size + ) + ]; + } } \ No newline at end of file diff --git a/playground/react/results.js b/playground/react/results.js index c547a295a..92b9042bb 100644 --- a/playground/react/results.js +++ b/playground/react/results.js @@ -62,6 +62,7 @@ var results = { filename: "fig1.svg", path: "fig1.svg", size: "28.3 kB", + mime_type: "image/svg+xml", caption: "

This is a caption with a link.

\n", job_properties: { rule: "a", @@ -78,6 +79,7 @@ var results = { filename: "testmodel.fig2.png", path: "testmodel.fig2.png", size: "9.1 kB", + mime_type: "image/png", caption: "

Some math \u2211ii2.

\n", job_properties: { rule: "b", From 3c81ff5a94a857ef74993ff111c1240b6906274b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Johannes=20K=C3=B6ster?= Date: Wed, 9 Mar 2022 14:15:16 +0100 Subject: [PATCH 09/45] html handling --- playground/react/components/abstract_results.js | 11 +++++++++++ playground/react/components/content.js | 5 +++++ 2 files changed, 16 insertions(+) diff --git a/playground/react/components/abstract_results.js b/playground/react/components/abstract_results.js index a2a6667d2..03b4e6168 100644 --- a/playground/react/components/abstract_results.js +++ b/playground/react/components/abstract_results.js @@ -157,6 +157,17 @@ class AbstractResults extends React.Component { } }; break; + case "text/html": + props = { + href: "#", + onClick: function () { + setView({ + content: "html", + contentPath: entry.data_uri() + }) + } + }; + break; default: props = { href: entry.data_uri(), diff --git a/playground/react/components/content.js b/playground/react/components/content.js index 463f2a89d..bd2605460 100644 --- a/playground/react/components/content.js +++ b/playground/react/components/content.js @@ -27,6 +27,11 @@ class ContentDisplay extends React.Component { "img", { src: this.props.app.state.contentPath } ) + case "html": + return e( + "iframe", + { src: this.props.add.state.contentPath, className: "w-screen h-screen" } + ) } } } \ No newline at end of file From f20ccd31aa618291bdd8e5c5a4783ce2f4ca2a58 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Johannes=20K=C3=B6ster?= Date: Wed, 9 Mar 2022 14:20:48 +0100 Subject: [PATCH 10/45] fixes --- playground/react/components/list_item.js | 2 +- playground/react/components/result_info.js | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/playground/react/components/list_item.js b/playground/react/components/list_item.js index 96748dfbe..cc377cf5b 100644 --- a/playground/react/components/list_item.js +++ b/playground/react/components/list_item.js @@ -8,7 +8,7 @@ class ListItem extends React.Component { render() { return e( "li", - { className: "p-1" }, + { className: "p-1", ...this.props }, this.props.children ); } diff --git a/playground/react/components/result_info.js b/playground/react/components/result_info.js index 6597dc72d..ffde0b5c3 100644 --- a/playground/react/components/result_info.js +++ b/playground/react/components/result_info.js @@ -83,7 +83,8 @@ class ResultInfo extends React.Component { getCaption() { const caption = this.getResult().caption; - if (caption !== undefined) { + console.log(caption) + if (caption) { return [ e( ListHeading, From 64a98550150a1b0ed106176c516e1270fe2bc81c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Johannes=20K=C3=B6ster?= Date: Wed, 9 Mar 2022 15:51:21 +0100 Subject: [PATCH 11/45] show/hide and papercut fixes --- playground/react/components/abstract_menu.js | 1 + playground/react/components/app.js | 3 +- playground/react/components/category.js | 2 +- playground/react/components/icon.js | 12 ++ playground/react/components/menu.js | 4 +- playground/react/components/navbar.js | 133 ++++++++++++++----- playground/react/components/result_info.js | 11 +- 7 files changed, 125 insertions(+), 41 deletions(-) diff --git a/playground/react/components/abstract_menu.js b/playground/react/components/abstract_menu.js index b215e4d0b..9a6cfa70f 100644 --- a/playground/react/components/abstract_menu.js +++ b/playground/react/components/abstract_menu.js @@ -9,6 +9,7 @@ class AbstractMenu extends React.Component { } getMenuItem(label, iconName, onClick) { + console.log(label, onClick); return e( "li", { key: label }, diff --git a/playground/react/components/app.js b/playground/react/components/app.js index 7fb5af454..b5bc0d8d4 100644 --- a/playground/react/components/app.js +++ b/playground/react/components/app.js @@ -5,7 +5,7 @@ class App extends React.Component { constructor(props) { super(props); - this.state = { navbarMode: "menu", content: "rulegraph", ruleinfo: undefined, category: undefined, subcategory: undefined, searchTerm: undefined, resultPath: undefined, contentPath: undefined }; + this.state = { hideNavbar: false, navbarMode: "menu", content: "rulegraph", ruleinfo: undefined, category: undefined, subcategory: undefined, searchTerm: undefined, resultPath: undefined, contentPath: undefined }; this.setView = this.setView.bind(this); } @@ -19,6 +19,7 @@ class App extends React.Component { setView(view) { event.preventDefault(); this.setState({ + hideNavbar: view.hideNavbar || this.hideNavbar, navbarMode: view.navbarMode || this.state.navbarMode, content: view.content || this.state.content, ruleinfo: view.ruleinfo || this.state.ruleinfo, diff --git a/playground/react/components/category.js b/playground/react/components/category.js index fcf329f54..3b99e633f 100644 --- a/playground/react/components/category.js +++ b/playground/react/components/category.js @@ -10,7 +10,7 @@ class Category extends AbstractMenu { } showSubcategory(subcategory) { - this.props.setView({ navbarMode: "category", category: this.props.category, subcategory: subcategory }) + this.props.setView({ navbarMode: "subcategory", category: this.props.category, subcategory: subcategory }) } getSubcategoryMenuitems() { diff --git a/playground/react/components/icon.js b/playground/react/components/icon.js index 4071f2739..dcb3086e9 100644 --- a/playground/react/components/icon.js +++ b/playground/react/components/icon.js @@ -3,9 +3,21 @@ class Icon extends React.Component { // paths are imported from https://heroicons.com paths = { + "menu": [ + { rule: "evenodd", path: "M3 5a1 1 0 011-1h12a1 1 0 110 2H4a1 1 0 01-1-1zM3 10a1 1 0 011-1h12a1 1 0 110 2H4a1 1 0 01-1-1zM3 15a1 1 0 011-1h12a1 1 0 110 2H4a1 1 0 01-1-1z" } + ], + "x": [ + { rule: "evenodd", path: "M4.293 4.293a1 1 0 011.414 0L10 8.586l4.293-4.293a1 1 0 111.414 1.414L11.414 10l4.293 4.293a1 1 0 01-1.414 1.414L10 11.414l-4.293 4.293a1 1 0 01-1.414-1.414L8.586 10 4.293 5.707a1 1 0 010-1.414z" } + ], "arrow-down": [ { rule: "evenodd", path: "M16.707 10.293a1 1 0 010 1.414l-6 6a1 1 0 01-1.414 0l-6-6a1 1 0 111.414-1.414L9 14.586V3a1 1 0 012 0v11.586l4.293-4.293a1 1 0 011.414 0z" } ], + "arrow-circle-left": [ + { rule: "evenodd", path: "M10 18a8 8 0 100-16 8 8 0 000 16zm.707-10.293a1 1 0 00-1.414-1.414l-3 3a1 1 0 000 1.414l3 3a1 1 0 001.414-1.414L9.414 11H13a1 1 0 100-2H9.414l1.293-1.293z" } + ], + "arrow-circle-right": [ + { rule: "evenodd", path: "M10 18a8 8 0 100-16 8 8 0 000 16zm3.707-8.707l-3-3a1 1 0 00-1.414 1.414L10.586 9H7a1 1 0 100 2h3.586l-1.293 1.293a1 1 0 101.414 1.414l3-3a1 1 0 000-1.414z" } + ], "information-circle": [ { rule: "evenodd", path: "M18 10a8 8 0 11-16 0 8 8 0 0116 0zm-7-4a1 1 0 11-2 0 1 1 0 012 0zM9 9a1 1 0 000 2v3a1 1 0 001 1h1a1 1 0 100-2v-3a1 1 0 00-1-1H9z" } ], diff --git a/playground/react/components/menu.js b/playground/react/components/menu.js index 68e9c9b67..54572770b 100644 --- a/playground/react/components/menu.js +++ b/playground/react/components/menu.js @@ -39,10 +39,12 @@ class Menu extends AbstractMenu { showCategory(category) { let subcategory = undefined; + let mode = "category"; if (isSingleSubcategory(category)) { subcategory = Object.keys(categories[category])[0]; + mode = "subcategory"; } - this.props.setView({ navbarMode: "category", category: category, subcategory: subcategory }) + this.props.setView({ navbarMode: mode, category: category, subcategory: subcategory }) } getCategoryMenumitems() { diff --git a/playground/react/components/navbar.js b/playground/react/components/navbar.js index 93337d1a7..8079c3e78 100644 --- a/playground/react/components/navbar.js +++ b/playground/react/components/navbar.js @@ -7,34 +7,82 @@ class Navbar extends React.Component { } render() { - return e( - "nav", - { className: `fixed z-50 transition-all ${this.getWidth()} min-w-fit bg-slate-900/70 backdrop-blur-sm text-white text-sm h-screen overflow-y-auto` }, + let translateNavbar = ""; + let translateShowButton = "-translate-x-full" + if (this.props.app.state.hideNavbar) { + translateNavbar = "-translate-x-full"; + translateShowButton = "" + } + return [ e( - "h1", - { className: "sticky bg-blur bg-white opacity-80 text-slate-700 text-l tracking-wide px-3 py-1 mb-1 flex items-center" }, - e( - "img", - { src: "logo.svg", className: "h-4" } - ), + "div", + { className: `fixed z-50 p-3 transition-translate ${translateShowButton}` }, + this.getShowButton() + ), + e( + "nav", + { className: `fixed z-50 transition-all ${translateNavbar} ${this.getWidth()} min-w-fit text-white text-sm bg-slate-900/70 backdrop-blur-sm h-screen overflow-y-auto` }, e( - "span", - { className: "font-bold mx-1" }, - "Snakemake" + "h1", + { className: "sticky bg-blur bg-white opacity-80 text-slate-700 text-l tracking-wide px-3 py-1 mb-1 flex items-center" }, + e( + "img", + { src: "logo.svg", className: "h-4" } + ), + e( + "span", + { className: "font-bold mx-1" }, + "Snakemake" + ), + e( + "span", + { className: "grow mr-5" }, + "Report" + ), + this.getHideButton() ), + this.renderBreadcrumbs(), e( - "span", - {}, - "Report" - ), - ), - this.renderBreadcrumbs(), + "div", + { className: "p-3" }, + this.renderContent() + ) + ) + ]; + } + + getHideButton() { + let setView = this.props.app.setView; + return e( + "a", + { + type: "button", + className: "bg-transparent hover:text-emerald-500", + href: "#", + onClick: () => setView({ hideNavbar: true }) + }, e( - "div", - { className: "p-3" }, - this.renderContent() + Icon, + { iconName: "x" } ) - ); + ) + } + + getShowButton() { + let setView = this.props.app.setView; + return e( + "a", + { + type: "button", + href: "#", + className: "bg-transparent hover:text-emerald-500", + onClick: () => setView({ hideNavbar: false }) + }, + e( + Icon, + { iconName: "menu" } + ) + ) } renderContent() { @@ -43,15 +91,13 @@ class Navbar extends React.Component { case "menu": return e(Menu, { setView: setView, app: this.props.app }); case "category": - if (this.props.app.state.subcategory !== undefined) { - return e(Subcategory, { setView: setView, category: this.props.app.state.category, subcategory: this.props.app.state.subcategory }); - } else { - return e(Category, { setView: setView, category: this.props.app.state.category }); - } + return e(Category, { setView: setView, category: this.props.app.state.category }); + case "subcategory": + return e(Subcategory, { setView: setView, category: this.props.app.state.category, subcategory: this.props.app.state.subcategory }); case "searchresults": return e(SearchResults, { setView: setView, searchTerm: this.props.app.state.searchTerm }); case "resultinfo": - return e(ResultInfo, { resultPath: this.props.app.state.resultPath }); + return e(ResultInfo, { resultPath: this.props.app.state.resultPath, setView: setView }); case "ruleinfo": return e(RuleInfo, { rule: this.props.app.state.ruleinfo }); } @@ -66,6 +112,11 @@ class Navbar extends React.Component { { entries: [this.getMenuBreadcrumb()], setView: setView } ); case "category": + return e( + Breadcrumbs, + { entries: [this.getMenuBreadcrumb(), this.getResultBreadcrumb(), this.getCategoryBreadcrumb()], setView: setView } + ); + case "subcategory": return e( Breadcrumbs, { entries: [this.getMenuBreadcrumb(), this.getResultBreadcrumb(), this.getCategoryBreadcrumb(), this.getSubcategoryBreadcrumb()], setView: setView } @@ -81,10 +132,17 @@ class Navbar extends React.Component { { entries: [this.getMenuBreadcrumb(), this.getSearchResultsBreadcrumb()], setView: setView } ) case "ruleinfo": - return e( - Breadcrumbs, - { entries: [this.getMenuBreadcrumb(), this.getRuleBreadcrumb(), this.getRuleinfoBreadcrumb()], setView: setView } - ) + if (this.props.app.state.resultPath) { + return e( + Breadcrumbs, + { entries: [this.getMenuBreadcrumb(), this.getResultBreadcrumb(), this.getCategoryBreadcrumb(), this.getSubcategoryBreadcrumb(), this.getSearchResultsBreadcrumb(), this.getResultinfoBreadcrumb(), this.getRuleBreadcrumb(), this.getRuleinfoBreadcrumb()], setView: setView } + ) + } else { + return e( + Breadcrumbs, + { entries: [this.getMenuBreadcrumb(), this.getRuleBreadcrumb(), this.getRuleinfoBreadcrumb()], setView: setView } + ) + } } } @@ -107,8 +165,10 @@ class Navbar extends React.Component { return undefined; } let subcategory = undefined; + let mode = "category"; if (isSingleSubcategory(category)) { subcategory = this.props.app.state.subcategory; + mode = "subcategory"; } let _this = this; @@ -117,7 +177,7 @@ class Navbar extends React.Component { name = "Results"; } let setView = this.props.app.setView; - return { name: name, func: function () { setView({ navbarMode: "category", category: category, subcategory: subcategory }) } }; + return { name: name, func: function () { setView({ navbarMode: mode, category: category, subcategory: subcategory }) } }; } getSubcategoryBreadcrumb() { @@ -127,7 +187,7 @@ class Navbar extends React.Component { return undefined; } let setView = this.props.app.setView; - return { name: this.props.app.state.subcategory, func: function () { setView({ navbarMode: "category", category: category, subcategory: subcategory }) } }; + return { name: this.props.app.state.subcategory, func: function () { setView({ navbarMode: "subcategory", category: category, subcategory: subcategory }) } }; } getResultBreadcrumb() { @@ -151,7 +211,10 @@ class Navbar extends React.Component { } getResultinfoBreadcrumb() { - return { name: "resultinfo", icon: "eye", func: undefined }; + let setView = this.props.app.setView; + return { + name: "resultinfo", icon: "eye", func: function () { setView({ navbarMode: "resultinfo" }) } + }; } getWidth() { diff --git a/playground/react/components/result_info.js b/playground/react/components/result_info.js index ffde0b5c3..c9abef127 100644 --- a/playground/react/components/result_info.js +++ b/playground/react/components/result_info.js @@ -83,7 +83,6 @@ class ResultInfo extends React.Component { getCaption() { const caption = this.getResult().caption; - console.log(caption) if (caption) { return [ e( @@ -105,6 +104,8 @@ class ResultInfo extends React.Component { } getRule() { + const setView = this.props.setView; + const rule = this.getResult().job_properties.rule; return [ e( ListHeading, @@ -112,8 +113,12 @@ class ResultInfo extends React.Component { ), e( ListItem, - { key: "rulename" }, - this.getResult().job_properties.rule + { key: "rulename", className: "" }, + e( + "a", + { type: "button", href: "#", className: "p-1 transition-all hover:text-emerald-500 rounded hover:bg-slate-800", onClick: () => setView({ navbarMode: "ruleinfo", ruleinfo: rule }) }, + rule + ) ) ] } From 6c0a2d13a6d6c5bb90d911c4a6862efab1c35e44 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Johannes=20K=C3=B6ster?= Date: Wed, 9 Mar 2022 18:02:38 +0100 Subject: [PATCH 12/45] move new report into module --- playground/react/index.html | 54 ------- setup.py | 2 +- snakemake/report/__init__.py | 51 ++++--- snakemake/report/data/__init__.py | 0 snakemake/report/data/categories.py | 8 + snakemake/report/data/results.py | 18 +++ snakemake/report/data/rulegraph.py | 116 ++++++++++++++ snakemake/report/data/rules.py | 2 + snakemake/report/data/runtimes.py | 17 +++ snakemake/report/data/timeline.py | 17 +++ .../report/template}/categories.js | 0 .../template}/components/abstract_menu.js | 0 .../template}/components/abstract_results.js | 6 +- .../report/template}/components/app.js | 0 .../template}/components/breadcrumbs.js | 0 .../report/template}/components/category.js | 0 .../report/template}/components/common.js | 0 .../report/template}/components/content.js | 0 .../report/template}/components/icon.js | 0 .../template}/components/list_heading.js | 0 .../report/template}/components/list_item.js | 0 .../report/template}/components/menu.js | 0 .../report/template}/components/navbar.js | 0 .../template}/components/result_info.js | 0 .../report/template}/components/rule_graph.js | 0 .../report/template}/components/rule_info.js | 0 .../template}/components/search_results.js | 0 .../report/template}/components/stats.js | 0 .../template}/components/subcategory.js | 0 snakemake/report/template/index.html.jinja2 | 80 ++++++++++ .../report/template}/logo.svg | 0 .../report/template}/results.js | 0 .../report/template}/rulegraph.js | 0 snakemake/report/template/rulegraph_spec.js | 142 ++++++++++++++++++ .../report/template}/rules.js | 0 .../report/template}/runtimes.js | 0 snakemake/report/template/style.css | 4 + .../report/template}/timeline.js | 0 38 files changed, 440 insertions(+), 77 deletions(-) delete mode 100644 playground/react/index.html create mode 100644 snakemake/report/data/__init__.py create mode 100644 snakemake/report/data/categories.py create mode 100644 snakemake/report/data/results.py create mode 100644 snakemake/report/data/rulegraph.py create mode 100644 snakemake/report/data/rules.py create mode 100644 snakemake/report/data/runtimes.py create mode 100644 snakemake/report/data/timeline.py rename {playground/react => snakemake/report/template}/categories.js (100%) rename {playground/react => snakemake/report/template}/components/abstract_menu.js (100%) rename {playground/react => snakemake/report/template}/components/abstract_results.js (96%) rename {playground/react => snakemake/report/template}/components/app.js (100%) rename {playground/react => snakemake/report/template}/components/breadcrumbs.js (100%) rename {playground/react => snakemake/report/template}/components/category.js (100%) rename {playground/react => snakemake/report/template}/components/common.js (100%) rename {playground/react => snakemake/report/template}/components/content.js (100%) rename {playground/react => snakemake/report/template}/components/icon.js (100%) rename {playground/react => snakemake/report/template}/components/list_heading.js (100%) rename {playground/react => snakemake/report/template}/components/list_item.js (100%) rename {playground/react => snakemake/report/template}/components/menu.js (100%) rename {playground/react => snakemake/report/template}/components/navbar.js (100%) rename {playground/react => snakemake/report/template}/components/result_info.js (100%) rename {playground/react => snakemake/report/template}/components/rule_graph.js (100%) rename {playground/react => snakemake/report/template}/components/rule_info.js (100%) rename {playground/react => snakemake/report/template}/components/search_results.js (100%) rename {playground/react => snakemake/report/template}/components/stats.js (100%) rename {playground/react => snakemake/report/template}/components/subcategory.js (100%) create mode 100644 snakemake/report/template/index.html.jinja2 rename {playground/react => snakemake/report/template}/logo.svg (100%) rename {playground/react => snakemake/report/template}/results.js (100%) rename {playground/react => snakemake/report/template}/rulegraph.js (100%) create mode 100644 snakemake/report/template/rulegraph_spec.js rename {playground/react => snakemake/report/template}/rules.js (100%) rename {playground/react => snakemake/report/template}/runtimes.js (100%) create mode 100644 snakemake/report/template/style.css rename {playground/react => snakemake/report/template}/timeline.js (100%) diff --git a/playground/react/index.html b/playground/react/index.html deleted file mode 100644 index 5060e0956..000000000 --- a/playground/react/index.html +++ /dev/null @@ -1,54 +0,0 @@ - - - - - - Snakemake Report - - - - - -
-
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - \ No newline at end of file diff --git a/setup.py b/setup.py index 46ebfafbc..8b1181cf9 100644 --- a/setup.py +++ b/setup.py @@ -56,7 +56,7 @@ "snakemake-bash-completion = snakemake:bash_completion", ] }, - package_data={"": ["*.css", "*.sh", "*.html", "*.jinja2"]}, + package_data={"": ["*.css", "*.sh", "*.html", "*.jinja2", "*.js", "*.svg"]}, install_requires=[ "wrapt", "requests", diff --git a/snakemake/report/__init__.py b/snakemake/report/__init__.py index 38adf1f1e..72d8bf389 100644 --- a/snakemake/report/__init__.py +++ b/snakemake/report/__init__.py @@ -46,6 +46,7 @@ from snakemake import __version__ from snakemake.common import is_local_file, num_if_possible, lazy_property from snakemake import logging +from snakemake.report import data class EmbeddedMixin(object): @@ -599,6 +600,7 @@ def encode_node(node): def rulegraph_spec(dag): # get toposorting, and keep only one job of each rule per level representatives = dict() + def get_representatives(level): unique = dict() for job in level: @@ -608,16 +610,13 @@ def get_representatives(level): representatives[job] = job unique[job.rule.name] = job return sorted(unique.values(), key=lambda job: job.rule.name) + toposorted = [get_representatives(level) for level in dag.toposorted()] - jobs = [ - job for level in toposorted - for job in level - ] + jobs = [job for level in toposorted for job in level] nodes = [ - {"rule": job.rule.name, "fx": 10, "fy": i * 50} - for i, job in enumerate(jobs) + {"rule": job.rule.name, "fx": 10, "fy": i * 50} for i, job in enumerate(jobs) ] idx = {job: i for i, job in enumerate(jobs)} @@ -638,7 +637,15 @@ def get_links(direct: bool): xmax = 100 ymax = max(node["fy"] for node in nodes) - return {"nodes": nodes, "links": list(get_links(direct=False)), "links_direct": list(get_links(direct=True))}, xmax, ymax + return ( + { + "nodes": nodes, + "links": list(get_links(direct=False)), + "links_direct": list(get_links(direct=True)), + }, + xmax, + ymax, + ) def get_resource_as_string(path_or_uri): @@ -678,7 +685,7 @@ def auto_report(dag, path, stylesheet=None): logger.info("Creating report...") env = Environment( - loader=PackageLoader("snakemake", "report"), + loader=PackageLoader("snakemake", "report", "template"), trim_blocks=True, lstrip_blocks=True, ) @@ -933,27 +940,33 @@ class Snakemake: "Python package pygments must be installed to create reports." ) - template = env.get_template("report.html.jinja2") + results = data.results.render_results(results) + categories = data.categories.render_categories(results) + rulegraph = data.rulegraph.render_rulegraph( + rulegraph["nodes"], rulegraph["links"], rulegraph["links_direct"] + ) + rules = data.rules.render_rules(rules.values()) + runtimes = data.runtimes.render_runtimes(runtimes) + timeline = data.timeline.render_timeline(timeline) + + template = env.get_template("index.html.jinja2") logger.info("Downloading resources and rendering HTML.") rendered = template.render( results=results, - results_size=results_size, - configfiles=configfiles, - text=text, - rulegraph_nodes=rulegraph["nodes"], - rulegraph_links=rulegraph["links"], - rulegraph_links_direct=rulegraph["links_direct"], - logo=data_uri_from_file(Path(__file__).parent / "logo.svg"), + categories=categories, + rulegraph=rulegraph, + rules=rules, runtimes=runtimes, timeline=timeline, - rules=[rec for recs in rules.values() for rec in recs], - version=__version__.split("+")[0], + pygments_css=HtmlFormatter(style="trac").get_style_defs(".source"), + custom_stylesheet=custom_stylesheet, + logo=data_uri_from_file(Path(__file__).parent / "logo.svg"), now=now, pygments_css=HtmlFormatter(style="trac").get_style_defs(".source"), custom_stylesheet=custom_stylesheet, - mode_embedded=mode_embedded, + version=__version__.split("+")[0], ) # TODO look into supporting .WARC format, also see (https://webrecorder.io) diff --git a/snakemake/report/data/__init__.py b/snakemake/report/data/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/snakemake/report/data/categories.py b/snakemake/report/data/categories.py new file mode 100644 index 000000000..0e7edaf58 --- /dev/null +++ b/snakemake/report/data/categories.py @@ -0,0 +1,8 @@ +def render_categories(results): + return { + cat.name: { + subcat.name: [res.path for res in catresults] + for subcat, catresults in subcats + } + for cat, subcats in results + } diff --git a/snakemake/report/data/results.py b/snakemake/report/data/results.py new file mode 100644 index 000000000..bf6bb3003 --- /dev/null +++ b/snakemake/report/data/results.py @@ -0,0 +1,18 @@ +def render_results(results): + return { + res.path: { + "name": res.name, + "filename": res.filename, + "size": res.size, + "caption": res.caption, + "job_properties": { + "rule": res.rule, + "wildcards": res.wildcards, + "params": res.params, + }, + "data_uri": res.data_uri, + } + for cat, subcats in results.items() + for subcat, catresults in subcats + for res in catresults + } diff --git a/snakemake/report/data/rulegraph.py b/snakemake/report/data/rulegraph.py new file mode 100644 index 000000000..98371a73a --- /dev/null +++ b/snakemake/report/data/rulegraph.py @@ -0,0 +1,116 @@ +def render_rulegraph(nodes, links, links_direct): + return { + "$schema": "https://vega.github.io/schema/vega/v5.json", + "padding": 0, + "signals": [ + {"name": "cx", "update": "width / 2"}, + {"name": "cy", "update": "height / 2"}, + ], + "data": [ + {"name": "node-data", "values": nodes}, + {"name": "link-data", "values": links}, + {"name": "link-data-direct", "values": links_direct}, + ], + "scales": [ + { + "name": "color", + "type": "ordinal", + "range": {"scheme": "category20c"}, + }, + {"name": "x", "type": "linear"}, + {"name": "y", "type": "linear"}, + ], + "marks": [ + { + "name": "nodes", + "type": "symbol", + "zindex": 1, + "from": {"data": "node-data"}, + "encode": { + "enter": { + "fill": {"scale": "color", "field": "rule"}, + "x": {"field": "fx", "scale": "x"}, + "y": {"field": "fy", "scale": "y"}, + "tooltip": {"value": "Click to show rule details."}, + }, + "update": {"size": {"value": 70}}, + "hover": {"size": {"value": 140}}, + }, + "transform": [ + { + "type": "force", + "iterations": 1, + "static": true, + "forces": [{"force": "link", "links": "link-data"}], + }, + { + "type": "force", + "iterations": 1, + "static": true, + "forces": [{"force": "link", "links": "link-data-direct"}], + }, + ], + }, + { + "name": "labels", + "type": "text", + "zindex": 2, + "from": {"data": "node-data"}, + "encode": { + "enter": { + "fill": {"value": "black"}, + "fontWeight": {"value": "normal"}, + "text": {"field": "rule"}, + "x": {"field": "fx", "scale": "x"}, + "y": {"field": "fy", "scale": "y"}, + "dx": {"value": -5}, + "dy": {"value": -5}, + "align": {"value": "right"}, + } + }, + }, + { + "type": "path", + "from": {"data": "link-data-direct"}, + "interactive": false, + "encode": { + "update": { + "stroke": {"value": "#ccc"}, + "strokeWidth": {"value": 1.0}, + } + }, + "transform": [ + { + "type": "linkpath", + "shape": "diagonal", + "sourceX": "datum.source.x", + "sourceY": "datum.source.y", + "targetX": "datum.target.x", + "targetY": "datum.target.y", + } + ], + }, + { + "type": "path", + "from": {"data": "link-data"}, + "interactive": false, + "encode": { + "update": { + "stroke": {"value": "#ccc"}, + "strokeWidth": {"value": 1.0}, + } + }, + "transform": [ + { + "type": "linkpath", + "shape": "curve", + "orient": "horizontal", + "sourceX": "datum.source.x", + "sourceY": "datum.source.y", + "targetX": "datum.target.x", + "targetY": "datum.target.y", + } + ], + }, + ], + } diff --git a/snakemake/report/data/rules.py b/snakemake/report/data/rules.py new file mode 100644 index 000000000..478c54933 --- /dev/null +++ b/snakemake/report/data/rules.py @@ -0,0 +1,2 @@ +def render_rules(rules): + return {} # TODO diff --git a/snakemake/report/data/runtimes.py b/snakemake/report/data/runtimes.py new file mode 100644 index 000000000..216162457 --- /dev/null +++ b/snakemake/report/data/runtimes.py @@ -0,0 +1,17 @@ +def render_runtimes(runtimes): + return { + "$schema": "https://vega.github.io/schema/vega-lite/v3.json", + "description": "Runtimes of jobs.", + "data": {"values": runtimes}, + "mark": "point", + "encoding": { + "x": { + "field": "runtime", + "type": "quantitative", + "axis": {"title": "runtime [s]", "labelAngle": -90}, + "scale": {"type": "log"}, + }, + "y": {"field": "rule", "type": "nominal"}, + "color": {"value": "#007bff"}, + }, + } diff --git a/snakemake/report/data/timeline.py b/snakemake/report/data/timeline.py new file mode 100644 index 000000000..b09d1ed30 --- /dev/null +++ b/snakemake/report/data/timeline.py @@ -0,0 +1,17 @@ +def render_timeline(timeline): + return { + "$schema": "https://vega.github.io/schema/vega-lite/v3.json", + "description": "Timeline of jobs.", + "data": {"values": timeline}, + "mark": "point", + "encoding": { + "x": { + "field": "endtime", + "type": "temporal", + "timeUnit": "yearmonthdatehoursminutes", + "axis": {"labelAngle": -90, "title": "creation date"}, + }, + "y": {"field": "rule", "type": "nominal"}, + "color": {"value": "#007bff"}, + }, + } diff --git a/playground/react/categories.js b/snakemake/report/template/categories.js similarity index 100% rename from playground/react/categories.js rename to snakemake/report/template/categories.js diff --git a/playground/react/components/abstract_menu.js b/snakemake/report/template/components/abstract_menu.js similarity index 100% rename from playground/react/components/abstract_menu.js rename to snakemake/report/template/components/abstract_menu.js diff --git a/playground/react/components/abstract_results.js b/snakemake/report/template/components/abstract_results.js similarity index 96% rename from playground/react/components/abstract_results.js rename to snakemake/report/template/components/abstract_results.js index 03b4e6168..7747f96c3 100644 --- a/playground/react/components/abstract_results.js +++ b/snakemake/report/template/components/abstract_results.js @@ -152,7 +152,7 @@ class AbstractResults extends React.Component { onClick: function () { setView({ content: "img", - contentPath: entry.data_uri() + contentPath: entry.data_uri }) } }; @@ -163,14 +163,14 @@ class AbstractResults extends React.Component { onClick: function () { setView({ content: "html", - contentPath: entry.data_uri() + contentPath: entry.data_uri }) } }; break; default: props = { - href: entry.data_uri(), + href: entry.data_uri, download: entry.name }; } diff --git a/playground/react/components/app.js b/snakemake/report/template/components/app.js similarity index 100% rename from playground/react/components/app.js rename to snakemake/report/template/components/app.js diff --git a/playground/react/components/breadcrumbs.js b/snakemake/report/template/components/breadcrumbs.js similarity index 100% rename from playground/react/components/breadcrumbs.js rename to snakemake/report/template/components/breadcrumbs.js diff --git a/playground/react/components/category.js b/snakemake/report/template/components/category.js similarity index 100% rename from playground/react/components/category.js rename to snakemake/report/template/components/category.js diff --git a/playground/react/components/common.js b/snakemake/report/template/components/common.js similarity index 100% rename from playground/react/components/common.js rename to snakemake/report/template/components/common.js diff --git a/playground/react/components/content.js b/snakemake/report/template/components/content.js similarity index 100% rename from playground/react/components/content.js rename to snakemake/report/template/components/content.js diff --git a/playground/react/components/icon.js b/snakemake/report/template/components/icon.js similarity index 100% rename from playground/react/components/icon.js rename to snakemake/report/template/components/icon.js diff --git a/playground/react/components/list_heading.js b/snakemake/report/template/components/list_heading.js similarity index 100% rename from playground/react/components/list_heading.js rename to snakemake/report/template/components/list_heading.js diff --git a/playground/react/components/list_item.js b/snakemake/report/template/components/list_item.js similarity index 100% rename from playground/react/components/list_item.js rename to snakemake/report/template/components/list_item.js diff --git a/playground/react/components/menu.js b/snakemake/report/template/components/menu.js similarity index 100% rename from playground/react/components/menu.js rename to snakemake/report/template/components/menu.js diff --git a/playground/react/components/navbar.js b/snakemake/report/template/components/navbar.js similarity index 100% rename from playground/react/components/navbar.js rename to snakemake/report/template/components/navbar.js diff --git a/playground/react/components/result_info.js b/snakemake/report/template/components/result_info.js similarity index 100% rename from playground/react/components/result_info.js rename to snakemake/report/template/components/result_info.js diff --git a/playground/react/components/rule_graph.js b/snakemake/report/template/components/rule_graph.js similarity index 100% rename from playground/react/components/rule_graph.js rename to snakemake/report/template/components/rule_graph.js diff --git a/playground/react/components/rule_info.js b/snakemake/report/template/components/rule_info.js similarity index 100% rename from playground/react/components/rule_info.js rename to snakemake/report/template/components/rule_info.js diff --git a/playground/react/components/search_results.js b/snakemake/report/template/components/search_results.js similarity index 100% rename from playground/react/components/search_results.js rename to snakemake/report/template/components/search_results.js diff --git a/playground/react/components/stats.js b/snakemake/report/template/components/stats.js similarity index 100% rename from playground/react/components/stats.js rename to snakemake/report/template/components/stats.js diff --git a/playground/react/components/subcategory.js b/snakemake/report/template/components/subcategory.js similarity index 100% rename from playground/react/components/subcategory.js rename to snakemake/report/template/components/subcategory.js diff --git a/snakemake/report/template/index.html.jinja2 b/snakemake/report/template/index.html.jinja2 new file mode 100644 index 000000000..334f44742 --- /dev/null +++ b/snakemake/report/template/index.html.jinja2 @@ -0,0 +1,80 @@ + + + + + + + + + + Snakemake Report + + + + + + {% if custom_stylesheet is not none %} + + {% endif %} + + + + +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/playground/react/logo.svg b/snakemake/report/template/logo.svg similarity index 100% rename from playground/react/logo.svg rename to snakemake/report/template/logo.svg diff --git a/playground/react/results.js b/snakemake/report/template/results.js similarity index 100% rename from playground/react/results.js rename to snakemake/report/template/results.js diff --git a/playground/react/rulegraph.js b/snakemake/report/template/rulegraph.js similarity index 100% rename from playground/react/rulegraph.js rename to snakemake/report/template/rulegraph.js diff --git a/snakemake/report/template/rulegraph_spec.js b/snakemake/report/template/rulegraph_spec.js new file mode 100644 index 000000000..fd694a608 --- /dev/null +++ b/snakemake/report/template/rulegraph_spec.js @@ -0,0 +1,142 @@ +var rulegraph_spec = { + "$schema": "https://vega.github.io/schema/vega/v5.json", + "padding": 0, + + "signals": [ + { "name": "cx", "update": "width / 2" }, + { "name": "cy", "update": "height / 2" } + ], + + "data": [ + { + "name": "node-data", + "values": {{ rulegraph_nodes }} + }, +{ + "name": "link-data", + "values": { { rulegraph_links } } +}, +{ + "name": "link-data-direct", + "values": { { rulegraph_links_direct } } +} + ], + +"scales": [ + { + "name": "color", + "type": "ordinal", + "range": { "scheme": "category20c" } + }, + { + "name": "x", + "type": "linear" + }, + { + "name": "y", + "type": "linear" + } +], + + "marks": [ + { + "name": "nodes", + "type": "symbol", + "zindex": 1, + "from": { "data": "node-data" }, + "encode": { + "enter": { + "fill": { "scale": "color", "field": "rule" }, + "x": { "field": "fx", "scale": "x" }, + "y": { "field": "fy", "scale": "y" }, + "tooltip": { "value": "Click to show rule details." } + }, + "update": { + "size": { "value": 70 } + }, + "hover": { + "size": { "value": 140 } + } + }, + + "transform": [ + { + "type": "force", + "iterations": 1, + "static": true, + "forces": [ + { + "force": "link", + "links": "link-data" + } + ] + }, + { + "type": "force", + "iterations": 1, + "static": true, + "forces": [ + { + "force": "link", + "links": "link-data-direct" + } + ] + } + ] + }, + { + "name": "labels", + "type": "text", + "zindex": 2, + "from": { "data": "node-data" }, + "encode": { + "enter": { + "fill": { "value": "black" }, + "fontWeight": { "value": "normal" }, + "text": { "field": "rule" }, + "x": { "field": "fx", "scale": "x" }, + "y": { "field": "fy", "scale": "y" }, + "dx": { "value": -5 }, + "dy": { "value": -5 }, + "align": { "value": "right" } + } + } + }, + { + "type": "path", + "from": { "data": "link-data-direct" }, + "interactive": false, + "encode": { + "update": { + "stroke": { "value": "#ccc" }, + "strokeWidth": { "value": 1.0 } + } + }, + "transform": [ + { + "type": "linkpath", "shape": "diagonal", + "sourceX": "datum.source.x", "sourceY": "datum.source.y", + "targetX": "datum.target.x", "targetY": "datum.target.y" + } + ] + }, + { + "type": "path", + "from": { "data": "link-data" }, + "interactive": false, + "encode": { + "update": { + "stroke": { "value": "#ccc" }, + "strokeWidth": { "value": 1.0 } + } + }, + "transform": [ + { + "type": "linkpath", "shape": "curve", "orient": "horizontal", + "sourceX": "datum.source.x", "sourceY": "datum.source.y", + "targetX": "datum.target.x", "targetY": "datum.target.y" + } + ] + } + ] + }; \ No newline at end of file diff --git a/playground/react/rules.js b/snakemake/report/template/rules.js similarity index 100% rename from playground/react/rules.js rename to snakemake/report/template/rules.js diff --git a/playground/react/runtimes.js b/snakemake/report/template/runtimes.js similarity index 100% rename from playground/react/runtimes.js rename to snakemake/report/template/runtimes.js diff --git a/snakemake/report/template/style.css b/snakemake/report/template/style.css new file mode 100644 index 000000000..f4146fa47 --- /dev/null +++ b/snakemake/report/template/style.css @@ -0,0 +1,4 @@ +.vega-embed summary { + z-index: 49 !important; + /* ensure that menu is always below navbar*/ +} \ No newline at end of file diff --git a/playground/react/timeline.js b/snakemake/report/template/timeline.js similarity index 100% rename from playground/react/timeline.js rename to snakemake/report/template/timeline.js From 4ee49b1fe99c3a7c1261f77188de194c823e05d2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Johannes=20K=C3=B6ster?= Date: Thu, 10 Mar 2022 11:31:49 +0100 Subject: [PATCH 13/45] fixes --- setup.py | 2 + snakemake/report/__init__.py | 34 +-- snakemake/report/data/__init__.py | 6 + snakemake/report/data/categories.py | 19 +- snakemake/report/data/results.py | 38 +-- snakemake/report/data/rulegraph.py | 223 +++++++++--------- snakemake/report/data/rules.py | 17 +- snakemake/report/data/runtimes.py | 35 +-- snakemake/report/data/timeline.py | 35 +-- snakemake/report/template/__init__.py | 0 .../report/template/components/navbar.js | 6 +- .../report/template/components/result_info.js | 2 +- .../report/template/components/rule_info.js | 83 +++++-- snakemake/report/template/index.html.jinja2 | 4 + snakemake/report/template/style.css | 4 + 15 files changed, 306 insertions(+), 202 deletions(-) create mode 100644 snakemake/report/template/__init__.py diff --git a/setup.py b/setup.py index 8b1181cf9..d959206ae 100644 --- a/setup.py +++ b/setup.py @@ -41,6 +41,8 @@ "snakemake", "snakemake.remote", "snakemake.report", + "snakemake.report.template", + "snakemake.report.data", "snakemake.common", "snakemake.caching", "snakemake.deployment", diff --git a/snakemake/report/__init__.py b/snakemake/report/__init__.py index 72d8bf389..9ec013cc0 100644 --- a/snakemake/report/__init__.py +++ b/snakemake/report/__init__.py @@ -121,7 +121,7 @@ def report( defaultenc="utf8", template=None, metadata=None, - **files + **files, ): if stylesheet is None: os.path.join(os.path.dirname(__file__), "report.css") @@ -400,7 +400,8 @@ def __init__( self.path = path self.target = os.path.basename(path) self.size = os.path.getsize(self.path) - logger.info("Adding {} ({:.2g} MB).".format(self.name, self.size / 1e6)) + self.size_mb = f"{self.size / 1e6:.2g} MB" + logger.info(f"Adding {self.name} ({self.size_mb}).") self.raw_caption = caption self.mime, _ = mime_from_file(self.path) self.workflow = workflow @@ -504,9 +505,7 @@ def render(self, env, rst_links, categories, files): caption = env.from_string(caption).render( snakemake=snakemake, categories=categories, files=files ) - self.caption = json.dumps( - publish_parts(caption, writer_name="html")["body"] - ) + self.caption = publish_parts(caption, writer_name="html")["body"] except Exception as e: raise WorkflowError( "Error loading caption file {} of output marked for report.".format( @@ -650,7 +649,7 @@ def get_links(direct: bool): def get_resource_as_string(path_or_uri): if is_local_file(path_or_uri): - return open(Path(__file__).parent / path_or_uri).read() + return open(Path(__file__).parent / "template" / path_or_uri).read() else: r = requests.get(path_or_uri) if r.status_code == requests.codes.ok: @@ -685,7 +684,7 @@ def auto_report(dag, path, stylesheet=None): logger.info("Creating report...") env = Environment( - loader=PackageLoader("snakemake", "report", "template"), + loader=PackageLoader("snakemake", "report/template"), trim_blocks=True, lstrip_blocks=True, ) @@ -865,6 +864,9 @@ def get_datetime(rectime): break if not merged: rules[rec.rule].append(rule) + # In theory there could be more than one rule with the same name kept from above. + # For now, we just keep the first. + rules = {rulename: items[0] for rulename, items in rules.items()} # rulegraph rulegraph, xmax, ymax = rulegraph_d3_spec(dag) @@ -940,14 +942,14 @@ class Snakemake: "Python package pygments must be installed to create reports." ) - results = data.results.render_results(results) - categories = data.categories.render_categories(results) - rulegraph = data.rulegraph.render_rulegraph( + categories = data.render_categories(results) + results = data.render_results(results) + rulegraph = data.render_rulegraph( rulegraph["nodes"], rulegraph["links"], rulegraph["links_direct"] ) - rules = data.rules.render_rules(rules.values()) - runtimes = data.runtimes.render_runtimes(runtimes) - timeline = data.timeline.render_timeline(timeline) + rules = data.render_rules(rules) + runtimes = data.render_runtimes(runtimes) + timeline = data.render_timeline(timeline) template = env.get_template("index.html.jinja2") @@ -960,12 +962,10 @@ class Snakemake: rules=rules, runtimes=runtimes, timeline=timeline, - pygments_css=HtmlFormatter(style="trac").get_style_defs(".source"), + pygments_css=HtmlFormatter(style="stata-dark").get_style_defs(".source"), custom_stylesheet=custom_stylesheet, - logo=data_uri_from_file(Path(__file__).parent / "logo.svg"), + logo=data_uri_from_file(Path(__file__).parent / "template" / "logo.svg"), now=now, - pygments_css=HtmlFormatter(style="trac").get_style_defs(".source"), - custom_stylesheet=custom_stylesheet, version=__version__.split("+")[0], ) diff --git a/snakemake/report/data/__init__.py b/snakemake/report/data/__init__.py index e69de29bb..45fb7ccfe 100644 --- a/snakemake/report/data/__init__.py +++ b/snakemake/report/data/__init__.py @@ -0,0 +1,6 @@ +from .results import render_results +from .categories import render_categories +from .rulegraph import render_rulegraph +from .rules import render_rules +from .runtimes import render_runtimes +from .timeline import render_timeline diff --git a/snakemake/report/data/categories.py b/snakemake/report/data/categories.py index 0e7edaf58..12e797eb7 100644 --- a/snakemake/report/data/categories.py +++ b/snakemake/report/data/categories.py @@ -1,8 +1,15 @@ +import json + + def render_categories(results): - return { - cat.name: { - subcat.name: [res.path for res in catresults] - for subcat, catresults in subcats + return json.dumps( + { + cat.name: { + subcat.name: [res.path for res in catresults] + for subcat, catresults in subcats.items() + if catresults + } + for cat, subcats in results.items() + if subcats and sum(len(catresults) for catresults in subcats.values()) } - for cat, subcats in results - } + ) diff --git a/snakemake/report/data/results.py b/snakemake/report/data/results.py index bf6bb3003..f4243aed6 100644 --- a/snakemake/report/data/results.py +++ b/snakemake/report/data/results.py @@ -1,18 +1,24 @@ +import json + + def render_results(results): - return { - res.path: { - "name": res.name, - "filename": res.filename, - "size": res.size, - "caption": res.caption, - "job_properties": { - "rule": res.rule, - "wildcards": res.wildcards, - "params": res.params, - }, - "data_uri": res.data_uri, + return json.dumps( + { + res.path: { + "name": res.name, + "filename": res.filename, + "size": res.size_mb, + "caption": res.caption, + "mime_type": res.mime, + "job_properties": { + "rule": res.job.rule.name, + "wildcards": res.wildcards, + "params": res.params, + }, + "data_uri": res.data_uri, + } + for cat, subcats in results.items() + for subcat, catresults in subcats.items() + for res in catresults } - for cat, subcats in results.items() - for subcat, catresults in subcats - for res in catresults - } + ) diff --git a/snakemake/report/data/rulegraph.py b/snakemake/report/data/rulegraph.py index 98371a73a..f9fb64110 100644 --- a/snakemake/report/data/rulegraph.py +++ b/snakemake/report/data/rulegraph.py @@ -1,116 +1,121 @@ +import json + + def render_rulegraph(nodes, links, links_direct): - return { - "$schema": "https://vega.github.io/schema/vega/v5.json", - "padding": 0, - "signals": [ - {"name": "cx", "update": "width / 2"}, - {"name": "cy", "update": "height / 2"}, - ], - "data": [ - {"name": "node-data", "values": nodes}, - {"name": "link-data", "values": links}, - {"name": "link-data-direct", "values": links_direct}, - ], - "scales": [ - { - "name": "color", - "type": "ordinal", - "range": {"scheme": "category20c"}, - }, - {"name": "x", "type": "linear"}, - {"name": "y", "type": "linear"}, - ], - "marks": [ - { - "name": "nodes", - "type": "symbol", - "zindex": 1, - "from": {"data": "node-data"}, - "encode": { - "enter": { - "fill": {"scale": "color", "field": "rule"}, - "x": {"field": "fx", "scale": "x"}, - "y": {"field": "fy", "scale": "y"}, - "tooltip": {"value": "Click to show rule details."}, - }, - "update": {"size": {"value": 70}}, - "hover": {"size": {"value": 140}}, + return json.dumps( + { + "$schema": "https://vega.github.io/schema/vega/v5.json", + "padding": 0, + "signals": [ + {"name": "cx", "update": "width / 2"}, + {"name": "cy", "update": "height / 2"}, + ], + "data": [ + {"name": "node-data", "values": nodes}, + {"name": "link-data", "values": links}, + {"name": "link-data-direct", "values": links_direct}, + ], + "scales": [ + { + "name": "color", + "type": "ordinal", + "range": {"scheme": "category20c"}, }, - "transform": [ - { - "type": "force", - "iterations": 1, - "static": true, - "forces": [{"force": "link", "links": "link-data"}], + {"name": "x", "type": "linear"}, + {"name": "y", "type": "linear"}, + ], + "marks": [ + { + "name": "nodes", + "type": "symbol", + "zindex": 1, + "from": {"data": "node-data"}, + "encode": { + "enter": { + "fill": {"scale": "color", "field": "rule"}, + "x": {"field": "fx", "scale": "x"}, + "y": {"field": "fy", "scale": "y"}, + "tooltip": {"value": "Click to show rule details."}, + }, + "update": {"size": {"value": 70}}, + "hover": {"size": {"value": 140}}, }, - { - "type": "force", - "iterations": 1, - "static": true, - "forces": [{"force": "link", "links": "link-data-direct"}], + "transform": [ + { + "type": "force", + "iterations": 1, + "static": True, + "forces": [{"force": "link", "links": "link-data"}], + }, + { + "type": "force", + "iterations": 1, + "static": True, + "forces": [{"force": "link", "links": "link-data-direct"}], + }, + ], + }, + { + "name": "labels", + "type": "text", + "zindex": 2, + "from": {"data": "node-data"}, + "encode": { + "enter": { + "fill": {"value": "black"}, + "fontWeight": {"value": "normal"}, + "text": {"field": "rule"}, + "x": {"field": "fx", "scale": "x"}, + "y": {"field": "fy", "scale": "y"}, + "dx": {"value": -5}, + "dy": {"value": -5}, + "align": {"value": "right"}, + } }, - ], - }, - { - "name": "labels", - "type": "text", - "zindex": 2, - "from": {"data": "node-data"}, - "encode": { - "enter": { - "fill": {"value": "black"}, - "fontWeight": {"value": "normal"}, - "text": {"field": "rule"}, - "x": {"field": "fx", "scale": "x"}, - "y": {"field": "fy", "scale": "y"}, - "dx": {"value": -5}, - "dy": {"value": -5}, - "align": {"value": "right"}, - } }, - }, - { - "type": "path", - "from": {"data": "link-data-direct"}, - "interactive": false, - "encode": { - "update": { - "stroke": {"value": "#ccc"}, - "strokeWidth": {"value": 1.0}, - } + { + "type": "path", + "from": {"data": "link-data-direct"}, + "interactive": False, + "encode": { + "update": { + "stroke": {"value": "#ccc"}, + "strokeWidth": {"value": 1.0}, + } + }, + "transform": [ + { + "type": "linkpath", + "shape": "diagonal", + "sourceX": "datum.source.x", + "sourceY": "datum.source.y", + "targetX": "datum.target.x", + "targetY": "datum.target.y", + } + ], }, - "transform": [ - { - "type": "linkpath", - "shape": "diagonal", - "sourceX": "datum.source.x", - "sourceY": "datum.source.y", - "targetX": "datum.target.x", - "targetY": "datum.target.y", - } - ], - }, - { - "type": "path", - "from": {"data": "link-data"}, - "interactive": false, - "encode": { - "update": { - "stroke": {"value": "#ccc"}, - "strokeWidth": {"value": 1.0}, - } + { + "type": "path", + "from": {"data": "link-data"}, + "interactive": False, + "encode": { + "update": { + "stroke": {"value": "#ccc"}, + "strokeWidth": {"value": 1.0}, + } + }, + "transform": [ + { + "type": "linkpath", + "shape": "curve", + "orient": "horizontal", + "sourceX": "datum.source.x", + "sourceY": "datum.source.y", + "targetX": "datum.target.x", + "targetY": "datum.target.y", + } + ], }, - "transform": [ - { - "type": "linkpath", - "shape": "curve", - "orient": "horizontal", - "sourceX": "datum.source.x", - "sourceY": "datum.source.y", - "targetX": "datum.target.x", - "targetY": "datum.target.y", - } - ], - }, - ], - } + ], + } + ) diff --git a/snakemake/report/data/rules.py b/snakemake/report/data/rules.py index 478c54933..dfa35004f 100644 --- a/snakemake/report/data/rules.py +++ b/snakemake/report/data/rules.py @@ -1,2 +1,17 @@ +import json + + def render_rules(rules): - return {} # TODO + return json.dumps( + { + rulename: { + "input": rule.input, + "output": rule.output, + "conda_env": rule.conda_env, + "container_img_url": rule.container_img_url, + "code": rule.code, + "n_jobs": rule.n_jobs, + } + for rulename, rule in rules.items() + } + ) diff --git a/snakemake/report/data/runtimes.py b/snakemake/report/data/runtimes.py index 216162457..a82c7009c 100644 --- a/snakemake/report/data/runtimes.py +++ b/snakemake/report/data/runtimes.py @@ -1,17 +1,22 @@ +import json + + def render_runtimes(runtimes): - return { - "$schema": "https://vega.github.io/schema/vega-lite/v3.json", - "description": "Runtimes of jobs.", - "data": {"values": runtimes}, - "mark": "point", - "encoding": { - "x": { - "field": "runtime", - "type": "quantitative", - "axis": {"title": "runtime [s]", "labelAngle": -90}, - "scale": {"type": "log"}, + return json.dumps( + { + "$schema": "https://vega.github.io/schema/vega-lite/v3.json", + "description": "Runtimes of jobs.", + "data": {"values": runtimes}, + "mark": "point", + "encoding": { + "x": { + "field": "runtime", + "type": "quantitative", + "axis": {"title": "runtime [s]", "labelAngle": -90}, + "scale": {"type": "log"}, + }, + "y": {"field": "rule", "type": "nominal"}, + "color": {"value": "#007bff"}, }, - "y": {"field": "rule", "type": "nominal"}, - "color": {"value": "#007bff"}, - }, - } + } + ) diff --git a/snakemake/report/data/timeline.py b/snakemake/report/data/timeline.py index b09d1ed30..7591441ce 100644 --- a/snakemake/report/data/timeline.py +++ b/snakemake/report/data/timeline.py @@ -1,17 +1,22 @@ +import json + + def render_timeline(timeline): - return { - "$schema": "https://vega.github.io/schema/vega-lite/v3.json", - "description": "Timeline of jobs.", - "data": {"values": timeline}, - "mark": "point", - "encoding": { - "x": { - "field": "endtime", - "type": "temporal", - "timeUnit": "yearmonthdatehoursminutes", - "axis": {"labelAngle": -90, "title": "creation date"}, + return json.dumps( + { + "$schema": "https://vega.github.io/schema/vega-lite/v3.json", + "description": "Timeline of jobs.", + "data": {"values": timeline}, + "mark": "point", + "encoding": { + "x": { + "field": "endtime", + "type": "temporal", + "timeUnit": "yearmonthdatehoursminutes", + "axis": {"labelAngle": -90, "title": "creation date"}, + }, + "y": {"field": "rule", "type": "nominal"}, + "color": {"value": "#007bff"}, }, - "y": {"field": "rule", "type": "nominal"}, - "color": {"value": "#007bff"}, - }, - } + } + ) diff --git a/snakemake/report/template/__init__.py b/snakemake/report/template/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/snakemake/report/template/components/navbar.js b/snakemake/report/template/components/navbar.js index 8079c3e78..19cda2d60 100644 --- a/snakemake/report/template/components/navbar.js +++ b/snakemake/report/template/components/navbar.js @@ -16,7 +16,7 @@ class Navbar extends React.Component { return [ e( "div", - { className: `fixed z-50 p-3 transition-translate ${translateShowButton}` }, + { className: `fixed z-50 p-3 transition-translate bg-white backdrop-blur-sm rounded-br-lg ${translateShowButton}` }, this.getShowButton() ), e( @@ -27,7 +27,7 @@ class Navbar extends React.Component { { className: "sticky bg-blur bg-white opacity-80 text-slate-700 text-l tracking-wide px-3 py-1 mb-1 flex items-center" }, e( "img", - { src: "logo.svg", className: "h-4" } + { src: logo_uri, className: "h-4" } ), e( "span", @@ -213,7 +213,7 @@ class Navbar extends React.Component { getResultinfoBreadcrumb() { let setView = this.props.app.setView; return { - name: "resultinfo", icon: "eye", func: function () { setView({ navbarMode: "resultinfo" }) } + name: this.props.app.state.resultPath, func: function () { setView({ navbarMode: "resultinfo" }) } }; } diff --git a/snakemake/report/template/components/result_info.js b/snakemake/report/template/components/result_info.js index c9abef127..637109f60 100644 --- a/snakemake/report/template/components/result_info.js +++ b/snakemake/report/template/components/result_info.js @@ -93,7 +93,7 @@ class ResultInfo extends React.Component { ListItem, { key: "caption", - className: "p-1", + className: "p-1 prose prose-invert prose-sm", dangerouslySetInnerHTML: { __html: caption } } ) diff --git a/snakemake/report/template/components/rule_info.js b/snakemake/report/template/components/rule_info.js index 5e3f60646..b43fb2c87 100644 --- a/snakemake/report/template/components/rule_info.js +++ b/snakemake/report/template/components/rule_info.js @@ -7,34 +7,79 @@ class RuleInfo extends React.Component { render() { let rule = rules[this.props.rule]; + if (rule === undefined) { + return e( + "span", + { className: "p-1" }, + `No metadata available for rule ${this.props.rule}` + ); + } + return e( "ol", {}, this.renderItems("Input", rule.input, {}, false), - this.renderItems("Output", rule.input), - this.renderItems("Software", rule.conda), + this.renderItems("Output", rule.output), + this.renderSoftware(), this.renderItems("Container", [rule.container]), - this.renderItems("Code", rule.code), + this.renderCode(), ) } + renderSoftware() { + let rule = rules[this.props.rule]; + if (rule.conda_env) { + return this.renderItems("Software", rule.conda_env.dependencies); + } else { + return []; + } + } + + renderCode() { + let rule = rules[this.props.rule]; + if (rule.code.length) { + return [ + e( + ListHeading, + { key: "code-heading", text: "Code" } + ), + rule.code.map(function (block) { + return e( + ListItem, + { + key: "code", + className: "p-1", + dangerouslySetInnerHTML: { __html: block } + } + ) + }) + ]; + } else { + return []; + } + } + renderItems(heading, items, props = {}, margin = true) { - let headingProps = {}; - if (margin) { - headingProps = { className: "" } + if (items.length && items.every((item) => item !== undefined)) { + let headingProps = {}; + if (margin) { + headingProps = { className: "" } + } + return [ + e( + ListHeading, + { text: heading, ...headingProps } + ), + items.map(function (item) { + return e( + ListItem, + props, + item + ); + }) + ]; + } else { + return []; } - return [ - e( - ListHeading, - { text: heading, ...headingProps } - ), - items.map(function (item) { - return e( - ListItem, - props, - item - ); - }) - ]; } } \ No newline at end of file diff --git a/snakemake/report/template/index.html.jinja2 b/snakemake/report/template/index.html.jinja2 index 334f44742..a46ed8713 100644 --- a/snakemake/report/template/index.html.jinja2 +++ b/snakemake/report/template/index.html.jinja2 @@ -53,6 +53,10 @@ var rules = {{rules}}; + + diff --git a/snakemake/report/template/style.css b/snakemake/report/template/style.css index f4146fa47..dd63f225d 100644 --- a/snakemake/report/template/style.css +++ b/snakemake/report/template/style.css @@ -1,4 +1,8 @@ .vega-embed summary { z-index: 49 !important; /* ensure that menu is always below navbar*/ +} + +.source { + background-color: transparent!important; } \ No newline at end of file From f22d6cc84d142fec65484801f9c649a98fdff834 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Johannes=20K=C3=B6ster?= Date: Thu, 10 Mar 2022 12:08:46 +0100 Subject: [PATCH 14/45] cleanup --- setup.py | 2 +- snakemake/report/__init__.py | 86 ------------------------------------ test-environment.yml | 2 - 3 files changed, 1 insertion(+), 89 deletions(-) diff --git a/setup.py b/setup.py index d959206ae..c83941777 100644 --- a/setup.py +++ b/setup.py @@ -84,7 +84,7 @@ "retry", ], extras_require={ - "reports": ["jinja2", "networkx", "pygments", "pygraphviz"], + "reports": ["jinja2", "pygments"], "messaging": ["slacker"], "google-cloud": [ "oauth2client", diff --git a/snakemake/report/__init__.py b/snakemake/report/__init__.py index 9ec013cc0..eeae225e5 100644 --- a/snakemake/report/__init__.py +++ b/snakemake/report/__init__.py @@ -425,50 +425,6 @@ def __init__( self.data_uri = self._data_uri() self.png_uri = self._png_uri() - @lazy_property - def png_content(self): - assert self.is_img - - convert = shutil.which("magick") - if convert is not None: - try: - # 2048 aims at a reasonable balance between what displays - # can show in a png-preview image and what renders quick - # into a small enough png - max_width = "2048" - max_height = "2048" - # '>' means only larger images scaled down to within max-dimensions - max_spec = max_width + "x" + max_height + ">" - png = sp.check_output( - ["magick", "convert", "-resize", max_spec, self.path, "png:-"], - stderr=sp.PIPE, - ) - return png - except sp.CalledProcessError as e: - logger.warning( - "Failed to convert image to png with " - "imagemagick convert: {}".format(e.stderr) - ) - else: - logger.warning( - "Command convert not in $PATH. Install " - "imagemagick in order to have embedded " - "images and pdfs in the report." - ) - - def _png_uri(self): - if self.is_img: - png = self.png_content - if self.mode_embedded: - if png is not None: - uri = data_uri( - png, os.path.basename(self.path) + ".png", mime="image/png" - ) - return uri - else: - if png is not None: - return os.path.join("data/thumbnails", self.id) - def _data_uri(self): if self.mode_embedded: return data_uri_from_file(self.path) @@ -561,41 +517,6 @@ def filename(self): return os.path.basename(self.path) -def rulegraph_d3_spec(dag): - try: - import networkx as nx - from networkx.drawing.nx_agraph import graphviz_layout - from networkx.readwrite import json_graph - except ImportError as e: - raise WorkflowError( - "Python packages networkx and pygraphviz must be " - "installed to create reports.", - e, - ) - - g = nx.DiGraph() - g.add_nodes_from(sorted(job.rule.name for job in dag.jobs)) - - for job in dag.jobs: - target = job.rule.name - for dep in dag.dependencies[job]: - source = dep.rule.name - g.add_edge(source, target) - - pos = graphviz_layout(g, "dot", args="-Grankdir=BT") - xmax = max(x for x, y in pos.values()) + 100 # add offset to account for labels - ymax = max(y for x, y in pos.values()) - - def encode_node(node): - x, y = pos[node] - return {"rule": node, "fx": x, "fy": y} - - nodes = list(map(encode_node, g.nodes)) - idx = {node: i for i, node in enumerate(g.nodes)} - links = [{"target": idx[u], "source": idx[v], "value": 1} for u, v in g.edges] - return {"nodes": nodes, "links": links}, xmax, ymax - - def rulegraph_spec(dag): # get toposorting, and keep only one job of each rule per level representatives = dict() @@ -817,7 +738,6 @@ def get_time(rectime, metatime, sel_func): rec.container_img_url = meta["container_img_url"] rec.output.append(f) except KeyError as e: - print(e) logger.warning( "Metadata for file {} was created with a too " "old Snakemake version.".format(f) @@ -869,7 +789,6 @@ def get_datetime(rectime): rules = {rulename: items[0] for rulename, items in rules.items()} # rulegraph - rulegraph, xmax, ymax = rulegraph_d3_spec(dag) rulegraph, xmax, ymax = rulegraph_spec(dag) # configfiles @@ -980,11 +899,6 @@ class Snakemake: for result in catresults: # write raw data zipout.write(result.path, str(folder.joinpath(result.data_uri))) - # write thumbnail - if result.is_img and result.png_content: - zipout.writestr( - str(folder.joinpath(result.png_uri)), result.png_content - ) # write aux files parent = folder.joinpath(result.data_uri).parent for aux_path in result.aux_files: diff --git a/test-environment.yml b/test-environment.yml index d1fcf797e..327024e74 100644 --- a/test-environment.yml +++ b/test-environment.yml @@ -42,8 +42,6 @@ dependencies: - cwltool - jsonschema - pandas - - networkx - - pygraphviz - python-kubernetes - gitpython - pulp >=2.0 From ea21e3e506c31cf1019064617ac2d9587b650404 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Johannes=20K=C3=B6ster?= Date: Thu, 10 Mar 2022 12:09:58 +0100 Subject: [PATCH 15/45] fixes --- snakemake/report/__init__.py | 1 - 1 file changed, 1 deletion(-) diff --git a/snakemake/report/__init__.py b/snakemake/report/__init__.py index eeae225e5..a8341e33b 100644 --- a/snakemake/report/__init__.py +++ b/snakemake/report/__init__.py @@ -423,7 +423,6 @@ def __init__( self.aux_files = aux_files or [] self.data_uri = self._data_uri() - self.png_uri = self._png_uri() def _data_uri(self): if self.mode_embedded: From 2db9dcf08cd2f6aef27b356cf7dd5bedb92d76e7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Johannes=20K=C3=B6ster?= Date: Thu, 10 Mar 2022 12:12:20 +0100 Subject: [PATCH 16/45] fix --- snakemake/report/__init__.py | 1 - 1 file changed, 1 deletion(-) diff --git a/snakemake/report/__init__.py b/snakemake/report/__init__.py index a8341e33b..3d30095f3 100644 --- a/snakemake/report/__init__.py +++ b/snakemake/report/__init__.py @@ -287,7 +287,6 @@ def code(self): self._rule.notebook, self._rule.workflow.sourcecache, self._rule.basedir, - wildcards=self.wildcards, params=self.params, ) language = language.split("_")[1] From ffae54801e80f17ee0010be0b3f84542b4d0623a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Johannes=20K=C3=B6ster?= Date: Thu, 10 Mar 2022 12:13:09 +0100 Subject: [PATCH 17/45] fixes --- snakemake/report/__init__.py | 1 - 1 file changed, 1 deletion(-) diff --git a/snakemake/report/__init__.py b/snakemake/report/__init__.py index 3d30095f3..87bee8ccf 100644 --- a/snakemake/report/__init__.py +++ b/snakemake/report/__init__.py @@ -287,7 +287,6 @@ def code(self): self._rule.notebook, self._rule.workflow.sourcecache, self._rule.basedir, - params=self.params, ) language = language.split("_")[1] sources = notebook.get_cell_sources(source) From 1fb439924ea1a0549fe17cb954c369330866af91 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Johannes=20K=C3=B6ster?= Date: Thu, 10 Mar 2022 12:16:59 +0100 Subject: [PATCH 18/45] fixes --- snakemake/report/__init__.py | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/snakemake/report/__init__.py b/snakemake/report/__init__.py index 87bee8ccf..6b49a8b6c 100644 --- a/snakemake/report/__init__.py +++ b/snakemake/report/__init__.py @@ -34,6 +34,7 @@ from snakemake.utils import format from snakemake.logging import logger from snakemake.io import ( + is_callable, is_flagged, get_flag_value, glob_wildcards, @@ -231,6 +232,13 @@ def __lt__(self, other): return self.name.__lt__(other.name) +def render_iofile(iofile): + if is_callable(iofile): + return "" + else: + return str(iofile) + + class RuleRecord: def __init__(self, job, job_rec): import yaml @@ -320,11 +328,11 @@ def add(self, job_rec): @property def output(self): - return self._rule.output + return [render_iofile(f) for f in self._rule.output] @property def input(self): - return self._rule.input + return [render_iofile(f) for f in self._rule.input] def __eq__(self, other): return ( From 20a8dc2161cef7409b6d64ebee0d3195e3190899 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Johannes=20K=C3=B6ster?= Date: Thu, 10 Mar 2022 12:17:48 +0100 Subject: [PATCH 19/45] dbg --- snakemake/report/__init__.py | 1 + 1 file changed, 1 insertion(+) diff --git a/snakemake/report/__init__.py b/snakemake/report/__init__.py index 6b49a8b6c..631b0d53a 100644 --- a/snakemake/report/__init__.py +++ b/snakemake/report/__init__.py @@ -234,6 +234,7 @@ def __lt__(self, other): def render_iofile(iofile): if is_callable(iofile): + print("func") return "" else: return str(iofile) From 8930221f2cb122059fc9354c252d09d94fc70c4e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Johannes=20K=C3=B6ster?= Date: Thu, 10 Mar 2022 12:18:27 +0100 Subject: [PATCH 20/45] dbg --- snakemake/report/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/snakemake/report/__init__.py b/snakemake/report/__init__.py index 631b0d53a..5266cf94c 100644 --- a/snakemake/report/__init__.py +++ b/snakemake/report/__init__.py @@ -233,8 +233,8 @@ def __lt__(self, other): def render_iofile(iofile): + print(iofile, is_callable(iofile)) if is_callable(iofile): - print("func") return "" else: return str(iofile) From c90ec189fc46b4176dfba5b655758689728ab245 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Johannes=20K=C3=B6ster?= Date: Thu, 10 Mar 2022 12:18:38 +0100 Subject: [PATCH 21/45] cleanup --- snakemake/report/__init__.py | 1 - 1 file changed, 1 deletion(-) diff --git a/snakemake/report/__init__.py b/snakemake/report/__init__.py index 5266cf94c..6b49a8b6c 100644 --- a/snakemake/report/__init__.py +++ b/snakemake/report/__init__.py @@ -233,7 +233,6 @@ def __lt__(self, other): def render_iofile(iofile): - print(iofile, is_callable(iofile)) if is_callable(iofile): return "" else: From ee403a8b89080311ae05489807faa95ae84f8b85 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Johannes=20K=C3=B6ster?= Date: Thu, 10 Mar 2022 12:33:50 +0100 Subject: [PATCH 22/45] implement column support --- snakemake/io.py | 8 ++++---- snakemake/report/__init__.py | 17 +++++++++++++++++ snakemake/report/data/results.py | 1 + 3 files changed, 22 insertions(+), 4 deletions(-) diff --git a/snakemake/io.py b/snakemake/io.py index f6772cdb3..e8f7de4f6 100755 --- a/snakemake/io.py +++ b/snakemake/io.py @@ -1080,12 +1080,12 @@ def checkpoint_target(value): ReportObject = collections.namedtuple( - "ReportObject", ["caption", "category", "subcategory", "patterns", "htmlindex"] + "ReportObject", ["caption", "category", "subcategory", "columns", "patterns", "htmlindex"] ) def report( - value, caption=None, category=None, subcategory=None, patterns=[], htmlindex=None + value, caption=None, category=None, subcategory=None, columns=None, patterns=[], htmlindex=None ): """Flag output file or directory as to be included into reports. @@ -1095,14 +1095,14 @@ def report( value -- File or directory. caption -- Path to a .rst file with a textual description of the result. category -- Name of the category in which the result should be displayed in the report. - pattern -- Wildcard pattern for selecting files if a directory is given (this is used as + patterns -- Wildcard patterns for selecting files if a directory is given (this is used as input for snakemake.io.glob_wildcards). Pattern shall not include the path to the directory itself. """ return flag( value, "report", - ReportObject(caption, category, subcategory, patterns, htmlindex), + ReportObject(caption, category, subcategory, columns, patterns, htmlindex), ) diff --git a/snakemake/report/__init__.py b/snakemake/report/__init__.py index 6b49a8b6c..78a4abf5e 100644 --- a/snakemake/report/__init__.py +++ b/snakemake/report/__init__.py @@ -400,7 +400,9 @@ def __init__( mode_embedded=True, aux_files=None, name_overwrite=None, + columns=None, ): + self.columns = columns self.name_overwrite = name_overwrite self.mode_embedded = mode_embedded self.path = path @@ -585,6 +587,19 @@ def get_resource_as_string(path_or_uri): ) +def expand_columns(columns, wildcards, job): + if columns is None: + return None + if not isinstance(columns, list) or not all( + isinstance(col, str) for col in columns + ): + raise WorkflowError( + "Expected list of strings as columns argument given to report flag.", + rule=job.rule, + ) + return [apply_wildcards(col, wildcards) for col in columns] + + def auto_report(dag, path, stylesheet=None): try: from jinja2 import Template, Environment, PackageLoader, UndefinedError @@ -639,6 +654,7 @@ def register_file( subcategory = Category( report_obj.subcategory, wildcards=wildcards, job=job ) + columns = expand_columns(report_obj.columns, wildcards, job) results[category][subcategory].append( FileRecord( @@ -652,6 +668,7 @@ def register_file( mode_embedded=mode_embedded, aux_files=aux_files, name_overwrite=name_overwrite, + columns=columns, ) ) recorded_files.add(f) diff --git a/snakemake/report/data/results.py b/snakemake/report/data/results.py index f4243aed6..374cd370b 100644 --- a/snakemake/report/data/results.py +++ b/snakemake/report/data/results.py @@ -7,6 +7,7 @@ def render_results(results): res.path: { "name": res.name, "filename": res.filename, + "columns": res.columns, "size": res.size_mb, "caption": res.caption, "mime_type": res.mime, From 60030c882f5cf54627c848f24eb8de6973354ac2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Johannes=20K=C3=B6ster?= Date: Thu, 10 Mar 2022 12:58:58 +0100 Subject: [PATCH 23/45] fixes --- snakemake/io.py | 15 ++++++++++++--- snakemake/report/__init__.py | 8 ++++---- .../template/components/abstract_results.js | 6 +++--- .../report/template/components/result_info.js | 15 ++++++--------- snakemake/rules.py | 1 + tests/test_report/Snakefile | 4 ++-- 6 files changed, 28 insertions(+), 21 deletions(-) diff --git a/snakemake/io.py b/snakemake/io.py index e8f7de4f6..42cefb40f 100755 --- a/snakemake/io.py +++ b/snakemake/io.py @@ -1080,12 +1080,19 @@ def checkpoint_target(value): ReportObject = collections.namedtuple( - "ReportObject", ["caption", "category", "subcategory", "columns", "patterns", "htmlindex"] + "ReportObject", + ["caption", "category", "subcategory", "columns", "patterns", "htmlindex"], ) def report( - value, caption=None, category=None, subcategory=None, columns=None, patterns=[], htmlindex=None + value, + caption=None, + category=None, + subcategory=None, + columns=None, + patterns=[], + htmlindex=None, ): """Flag output file or directory as to be included into reports. @@ -1094,7 +1101,9 @@ def report( Arguments value -- File or directory. caption -- Path to a .rst file with a textual description of the result. - category -- Name of the category in which the result should be displayed in the report. + category -- Name of the (optional) category in which the result should be displayed in the report. + subcategory -- Name of the (optional) subcategory + columns -- Dict of strings (may contain wildcard expressions) that will be used as columns when displaying result tables patterns -- Wildcard patterns for selecting files if a directory is given (this is used as input for snakemake.io.glob_wildcards). Pattern shall not include the path to the directory itself. diff --git a/snakemake/report/__init__.py b/snakemake/report/__init__.py index 78a4abf5e..158d5b60b 100644 --- a/snakemake/report/__init__.py +++ b/snakemake/report/__init__.py @@ -590,14 +590,14 @@ def get_resource_as_string(path_or_uri): def expand_columns(columns, wildcards, job): if columns is None: return None - if not isinstance(columns, list) or not all( - isinstance(col, str) for col in columns + if not isinstance(columns, dict) or not all( + isinstance(col, str) for col in columns.values() ): raise WorkflowError( - "Expected list of strings as columns argument given to report flag.", + "Expected dict of strings as columns argument given to report flag.", rule=job.rule, ) - return [apply_wildcards(col, wildcards) for col in columns] + return {name: apply_wildcards(col, wildcards) for name, col in columns.items()} def auto_report(dag, path, stylesheet=None): diff --git a/snakemake/report/template/components/abstract_results.js b/snakemake/report/template/components/abstract_results.js index 7747f96c3..6d2d55c5f 100644 --- a/snakemake/report/template/components/abstract_results.js +++ b/snakemake/report/template/components/abstract_results.js @@ -39,12 +39,12 @@ class AbstractResults extends React.Component { } getColumns() { - return Array.from(new Set(this.getResults().map(function ([path, result]) { Object.keys(result.columns) }).flat())).sort(); + return Array.from(new Set(this.getResults().map(function ([path, result]) { return Object.keys(result.columns) }).flat())).sort(); } isColumnBased() { return this.getResults().every(function ([path, result]) { - "columns" in result + return result.columns; }); } @@ -56,7 +56,7 @@ class AbstractResults extends React.Component { this.getColumns().map(function (column) { return e( "th", - { className: "text-left p-1" }, + { className: "text-left p-1 uppercase" }, column ) }), diff --git a/snakemake/report/template/components/result_info.js b/snakemake/report/template/components/result_info.js index 637109f60..c467a3b58 100644 --- a/snakemake/report/template/components/result_info.js +++ b/snakemake/report/template/components/result_info.js @@ -20,18 +20,15 @@ class ResultInfo extends React.Component { getDescriptor() { let result = this.getResult(); - if (result.columns !== undefined) { + if (result.columns) { const columns = Object.keys(result.columns).sort(); return [ - e( - ListHeading, - { text: "Result", key: "result" } - ), e( ListItem, + {}, e( "table", - {}, + { className: "table-auto text-white text-sm" }, e( "thead", {}, @@ -41,7 +38,7 @@ class ResultInfo extends React.Component { columns.map(function (column) { return e( "th", - {}, + { className: "text-left uppercase pr-2" }, column ); }) @@ -57,7 +54,7 @@ class ResultInfo extends React.Component { const value = result.columns[column]; return e( "td", - {}, + { className: "pr-2" }, value ); }) @@ -70,7 +67,7 @@ class ResultInfo extends React.Component { return [ e( ListHeading, - { text: "Result", key: "result" } + { text: "Path", key: "result" } ), e( ListItem, diff --git a/snakemake/rules.py b/snakemake/rules.py index 45730db1c..aa24b1eca 100644 --- a/snakemake/rules.py +++ b/snakemake/rules.py @@ -594,6 +594,7 @@ def _set_inoutput_item(self, item, output=False, name=None): self.workflow.current_basedir.join(report_obj.caption), report_obj.category, report_obj.subcategory, + report_obj.columns, report_obj.patterns, report_obj.htmlindex, ) diff --git a/tests/test_report/Snakefile b/tests/test_report/Snakefile index 91ba92e4c..f900b8682 100644 --- a/tests/test_report/Snakefile +++ b/tests/test_report/Snakefile @@ -23,7 +23,7 @@ rule a: input: expand("test.{i}.out", i=range(10)) output: - report("fig1.svg", caption="report/fig1.rst", category="Step 1") + report("fig1.svg", caption="report/fig1.rst", category="Step 1", columns={"type": "figure", "num": "1"}) shell: "sleep `shuf -i 1-3 -n 1`; cp data/fig1.svg {output}" @@ -32,7 +32,7 @@ rule b: input: expand("test.{i}.out", i=range(10)) output: - report("{model}.fig2.png", caption="report/fig2.rst", category="Step 2", subcategory="{model}") + report("{model}.fig2.png", caption="report/fig2.rst", category="Step 2", subcategory="{model}", columns={"type": "figure", "model": "{model}"}) shell: "sleep `shuf -i 1-3 -n 1`; cp data/fig2.png {output}" From cdb8af6a515f374a20782d664268bedba67b3088 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Johannes=20K=C3=B6ster?= Date: Thu, 10 Mar 2022 13:16:01 +0100 Subject: [PATCH 24/45] polish --- .../report/template/components/result_info.js | 24 +++++++++++++++---- 1 file changed, 20 insertions(+), 4 deletions(-) diff --git a/snakemake/report/template/components/result_info.js b/snakemake/report/template/components/result_info.js index c467a3b58..2119bb4e3 100644 --- a/snakemake/report/template/components/result_info.js +++ b/snakemake/report/template/components/result_info.js @@ -110,11 +110,27 @@ class ResultInfo extends React.Component { ), e( ListItem, - { key: "rulename", className: "" }, + { key: "rulename" }, e( - "a", - { type: "button", href: "#", className: "p-1 transition-all hover:text-emerald-500 rounded hover:bg-slate-800", onClick: () => setView({ navbarMode: "ruleinfo", ruleinfo: rule }) }, - rule + "span", + { className: "flex items-center gap-1" }, + [ + e( + "span", + {}, + rule + ), + e( + "a", + { + type: "button", + href: "#", + className: `transition-all inline-block p-1 text-emerald-500 rounded hover:bg-slate-800`, + onClick: () => setView({ navbarMode: "ruleinfo", ruleinfo: rule }) + }, + e(Icon, { iconName: "information-circle" }) + ) + ] ) ) ] From 4928be9d145c163e2a2044e35299c6e76b1cfeda Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Johannes=20K=C3=B6ster?= Date: Thu, 10 Mar 2022 13:55:50 +0100 Subject: [PATCH 25/45] allow input functions for report category, subcategory, and columns --- snakemake/common/__init__.py | 10 ++++++++++ snakemake/report/__init__.py | 37 +++++++++++++++++++++++++++++------- snakemake/rules.py | 18 ++++++++++++------ tests/test_report/Snakefile | 4 ++-- 4 files changed, 54 insertions(+), 15 deletions(-) diff --git a/snakemake/common/__init__.py b/snakemake/common/__init__.py index 2cde9d810..852abd70d 100644 --- a/snakemake/common/__init__.py +++ b/snakemake/common/__init__.py @@ -257,3 +257,13 @@ class Gather: """A namespace for gather to allow items to be accessed via dot notation.""" pass + + +def get_function_params(func): + return inspect.signature(func).parameters + + +def get_input_function_aux_params(func, candidate_params): + func_params = get_function_params(func) + + return {k: v for k, v in candidate_params.items() if k in func_params} diff --git a/snakemake/report/__init__.py b/snakemake/report/__init__.py index 158d5b60b..fff69c2be 100644 --- a/snakemake/report/__init__.py +++ b/snakemake/report/__init__.py @@ -42,10 +42,15 @@ apply_wildcards, contains_wildcard, ) -from snakemake.exceptions import WorkflowError +from snakemake.exceptions import InputFunctionException, WorkflowError from snakemake.script import Snakemake from snakemake import __version__ -from snakemake.common import is_local_file, num_if_possible, lazy_property +from snakemake.common import ( + get_input_function_aux_params, + is_local_file, + num_if_possible, + lazy_property, +) from snakemake import logging from snakemake.report import data @@ -204,6 +209,22 @@ def report( ) +def expand_report_argument(item, wildcards, job): + if is_callable(item): + aux_params = get_input_function_aux_params(item, {"params": job.params}) + try: + item = item(wildcards, **aux_params) + except Exception as e: + raise InputFunctionException(e, rule=job.rule, wildcards=wildcards) + if isinstance(item, str): + try: + return apply_wildcards(item, wildcards) + except AttributeError as e: + raise WorkflowError("Failed to resolve wildcards.", e, rule=job.rule) + else: + return item + + class Category: def __init__(self, name, wildcards, job): if name is None: @@ -211,10 +232,7 @@ def __init__(self, name, wildcards, job): self.is_other = True else: self.is_other = False - try: - name = apply_wildcards(name, wildcards) - except AttributeError as e: - raise WorkflowError("Failed to resolve wildcards.", e, rule=job.rule) + name = expand_report_argument(name, wildcards, job) self.name = name h = hashlib.sha256() h.update(name.encode()) @@ -590,6 +608,8 @@ def get_resource_as_string(path_or_uri): def expand_columns(columns, wildcards, job): if columns is None: return None + columns = expand_report_argument(columns, wildcards, job) + if not isinstance(columns, dict) or not all( isinstance(col, str) for col in columns.values() ): @@ -597,7 +617,10 @@ def expand_columns(columns, wildcards, job): "Expected dict of strings as columns argument given to report flag.", rule=job.rule, ) - return {name: apply_wildcards(col, wildcards) for name, col in columns.items()} + return { + name: expand_report_argument(col, wildcards, job) + for name, col in columns.items() + } def auto_report(dag, path, stylesheet=None): diff --git a/snakemake/rules.py b/snakemake/rules.py index aa24b1eca..2d9c8fbb0 100644 --- a/snakemake/rules.py +++ b/snakemake/rules.py @@ -55,7 +55,14 @@ IncompleteCheckpointException, ) from snakemake.logging import logger -from snakemake.common import Mode, ON_WINDOWS, lazy_property, TBDString +from snakemake.common import ( + Mode, + ON_WINDOWS, + get_function_params, + get_input_function_aux_params, + lazy_property, + TBDString, +) import snakemake.io @@ -720,18 +727,17 @@ def apply_input_function( func = func._file.callable elif isinstance(func, AnnotatedString): func = func.callable - sig = inspect.signature(func) - - _aux_params = {k: v for k, v in aux_params.items() if k in sig.parameters} - if "groupid" in sig.parameters: + if "groupid" in get_function_params(func): if groupid is not None: - _aux_params["groupid"] = groupid + aux_params["groupid"] = groupid else: # Return empty list of files and incomplete marker # the job will be reevaluated once groupids have been determined return [], True + _aux_params = get_input_function_aux_params(func, aux_params) + try: value = func(Wildcards(fromdict=wildcards), **_aux_params) except IncompleteCheckpointException as e: diff --git a/tests/test_report/Snakefile b/tests/test_report/Snakefile index f900b8682..c5960a38c 100644 --- a/tests/test_report/Snakefile +++ b/tests/test_report/Snakefile @@ -23,7 +23,7 @@ rule a: input: expand("test.{i}.out", i=range(10)) output: - report("fig1.svg", caption="report/fig1.rst", category="Step 1", columns={"type": "figure", "num": "1"}) + report("fig1.svg", caption="report/fig1.rst", category="Step 1", columns=lambda w, params: {"type": "figure", "num": "1"}) shell: "sleep `shuf -i 1-3 -n 1`; cp data/fig1.svg {output}" @@ -32,7 +32,7 @@ rule b: input: expand("test.{i}.out", i=range(10)) output: - report("{model}.fig2.png", caption="report/fig2.rst", category="Step 2", subcategory="{model}", columns={"type": "figure", "model": "{model}"}) + report("{model}.fig2.png", caption="report/fig2.rst", category=lambda w: "Step 2", subcategory="{model}", columns={"type": "figure", "model": "{model}"}) shell: "sleep `shuf -i 1-3 -n 1`; cp data/fig2.png {output}" From 079cf8dba56053cb159b2b15e68309c401c895b0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Johannes=20K=C3=B6ster?= Date: Thu, 10 Mar 2022 14:25:41 +0100 Subject: [PATCH 26/45] rename columns to labels --- snakemake/io.py | 6 ++-- snakemake/report/__init__.py | 22 ++++++------ snakemake/report/data/results.py | 2 +- .../template/components/abstract_results.js | 34 +++++++++---------- .../report/template/components/result_info.js | 12 +++---- snakemake/rules.py | 2 +- tests/test_report/Snakefile | 4 +-- 7 files changed, 41 insertions(+), 41 deletions(-) diff --git a/snakemake/io.py b/snakemake/io.py index 42cefb40f..d22086025 100755 --- a/snakemake/io.py +++ b/snakemake/io.py @@ -1081,7 +1081,7 @@ def checkpoint_target(value): ReportObject = collections.namedtuple( "ReportObject", - ["caption", "category", "subcategory", "columns", "patterns", "htmlindex"], + ["caption", "category", "subcategory", "labels", "patterns", "htmlindex"], ) @@ -1090,7 +1090,7 @@ def report( caption=None, category=None, subcategory=None, - columns=None, + labels=None, patterns=[], htmlindex=None, ): @@ -1111,7 +1111,7 @@ def report( return flag( value, "report", - ReportObject(caption, category, subcategory, columns, patterns, htmlindex), + ReportObject(caption, category, subcategory, labels, patterns, htmlindex), ) diff --git a/snakemake/report/__init__.py b/snakemake/report/__init__.py index fff69c2be..dc0c7361d 100644 --- a/snakemake/report/__init__.py +++ b/snakemake/report/__init__.py @@ -418,9 +418,9 @@ def __init__( mode_embedded=True, aux_files=None, name_overwrite=None, - columns=None, + labels=None, ): - self.columns = columns + self.labels = labels self.name_overwrite = name_overwrite self.mode_embedded = mode_embedded self.path = path @@ -605,21 +605,21 @@ def get_resource_as_string(path_or_uri): ) -def expand_columns(columns, wildcards, job): - if columns is None: +def expand_labels(labels, wildcards, job): + if labels is None: return None - columns = expand_report_argument(columns, wildcards, job) + labels = expand_report_argument(labels, wildcards, job) - if not isinstance(columns, dict) or not all( - isinstance(col, str) for col in columns.values() + if not isinstance(labels, dict) or not all( + isinstance(col, str) for col in labels.values() ): raise WorkflowError( - "Expected dict of strings as columns argument given to report flag.", + "Expected dict of strings as labels argument given to report flag.", rule=job.rule, ) return { name: expand_report_argument(col, wildcards, job) - for name, col in columns.items() + for name, col in labels.items() } @@ -677,7 +677,7 @@ def register_file( subcategory = Category( report_obj.subcategory, wildcards=wildcards, job=job ) - columns = expand_columns(report_obj.columns, wildcards, job) + labels = expand_labels(report_obj.labels, wildcards, job) results[category][subcategory].append( FileRecord( @@ -691,7 +691,7 @@ def register_file( mode_embedded=mode_embedded, aux_files=aux_files, name_overwrite=name_overwrite, - columns=columns, + labels=labels, ) ) recorded_files.add(f) diff --git a/snakemake/report/data/results.py b/snakemake/report/data/results.py index 374cd370b..1cd4010fa 100644 --- a/snakemake/report/data/results.py +++ b/snakemake/report/data/results.py @@ -7,7 +7,7 @@ def render_results(results): res.path: { "name": res.name, "filename": res.filename, - "columns": res.columns, + "labels": res.labels, "size": res.size_mb, "caption": res.caption, "mime_type": res.mime, diff --git a/snakemake/report/template/components/abstract_results.js b/snakemake/report/template/components/abstract_results.js index 6d2d55c5f..ef5940435 100644 --- a/snakemake/report/template/components/abstract_results.js +++ b/snakemake/report/template/components/abstract_results.js @@ -38,26 +38,26 @@ class AbstractResults extends React.Component { throw new Error("Unimplemented!"); } - getColumns() { - return Array.from(new Set(this.getResults().map(function ([path, result]) { return Object.keys(result.columns) }).flat())).sort(); + getLabels() { + return Array.from(new Set(this.getResults().map(function ([path, result]) { return Object.keys(result.labels) }).flat())).sort(); } - isColumnBased() { + isLabelled() { return this.getResults().every(function ([path, result]) { - return result.columns; + return result.labels; }); } renderHeader() { - if (this.isColumnBased()) { + if (this.isLabelled()) { return e( "tr", {}, - this.getColumns().map(function (column) { + this.getLabels().map(function (label) { return e( "th", { className: "text-left p-1 uppercase" }, - column + label ) }), e( @@ -84,9 +84,9 @@ class AbstractResults extends React.Component { renderEntries() { let _this = this; - let columns = undefined; - if (this.isColumnBased()) { - columns = this.getColumns(); + let labels = undefined; + if (this.isLabelled()) { + labels = this.getLabels(); } return this.getResults().map(function ([path, entry]) { let actions = e( @@ -106,19 +106,19 @@ class AbstractResults extends React.Component { ) ); - let entryColumns = undefined; + let entryLabels = undefined; let key = undefined; - if (columns !== undefined) { - entryColumns = columns.map(function (column) { + if (labels !== undefined) { + entryLabels = labels.map(function (label) { return e( "td", { className: "p-1" }, - entry.columns[column] || "" + entry.labels[label] || "" ); }); - key = columns.join(); + key = labels.join(); } else { - entryColumns = e( + entryLabels = e( "td", { className: "p-1" }, path @@ -130,7 +130,7 @@ class AbstractResults extends React.Component { e( "tr", { key: key }, - entryColumns, + entryLabels, actions ) ]; diff --git a/snakemake/report/template/components/result_info.js b/snakemake/report/template/components/result_info.js index 2119bb4e3..6573d0491 100644 --- a/snakemake/report/template/components/result_info.js +++ b/snakemake/report/template/components/result_info.js @@ -20,8 +20,8 @@ class ResultInfo extends React.Component { getDescriptor() { let result = this.getResult(); - if (result.columns) { - const columns = Object.keys(result.columns).sort(); + if (result.labels) { + const labels = Object.keys(result.labels).sort(); return [ e( ListItem, @@ -35,11 +35,11 @@ class ResultInfo extends React.Component { e( "tr", {}, - columns.map(function (column) { + labels.map(function (label) { return e( "th", { className: "text-left uppercase pr-2" }, - column + label ); }) ) @@ -50,8 +50,8 @@ class ResultInfo extends React.Component { e( "tr", {}, - columns.map(function (column) { - const value = result.columns[column]; + labels.map(function (label) { + const value = result.labels[label]; return e( "td", { className: "pr-2" }, diff --git a/snakemake/rules.py b/snakemake/rules.py index 2d9c8fbb0..b647f249e 100644 --- a/snakemake/rules.py +++ b/snakemake/rules.py @@ -601,7 +601,7 @@ def _set_inoutput_item(self, item, output=False, name=None): self.workflow.current_basedir.join(report_obj.caption), report_obj.category, report_obj.subcategory, - report_obj.columns, + report_obj.labels, report_obj.patterns, report_obj.htmlindex, ) diff --git a/tests/test_report/Snakefile b/tests/test_report/Snakefile index c5960a38c..1b79ea4fc 100644 --- a/tests/test_report/Snakefile +++ b/tests/test_report/Snakefile @@ -23,7 +23,7 @@ rule a: input: expand("test.{i}.out", i=range(10)) output: - report("fig1.svg", caption="report/fig1.rst", category="Step 1", columns=lambda w, params: {"type": "figure", "num": "1"}) + report("fig1.svg", caption="report/fig1.rst", category="Step 1", labels=lambda w, params: {"type": "figure", "num": "1"}) shell: "sleep `shuf -i 1-3 -n 1`; cp data/fig1.svg {output}" @@ -32,7 +32,7 @@ rule b: input: expand("test.{i}.out", i=range(10)) output: - report("{model}.fig2.png", caption="report/fig2.rst", category=lambda w: "Step 2", subcategory="{model}", columns={"type": "figure", "model": "{model}"}) + report("{model}.fig2.png", caption="report/fig2.rst", category=lambda w: "Step 2", subcategory="{model}", labels={"type": "figure", "model": "{model}"}) shell: "sleep `shuf -i 1-3 -n 1`; cp data/fig2.png {output}" From 77f97c539339370fbee591877f651504ace7e532 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Johannes=20K=C3=B6ster?= Date: Thu, 10 Mar 2022 14:45:09 +0100 Subject: [PATCH 27/45] use chevron icon for breadcrumbs --- snakemake/report/template/components/breadcrumbs.js | 5 ++++- snakemake/report/template/components/icon.js | 3 +++ 2 files changed, 7 insertions(+), 1 deletion(-) diff --git a/snakemake/report/template/components/breadcrumbs.js b/snakemake/report/template/components/breadcrumbs.js index 49c5c6d7f..abaf9f2ae 100644 --- a/snakemake/report/template/components/breadcrumbs.js +++ b/snakemake/report/template/components/breadcrumbs.js @@ -61,7 +61,10 @@ class Breadcrumbs extends React.Component { e( "li", { key: `sep-${index}` }, - "/" + e( + Icon, + { iconName: "chevron-right", className: "text-emerald-500" } + ) ) ]; } diff --git a/snakemake/report/template/components/icon.js b/snakemake/report/template/components/icon.js index dcb3086e9..d7302fa2f 100644 --- a/snakemake/report/template/components/icon.js +++ b/snakemake/report/template/components/icon.js @@ -3,6 +3,9 @@ class Icon extends React.Component { // paths are imported from https://heroicons.com paths = { + "chevron-right": [ + { rule: "evenodd", path: "M7.293 14.707a1 1 0 010-1.414L10.586 10 7.293 6.707a1 1 0 011.414-1.414l4 4a1 1 0 010 1.414l-4 4a1 1 0 01-1.414 0z" } + ] "menu": [ { rule: "evenodd", path: "M3 5a1 1 0 011-1h12a1 1 0 110 2H4a1 1 0 01-1-1zM3 10a1 1 0 011-1h12a1 1 0 110 2H4a1 1 0 01-1-1zM3 15a1 1 0 011-1h12a1 1 0 110 2H4a1 1 0 01-1-1z" } ], From 824e0cbd83ea84bcb5b649f0f8b972da41d7e28c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Johannes=20K=C3=B6ster?= Date: Thu, 10 Mar 2022 14:46:58 +0100 Subject: [PATCH 28/45] fix --- snakemake/report/template/components/icon.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/snakemake/report/template/components/icon.js b/snakemake/report/template/components/icon.js index d7302fa2f..240a029b1 100644 --- a/snakemake/report/template/components/icon.js +++ b/snakemake/report/template/components/icon.js @@ -5,7 +5,7 @@ class Icon extends React.Component { paths = { "chevron-right": [ { rule: "evenodd", path: "M7.293 14.707a1 1 0 010-1.414L10.586 10 7.293 6.707a1 1 0 011.414-1.414l4 4a1 1 0 010 1.414l-4 4a1 1 0 01-1.414 0z" } - ] + ], "menu": [ { rule: "evenodd", path: "M3 5a1 1 0 011-1h12a1 1 0 110 2H4a1 1 0 01-1-1zM3 10a1 1 0 011-1h12a1 1 0 110 2H4a1 1 0 01-1-1zM3 15a1 1 0 011-1h12a1 1 0 110 2H4a1 1 0 01-1-1z" } ], From 7297c377695100041c51f91ccdac19686986ac36 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Johannes=20K=C3=B6ster?= Date: Thu, 10 Mar 2022 14:49:24 +0100 Subject: [PATCH 29/45] padding --- snakemake/report/template/components/content.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/snakemake/report/template/components/content.js b/snakemake/report/template/components/content.js index bd2605460..81007ff0a 100644 --- a/snakemake/report/template/components/content.js +++ b/snakemake/report/template/components/content.js @@ -10,7 +10,7 @@ class ContentDisplay extends React.Component { render() { return e( "div", - { className: "flex items-center justify-center min-h-screen z-0" }, + { className: "flex items-center justify-center min-h-screen z-0 p-3" }, this.renderContent() ) } From 727857750fd117b369994c1a8ee3d886e0c9cef3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Johannes=20K=C3=B6ster?= Date: Thu, 10 Mar 2022 15:39:38 +0100 Subject: [PATCH 30/45] overflow and code display polish --- snakemake/report/__init__.py | 13 +++++-------- snakemake/report/template/components/navbar.js | 2 +- .../report/template/components/rule_info.js | 18 ++++++++---------- 3 files changed, 14 insertions(+), 19 deletions(-) diff --git a/snakemake/report/__init__.py b/snakemake/report/__init__.py index dc0c7361d..ce92390ec 100644 --- a/snakemake/report/__init__.py +++ b/snakemake/report/__init__.py @@ -325,14 +325,11 @@ def code(self): try: lexer = get_lexer_by_name(language) - highlighted = [ - highlight( - source, - lexer, - HtmlFormatter(linenos=True, cssclass="source", wrapcode=True), - ) - for source in sources - ] + highlighted = highlight( + "\n\n".join(sources), + lexer, + HtmlFormatter(linenos=True, cssclass="source", wrapcode=True), + ) return highlighted except pygments.util.ClassNotFound: diff --git a/snakemake/report/template/components/navbar.js b/snakemake/report/template/components/navbar.js index 19cda2d60..77a21f388 100644 --- a/snakemake/report/template/components/navbar.js +++ b/snakemake/report/template/components/navbar.js @@ -21,7 +21,7 @@ class Navbar extends React.Component { ), e( "nav", - { className: `fixed z-50 transition-all ${translateNavbar} ${this.getWidth()} min-w-fit text-white text-sm bg-slate-900/70 backdrop-blur-sm h-screen overflow-y-auto` }, + { className: `fixed z-50 transition-all ${translateNavbar} ${this.getWidth()} min-w-fit max-w-screen text-white text-sm bg-slate-900/70 backdrop-blur-sm h-screen overflow-auto` }, e( "h1", { className: "sticky bg-blur bg-white opacity-80 text-slate-700 text-l tracking-wide px-3 py-1 mb-1 flex items-center" }, diff --git a/snakemake/report/template/components/rule_info.js b/snakemake/report/template/components/rule_info.js index b43fb2c87..d2b942dac 100644 --- a/snakemake/report/template/components/rule_info.js +++ b/snakemake/report/template/components/rule_info.js @@ -43,16 +43,14 @@ class RuleInfo extends React.Component { ListHeading, { key: "code-heading", text: "Code" } ), - rule.code.map(function (block) { - return e( - ListItem, - { - key: "code", - className: "p-1", - dangerouslySetInnerHTML: { __html: block } - } - ) - }) + e( + ListItem, + { + key: "code", + className: "p-1", + dangerouslySetInnerHTML: { __html: rule.code } + } + ) ]; } else { return []; From 8be2830a582a915c8e34735ecd9f8d1c9827a86c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Johannes=20K=C3=B6ster?= Date: Thu, 10 Mar 2022 16:49:30 +0100 Subject: [PATCH 31/45] scrolling fixes --- .../report/template/components/navbar.js | 24 +++++++++++++------ 1 file changed, 17 insertions(+), 7 deletions(-) diff --git a/snakemake/report/template/components/navbar.js b/snakemake/report/template/components/navbar.js index 77a21f388..54e51af24 100644 --- a/snakemake/report/template/components/navbar.js +++ b/snakemake/report/template/components/navbar.js @@ -21,7 +21,7 @@ class Navbar extends React.Component { ), e( "nav", - { className: `fixed z-50 transition-all ${translateNavbar} ${this.getWidth()} min-w-fit max-w-screen text-white text-sm bg-slate-900/70 backdrop-blur-sm h-screen overflow-auto` }, + { className: `fixed z-50 transition-all ${translateNavbar} ${this.getWidth()} text-white text-sm bg-slate-900/70 backdrop-blur-sm h-screen` }, e( "h1", { className: "sticky bg-blur bg-white opacity-80 text-slate-700 text-l tracking-wide px-3 py-1 mb-1 flex items-center" }, @@ -41,11 +41,15 @@ class Navbar extends React.Component { ), this.getHideButton() ), - this.renderBreadcrumbs(), e( "div", - { className: "p-3" }, - this.renderContent() + { className: "overflow-auto" }, + this.renderBreadcrumbs(), + e( + "div", + { className: "p-3" }, + this.renderContent() + ) ) ) ]; @@ -220,11 +224,17 @@ class Navbar extends React.Component { getWidth() { switch (this.props.app.state.navbarMode) { case "menu": - return "w-1/5" + return "w-1/5 min-w-fit" case "category": - return "w-1/3" + case "subcategory": + case "searchresults": + return "w-1/4 min-w-fit" case "resultinfo": - return "w-3/4" + return "w-1/2" + case "ruleinfo": + return "w-1/2" + default: + return "w-1/5 min-w-fit" } } } \ No newline at end of file From 4beb587611584b67c9739c15892150c038a2d3a4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Johannes=20K=C3=B6ster?= Date: Thu, 10 Mar 2022 16:58:36 +0100 Subject: [PATCH 32/45] static tailwind --- snakemake/report/template/index.html.jinja2 | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/snakemake/report/template/index.html.jinja2 b/snakemake/report/template/index.html.jinja2 index a46ed8713..2f61878c2 100644 --- a/snakemake/report/template/index.html.jinja2 +++ b/snakemake/report/template/index.html.jinja2 @@ -9,7 +9,7 @@ Snakemake Report - + From b0df7972aedc661633548a0fa319f058c030eb27 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Johannes=20K=C3=B6ster?= Date: Thu, 10 Mar 2022 17:20:12 +0100 Subject: [PATCH 33/45] loading screen --- snakemake/report/template/index.html.jinja2 | 12 +++++++++++ snakemake/report/template/style.css | 22 +++++++++++++++++++++ 2 files changed, 34 insertions(+) diff --git a/snakemake/report/template/index.html.jinja2 b/snakemake/report/template/index.html.jinja2 index 2f61878c2..42851b970 100644 --- a/snakemake/report/template/index.html.jinja2 +++ b/snakemake/report/template/index.html.jinja2 @@ -20,6 +20,14 @@ +
+

Loading Snakemake Report...

+

Please enable Javascript in your browser to see this report.

+
+ +
@@ -79,6 +87,10 @@ + + \ No newline at end of file diff --git a/snakemake/report/template/style.css b/snakemake/report/template/style.css index dd63f225d..62cfb1d44 100644 --- a/snakemake/report/template/style.css +++ b/snakemake/report/template/style.css @@ -5,4 +5,26 @@ .source { background-color: transparent!important; +} + +#loading-screen { + background-color: white; + width: 100%; + height: 100%; + position: fixed; + top: 0; + left: 0; + z-index: 2000; + padding-top: 50vh; +} + +#loading-screen .animation { + animation: fadeinout 2.5s infinite; + text-align: center; + font-size: 200%; +} + +#loading-screen #jswarning { + text-align: center; + color: red; } \ No newline at end of file From e3246a668905d8a4076c54168fdfb40ecece7cbc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Johannes=20K=C3=B6ster?= Date: Thu, 10 Mar 2022 17:29:13 +0100 Subject: [PATCH 34/45] fixes and cleanup --- snakemake/report/controller.js | 22 - snakemake/report/events.js | 3 - snakemake/report/logo.svg | 7 - snakemake/report/report.html.jinja2 | 705 -------------------- snakemake/report/style.css | 314 --------- snakemake/report/template/index.html.jinja2 | 2 +- snakemake/report/template/style.css | 16 +- 7 files changed, 15 insertions(+), 1054 deletions(-) delete mode 100644 snakemake/report/controller.js delete mode 100644 snakemake/report/events.js delete mode 100644 snakemake/report/logo.svg delete mode 100644 snakemake/report/report.html.jinja2 delete mode 100644 snakemake/report/style.css diff --git a/snakemake/report/controller.js b/snakemake/report/controller.js deleted file mode 100644 index 89b4e204b..000000000 --- a/snakemake/report/controller.js +++ /dev/null @@ -1,22 +0,0 @@ -sidebar_controller = { - collapsed: false, - content: "nav", - - toggle: function() { - if (this.collapsed) { - this.collapsed = false - $("#sidebar-content").show() - $("#show-hide-button svg").replaceWith(feather.icons["arrow-left"].toSvg()) - } else { - this.collapsed = true - $("#sidebar-content").hide() - $("#show-hide-button svg").replaceWith(feather.icons["arrow-right"].toSvg()) - } - }, - - show: function(content) { - $(`#${this.content}`).hide() - $(`#${content}`).show() - this.content = content - } -} \ No newline at end of file diff --git a/snakemake/report/events.js b/snakemake/report/events.js deleted file mode 100644 index 0099e3198..000000000 --- a/snakemake/report/events.js +++ /dev/null @@ -1,3 +0,0 @@ -$("#show-hide-button").click(function() { - sidebar_controller.toggle() -}) \ No newline at end of file diff --git a/snakemake/report/logo.svg b/snakemake/report/logo.svg deleted file mode 100644 index 8362455cd..000000000 --- a/snakemake/report/logo.svg +++ /dev/null @@ -1,7 +0,0 @@ - - - - - - - \ No newline at end of file diff --git a/snakemake/report/report.html.jinja2 b/snakemake/report/report.html.jinja2 deleted file mode 100644 index 5cc9f99b3..000000000 --- a/snakemake/report/report.html.jinja2 +++ /dev/null @@ -1,705 +0,0 @@ - - - - - - - - - Snakemake Report - - - - - - - - - - - {% if custom_stylesheet is not none %} - - {% endif %} - - - -
-

Loading Snakemake Report...

-

Please enable Javascript in your browser to see this report.

- {% if mode_embedded %} -

Loading {{ results_size|filesizeformat }}. For large reports, this can take a while.

- {% endif %} -
- -
-
-
-
-

Snakemake Report

-
- - - - - -
- -
-
-
- -
- - - -
-
- -
-
-
-
-
-
-
-
-
-
- - {% for cat, subcats in results|dictsort %} -
-

{{ cat.name }}

- {% for subcat, catresults in subcats|dictsort %} - {% if subcats|length > 1 or not subcat.is_other %} -

{{ subcat.name }}

- {% endif %} -
- {% if not loop.last %} -
- {% endif %} - {% endfor %} -
- {% endfor %} - -
-

Statistics

- If the workflow has been executed in cluster/cloud, runtimes include the waiting time in the queue. -
-
-
-
-
-
-
-
-
- - {% if configfiles %} -
-

Configuration

- - - - - - - - - - {% for configfile in configfiles %} - - - - - {% endfor %} - -
Configuration files
FileCode
{{ configfile.name }} - -
- {{ configfile.code()|safe }} -
-
-
- {% endif %} - -
-

Loading...

-
-
- - - - {% for rule in rules %} - - {% endfor %} -
-
- - - - - - - - - - - - - {% if mode_embedded %} - - {% endif %} - - - - - - - - - - - - diff --git a/snakemake/report/style.css b/snakemake/report/style.css deleted file mode 100644 index 4a899208d..000000000 --- a/snakemake/report/style.css +++ /dev/null @@ -1,314 +0,0 @@ -body { - font-size: .875rem; -} - -.feather { - width: 16px; - height: 16px; - vertical-align: text-bottom; -} - - -/* Sidebar */ - -.sidebar { - position: fixed; - top: 0; - bottom: 0; - left: 0; - z-index: 100; -} - -#sidebar-content { - display: flex; - flex-direction: column; - align-items: stretch; - padding-top: 15px; - padding-left: 0px; - padding-right: 0px; - height: 100vh; - transition: width 2s; -} - -.sidebar-background { - opacity: 80%; -} - -.sidebar #nav { - flex-grow: 1; - overflow-y: auto; -} - -.sidebar p { - margin-left: 15px; - margin-right: 15px; -} - -.sidebar #title { - letter-spacing: 0.1em; -} - -.sidebar #title #logo { - height: 1.5em; - margin: 1em; - vertical-align: middle; -} - -.sidebar .nav-link { - font-weight: 500; - color: white; -} - -.sidebar .nav-link:hover { - font-weight: 500; - color: black; - background-color: white; -} - -.sidebar-heading { - font-size: .75rem; - text-transform: uppercase; -} - -.sidebar #show-hide-container { - height: 100vh; - display: flex; - justify-content: center; - align-items: center; -} - -#show-hide-button { - padding-top: 3em; - padding-bottom: 3em; - border: 1px solid #343a40; -} - -#show-hide-button#hover { - color: black; - background-color: white!important; - border: 1px solid #343a40; -} - - -/* Content */ - -[role="main"] { - padding-top: 65px; - /* Space for fixed navbar */ -} - -*[id]:before { - display: block; - content: " "; - margin-top: -75px; - height: 75px; - visibility: hidden; -} - - -/* Navbar */ - -.navbar-brand { - padding-top: .75rem; - padding-bottom: .75rem; - font-size: 1rem; - font-weight: bold; - background-color: rgba(0, 0, 0, .25); - box-shadow: inset -1px 0 0 rgba(0, 0, 0, .25); -} - -.navbar .form-control { - padding: .75rem 1rem; - border-width: 0; - border-radius: 0; -} - -.form-control-dark { - color: #fff; - background-color: rgba(255, 255, 255, .1); - border-color: rgba(255, 255, 255, .1); -} - -.form-control-dark:focus { - border-color: transparent; - box-shadow: 0 0 0 3px rgba(255, 255, 255, .25); -} - - -/* Utilities */ - -.border-top { - border-top: 1px solid #e5e5e5; -} - -.border-bottom { - border-bottom: 1px solid #e5e5e5; -} - - -/* Snakemake specific */ - -.result img { - max-width: 100vw; -} - -.result .preview { - text-align: center; -} - -#rulegraph canvas { - display: block; - max-width: 100vw; - margin-left: auto; - margin-right: auto; -} - -@keyframes fadeinout { - 0% { - opacity: 1; - } - 50% { - opacity: 0; - } - 100% { - opacity: 1; - } -} - -#loading-screen { - background-color: white; - width: 100%; - height: 100%; - position: fixed; - top: 0; - left: 0; - z-index: 2000; - padding-top: 50vh; -} - -p.animation { - animation: fadeinout 2.5s infinite; - text-align: center; - font-size: 200%; -} - -#loading-screen p#info { - text-align: center; - color: grey; -} - -#loading-screen p#jswarning { - text-align: center; - color: red; -} - -#panel-loading-screen { - width: 100%; - height: 100%; - padding-top: 50vh; -} - -#panel-loading-sceen p.animation { - margin: auto; -} - -.vega-actions .btn { - font-size: 100%; -} - -.plot { - text-align: center; -} - -h6.sidebar-heading { - text-transform: none; -} - -.preview { - text-align: right; -} - -.ekko-lightbox-nav-overlay a span { - color: lightgrey; -} - -.navbar { - opacity: 0.8; -} - -.source { - background: none !important; - overflow-x: auto; - width: 100%; -} - -table.dataTable tbody tr.selected, -table.dataTable tbody th.selected, -table.dataTable tbody td.selected { - color: black; - font-weight: bold; -} - -table.dataTable tbody tr.selected td:first-of-type { - font-weight: bold; -} - -table.dataTable tbody tr.selected td { - border-top: 1px solid #007bff; - border-bottom: 1px solid #007bff; -} - -table.dataTable tbody>tr.selected, -table.dataTable tbody>tr>.selected { - background-color: transparent; -} - -table.dataTable tbody tr.selected a, -table.dataTable tbody th.selected a, -table.dataTable tbody td.selected a { - color: #007bff; -} - -table caption { - display: none; -} - -table.results-table { - width: 100%; - margin-bottom: 4em; -} - -.rule-property { - overflow-y: auto; - max-height: 10em; -} - -.panel { - display: none; -} - -.panel#workflow { - display: block; -} - -.ruletable th { - width: 1px; -} - -.rule-properties ul { - padding-left: 1.2em; -} - -#thumbnail-modal .modal-body { - overflow: auto; - text-align: center; -} - -.category pre { - max-width: 20vw; - max-height: 10vh; -} - -.modal-lg { - max-width: 95%; -} \ No newline at end of file diff --git a/snakemake/report/template/index.html.jinja2 b/snakemake/report/template/index.html.jinja2 index 42851b970..3c8f69015 100644 --- a/snakemake/report/template/index.html.jinja2 +++ b/snakemake/report/template/index.html.jinja2 @@ -21,7 +21,7 @@
-

Loading Snakemake Report...

+

Loading Snakemake Report...

Please enable Javascript in your browser to see this report.

+ + From bbe6fb9bb2e705d81d9e8e41d39aaf68c6c8b502 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Johannes=20K=C3=B6ster?= Date: Fri, 11 Mar 2022 12:17:46 +0100 Subject: [PATCH 40/45] cleanup --- snakemake/report/template/categories.js | 21 --- snakemake/report/template/results.js | 94 ------------- snakemake/report/template/rulegraph.js | 142 -------------------- snakemake/report/template/rulegraph_spec.js | 142 -------------------- snakemake/report/template/rules.js | 20 --- snakemake/report/template/runtimes.js | 15 --- snakemake/report/template/timeline.js | 20 --- 7 files changed, 454 deletions(-) delete mode 100644 snakemake/report/template/categories.js delete mode 100644 snakemake/report/template/results.js delete mode 100644 snakemake/report/template/rulegraph.js delete mode 100644 snakemake/report/template/rulegraph_spec.js delete mode 100644 snakemake/report/template/rules.js delete mode 100644 snakemake/report/template/runtimes.js delete mode 100644 snakemake/report/template/timeline.js diff --git a/snakemake/report/template/categories.js b/snakemake/report/template/categories.js deleted file mode 100644 index c55585e14..000000000 --- a/snakemake/report/template/categories.js +++ /dev/null @@ -1,21 +0,0 @@ -var categories = { - "Foo": { - "Sub": [ - "testdir/1.txt", - "test.csv" - ], - "Other": [] - }, - "Bar": { - "Other": [ - "testdir/2.txt", - "testdir/3.txt" - ] - }, - "Other": { - "Other": [ - "fig1.svg", - "testmodel.fig2.png" - ] - } -} \ No newline at end of file diff --git a/snakemake/report/template/results.js b/snakemake/report/template/results.js deleted file mode 100644 index 92b9042bb..000000000 --- a/snakemake/report/template/results.js +++ /dev/null @@ -1,94 +0,0 @@ -var results = { - "testdir/1.txt": { - name: "1.txt", - filename: "1.txt", - path: "testdir/1.txt", - size: "2 Bytes", - caption: "

Files obtained from a directory. This file starts with 1. This value has been dynamically inferred from the given pattern.

\n", - job_properties: { - rule: "e", - wildcards: "name=1", - params: "" - }, - data_uri: function () { return "data:text/plain;charset=utf8;filename=1.txt;base64,MQo="; }, - thumbnail_uri: function () { return null; } - }, - "testdir/2.txt": { - name: "2.txt", - filename: "2.txt", - path: "testdir/2.txt", - size: "2 Bytes", - caption: "

Files obtained from a directory. This file starts with 2. This value has been dynamically inferred from the given pattern.

\n", - job_properties: { - rule: "e", - wildcards: "name=2", - params: "" - }, - data_uri: function () { return "data:text/plain;charset=utf8;filename=2.txt;base64,Mgo="; }, - thumbnail_uri: function () { return null; } - }, - "testdir/3.txt": { - name: "3.txt", - filename: "3.txt", - path: "testdir/3.txt", - size: "2 Bytes", - caption: "

Files obtained from a directory. This file starts with 3. This value has been dynamically inferred from the given pattern.

\n", - job_properties: { - rule: "e", - wildcards: "name=3", - params: "" - }, - data_uri: function () { return "data:text/plain;charset=utf8;filename=3.txt;base64,Mwo="; }, - thumbnail_uri: function () { return null; } - }, - "test.csv": { - name: "test.csv", - filename: "test.csv", - path: "test.csv", - size: "113.2 kB", - caption: "

An example table.

\n", - job_properties: { - rule: "d", - wildcards: "", - params: "" - }, - data_uri: function () { return "data:text/csv;charset=utf8;filename=test.csv;base64,street,city,zip,state,beds,baths,sq__ft,type,sale_date,price,latitude,longitude3526 HIGH ST,SACRAMENTO,95838,CA,2,1,836,Residential,Wed May 21 00:00:00 EDT 2008,59222,38.631913,-121.43487951 OMAHA CT,SACRAMENTO,95823,CA,3,1,1167,Residential,Wed May 21 00:00:00 EDT 2008,68212,38.478902,-121.4310282796 BRANCH ST,SACRAMENTO,95815,CA,2,1,796,Residential,Wed May 21 00:00:00 EDT 2008,68880,38.618305,-121.4438392805 JANETTE WAY,SACRAMENTO,95815,CA,2,1,852,Residential,Wed May 21 00:00:00 EDT 2008,69307,38.616835,-121.4391466001 MCMAHON DR,SACRAMENTO,95824,CA,2,1,797,Residential,Wed May 21 00:00:00 EDT 2008,81900,38.51947,-121.4357685828 PEPPERMILL CT,SACRAMENTO,95841,CA,3,1,1122,Condo,Wed May 21 00:00:00 EDT 2008,89921,38.662595,-121.3278136048 OGDEN NASH WAY,SACRAMENTO,95842,CA,3,2,1104,Residential,Wed May 21 00:00:00 EDT 2008,90895,38.681659,-121.3517052561 19TH AVE,SACRAMENTO,95820,CA,3,1,1177,Residential,Wed May 21 00:00:00 EDT 2008,91002,38.535092,-121.48136711150 TRINITY RIVER DR Unit 114,RANCHO CORDOVA,95670,CA,2,2,941,Condo,Wed May 21 00:00:00 EDT 2008,94905,38.621188,-121.2705557325 10TH ST,RIO LINDA,95673,CA,3,2,1146,Residential,Wed May 21 00:00:00 EDT 2008,98937,38.700909,-121.442979645 MORRISON AVE,SACRAMENTO,95838,CA,3,2,909,Residential,Wed May 21 00:00:00 EDT 2008,100309,38.637663,-121.451524085 FAWN CIR,SACRAMENTO,95823,CA,3,2,1289,Residential,Wed May 21 00:00:00 EDT 2008,106250,38.470746,-121.4589182930 LA ROSA RD,SACRAMENTO,95815,CA,1,1,871,Residential,Wed May 21 00:00:00 EDT 2008,106852,38.618698,-121.4358332113 KIRK WAY,SACRAMENTO,95822,CA,3,1,1020,Residential,Wed May 21 00:00:00 EDT 2008,107502,38.482215,-121.4926034533 LOCH HAVEN WAY,SACRAMENTO,95842,CA,2,2,1022,Residential,Wed May 21 00:00:00 EDT 2008,108750,38.672914,-121.359347340 HAMDEN PL,SACRAMENTO,95842,CA,2,2,1134,Condo,Wed May 21 00:00:00 EDT 2008,110700,38.700051,-121.3512786715 6TH ST,RIO LINDA,95673,CA,2,1,844,Residential,Wed May 21 00:00:00 EDT 2008,113263,38.689591,-121.4522396236 LONGFORD DR Unit 1,CITRUS HEIGHTS,95621,CA,2,1,795,Condo,Wed May 21 00:00:00 EDT 2008,116250,38.679776,-121.314089250 PERALTA AVE,SACRAMENTO,95833,CA,2,1,588,Residential,Wed May 21 00:00:00 EDT 2008,120000,38.612099,-121.469095113 LEEWILL AVE,RIO LINDA,95673,CA,3,2,1356,Residential,Wed May 21 00:00:00 EDT 2008,121630,38.689999,-121.463226118 STONEHAND AVE,CITRUS HEIGHTS,95621,CA,3,2,1118,Residential,Wed May 21 00:00:00 EDT 2008,122000,38.707851,-121.3207074882 BANDALIN WAY,SACRAMENTO,95823,CA,4,2,1329,Residential,Wed May 21 00:00:00 EDT 2008,122682,38.468173,-121.4440717511 OAKVALE CT,NORTH HIGHLANDS,95660,CA,4,2,1240,Residential,Wed May 21 00:00:00 EDT 2008,123000,38.702792,-121.382219 PASTURE CT,SACRAMENTO,95834,CA,3,2,1601,Residential,Wed May 21 00:00:00 EDT 2008,124100,38.628631,-121.4880973729 BAINBRIDGE DR,NORTH HIGHLANDS,95660,CA,3,2,901,Residential,Wed May 21 00:00:00 EDT 2008,125000,38.701499,-121.376223828 BLACKFOOT WAY,ANTELOPE,95843,CA,3,2,1088,Residential,Wed May 21 00:00:00 EDT 2008,126640,38.70974,-121.373774108 NORTON WAY,SACRAMENTO,95820,CA,3,1,963,Residential,Wed May 21 00:00:00 EDT 2008,127281,38.537526,-121.4783151469 JANRICK AVE,SACRAMENTO,95832,CA,3,2,1119,Residential,Wed May 21 00:00:00 EDT 2008,129000,38.476472,-121.5017119861 CULP WAY,SACRAMENTO,95827,CA,4,2,1380,Residential,Wed May 21 00:00:00 EDT 2008,131200,38.558423,-121.3279487825 CREEK VALLEY CIR,SACRAMENTO,95828,CA,3,2,1248,Residential,Wed May 21 00:00:00 EDT 2008,132000,38.472122,-121.4041995201 LAGUNA OAKS DR Unit 140,ELK GROVE,95758,CA,2,2,1039,Condo,Wed May 21 00:00:00 EDT 2008,133000,38.423251,-121.4444896768 MEDORA DR,NORTH HIGHLANDS,95660,CA,3,2,1152,Residential,Wed May 21 00:00:00 EDT 2008,134555,38.691161,-121.371923100 EXPLORER DR,SACRAMENTO,95827,CA,3,2,1380,Residential,Wed May 21 00:00:00 EDT 2008,136500,38.566663,-121.3326447944 DOMINION WAY,ELVERTA,95626,CA,3,2,1116,Residential,Wed May 21 00:00:00 EDT 2008,138750,38.713182,-121.4112275201 LAGUNA OAKS DR Unit 162,ELK GROVE,95758,CA,2,2,1039,Condo,Wed May 21 00:00:00 EDT 2008,141000,38.423251,-121.4444893920 SHINING STAR DR,SACRAMENTO,95823,CA,3,2,1418,Residential,Wed May 21 00:00:00 EDT 2008,146250,38.48742,-121.4624595031 CORVAIR ST,NORTH HIGHLANDS,95660,CA,3,2,1082,Residential,Wed May 21 00:00:00 EDT 2008,147308,38.658246,-121.3754697661 NIXOS WAY,SACRAMENTO,95823,CA,4,2,1472,Residential,Wed May 21 00:00:00 EDT 2008,148750,38.479553,-121.4633177044 CARTHY WAY,SACRAMENTO,95828,CA,4,2,1146,Residential,Wed May 21 00:00:00 EDT 2008,149593,38.49857,-121.4209252442 LARKSPUR LN,SACRAMENTO,95825,CA,1,1,760,Condo,Wed May 21 00:00:00 EDT 2008,150000,38.58514,-121.4037364800 WESTLAKE PKWY Unit 2109,SACRAMENTO,95835,CA,2,2,1304,Condo,Wed May 21 00:00:00 EDT 2008,152000,38.658812,-121.5423452178 63RD AVE,SACRAMENTO,95822,CA,3,2,1207,Residential,Wed May 21 00:00:00 EDT 2008,154000,38.493955,-121.489668718 ELK WAY,ELK GROVE,95624,CA,3,2,1056,Residential,Wed May 21 00:00:00 EDT 2008,156896,38.41653,-121.3796535708 RIDGEPOINT DR,ANTELOPE,95843,CA,2,2,1043,Residential,Wed May 21 00:00:00 EDT 2008,161250,38.72027,-121.3315557315 KOALA CT,NORTH HIGHLANDS,95660,CA,4,2,1587,Residential,Wed May 21 00:00:00 EDT 2008,161500,38.699251,-121.3714142622 ERIN DR,SACRAMENTO,95833,CA,4,1,1120,Residential,Wed May 21 00:00:00 EDT 2008,164000,38.613765,-121.4886948421 SUNBLAZE WAY,SACRAMENTO,95823,CA,4,2,1580,Residential,Wed May 21 00:00:00 EDT 2008,165000,38.450543,-121.4325387420 ALIX PKWY,SACRAMENTO,95823,CA,4,1,1955,Residential,Wed May 21 00:00:00 EDT 2008,166357,38.489405,-121.4528113820 NATOMA WAY,SACRAMENTO,95838,CA,4,2,1656,Residential,Wed May 21 00:00:00 EDT 2008,166357,38.636748,-121.4221594431 GREEN TREE DR,SACRAMENTO,95823,CA,3,2,1477,Residential,Wed May 21 00:00:00 EDT 2008,168000,38.499954,-121.4544699417 SARA ST,ELK GROVE,95624,CA,3,2,1188,Residential,Wed May 21 00:00:00 EDT 2008,170000,38.415518,-121.3705278299 HALBRITE WAY,SACRAMENTO,95828,CA,4,2,1590,Residential,Wed May 21 00:00:00 EDT 2008,173000,38.473814,-121.47223 KALLIE KAY LN,SACRAMENTO,95823,CA,3,2,1463,Residential,Wed May 21 00:00:00 EDT 2008,174250,38.477553,-121.4194638156 STEINBECK WAY,SACRAMENTO,95828,CA,4,2,1714,Residential,Wed May 21 00:00:00 EDT 2008,174313,38.474853,-121.4063267957 VALLEY GREEN DR,SACRAMENTO,95823,CA,3,2,1185,Residential,Wed May 21 00:00:00 EDT 2008,178480,38.465184,-121.4349251122 WILD POPPY CT,GALT,95632,CA,3,2,1406,Residential,Wed May 21 00:00:00 EDT 2008,178760,38.287789,-121.2947154520 BOMARK WAY,SACRAMENTO,95842,CA,4,2,1943,Multi-Family,Wed May 21 00:00:00 EDT 2008,179580,38.665724,-121.3585769012 KIEFER BLVD,SACRAMENTO,95826,CA,3,2,1172,Residential,Wed May 21 00:00:00 EDT 2008,181000,38.547011,-121.3662175332 SANDSTONE ST,CARMICHAEL,95608,CA,3,1,1152,Residential,Wed May 21 00:00:00 EDT 2008,181872,38.662105,-121.3139455993 SAWYER CIR,SACRAMENTO,95823,CA,4,3,1851,Residential,Wed May 21 00:00:00 EDT 2008,182587,38.4473,-121.4352184844 CLYDEBANK WAY,ANTELOPE,95843,CA,3,2,1215,Residential,Wed May 21 00:00:00 EDT 2008,182716,38.714609,-121.347887306 CAMELLIA WAY,GALT,95632,CA,3,2,1130,Residential,Wed May 21 00:00:00 EDT 2008,182750,38.260443,-121.2978649021 MADISON AVE,ORANGEVALE,95662,CA,4,2,1603,Residential,Wed May 21 00:00:00 EDT 2008,183200,38.664186,-121.217511404 6TH ST,GALT,95632,CA,3,1,1479,Residential,Wed May 21 00:00:00 EDT 2008,188741,38.251808,-121.3024938317 SUNNY CREEK WAY,SACRAMENTO,95823,CA,3,2,1420,Residential,Wed May 21 00:00:00 EDT 2008,189000,38.459041,-121.4246442617 BASS CT,SACRAMENTO,95826,CA,3,2,1280,Residential,Wed May 21 00:00:00 EDT 2008,192067,38.560767,-121.3774717005 TIANT WAY,ELK GROVE,95758,CA,3,2,1586,Residential,Wed May 21 00:00:00 EDT 2008,194000,38.422811,-121.4232857895 CABER WAY,ANTELOPE,95843,CA,3,2,1362,Residential,Wed May 21 00:00:00 EDT 2008,194818,38.711279,-121.3934497624 BOGEY CT,SACRAMENTO,95828,CA,4,4,2162,Multi-Family,Wed May 21 00:00:00 EDT 2008,195000,38.48009,-121.4151026930 HAMPTON COVE WAY,SACRAMENTO,95823,CA,3,2,1266,Residential,Wed May 21 00:00:00 EDT 2008,198000,38.44004,-121.4210128708 MESA BROOK WAY,ELK GROVE,95624,CA,4,2,1715,Residential,Wed May 21 00:00:00 EDT 2008,199500,38.44076,-121.385792120 GRANT LN,FOLSOM,95630,CA,3,2,1820,Residential,Wed May 21 00:00:00 EDT 2008,200000,38.687742,-121.171045907 ELLERSLEE DR,CARMICHAEL,95608,CA,3,1,936,Residential,Wed May 21 00:00:00 EDT 2008,200000,38.664468,-121.3268317 SERASPI CT,SACRAMENTO,95834,CA,0,0,0,Residential,Wed May 21 00:00:00 EDT 2008,206000,38.631481,-121.50188170 PENHOW CIR,SACRAMENTO,95834,CA,3,2,1511,Residential,Wed May 21 00:00:00 EDT 2008,208000,38.653439,-121.5351698345 STAR THISTLE WAY,SACRAMENTO,95823,CA,4,2,1590,Residential,Wed May 21 00:00:00 EDT 2008,212864,38.454349,-121.4392399080 FRESCA WAY,ELK GROVE,95758,CA,4,2,1596,Residential,Wed May 21 00:00:00 EDT 2008,221000,38.427818,-121.424026391 NATALINO CIR,SACRAMENTO,95835,CA,2,2,1341,Residential,Wed May 21 00:00:00 EDT 2008,221000,38.67307,-121.5063738373 BLACKMAN WAY,ELK GROVE,95624,CA,5,3,2136,Residential,Wed May 21 00:00:00 EDT 2008,223058,38.435436,-121.3945369837 CORTE DORADO CT,ELK GROVE,95624,CA,4,2,1616,Residential,Wed May 21 00:00:00 EDT 2008,227887,38.400676,-121.381015037 J PKWY,SACRAMENTO,95823,CA,3,2,1478,Residential,Wed May 21 00:00:00 EDT 2008,231477,38.491399,-121.44354710245 LOS PALOS DR,RANCHO CORDOVA,95670,CA,3,2,1287,Residential,Wed May 21 00:00:00 EDT 2008,234697,38.593699,-121.310896613 NAVION DR,CITRUS HEIGHTS,95621,CA,4,2,1277,Residential,Wed May 21 00:00:00 EDT 2008,235000,38.702855,-121.313082887 AZEVEDO DR,SACRAMENTO,95833,CA,4,2,1448,Residential,Wed May 21 00:00:00 EDT 2008,236000,38.618457,-121.5094399186 KINBRACE CT,SACRAMENTO,95829,CA,4,3,2235,Residential,Wed May 21 00:00:00 EDT 2008,236685,38.463355,-121.3589364243 MIDDLEBURY WAY,MATHER,95655,CA,3,2,2093,Residential,Wed May 21 00:00:00 EDT 2008,237800,38.547991,-121.2804831028 FALLON PLACE CT,RIO LINDA,95673,CA,3,2,1193,Residential,Wed May 21 00:00:00 EDT 2008,240122,38.693818,-121.4411534804 NORIKER DR,ELK GROVE,95757,CA,3,2,2163,Residential,Wed May 21 00:00:00 EDT 2008,242638,38.400974,-121.4484247713 HARVEST WOODS DR,SACRAMENTO,95828,CA,3,2,1269,Residential,Wed May 21 00:00:00 EDT 2008,244000,38.478198,-121.4129112866 KARITSA AVE,SACRAMENTO,95833,CA,0,0,0,Residential,Wed May 21 00:00:00 EDT 2008,244500,38.626671,-121.525976913 RICHEVE WAY,SACRAMENTO,95828,CA,3,1,958,Residential,Wed May 21 00:00:00 EDT 2008,244960,38.502519,-121.4207698636 TEGEA WAY,ELK GROVE,95624,CA,5,3,2508,Residential,Wed May 21 00:00:00 EDT 2008,245918,38.443832,-121.3820875448 MAIDSTONE WAY,CITRUS HEIGHTS,95621,CA,3,2,1305,Residential,Wed May 21 00:00:00 EDT 2008,250000,38.665395,-121.29328818 OLLIE CT,ELK GROVE,95758,CA,4,2,1591,Residential,Wed May 21 00:00:00 EDT 2008,250000,38.444909,-121.4123454010 ALEX LN,CARMICHAEL,95608,CA,2,2,1326,Condo,Wed May 21 00:00:00 EDT 2008,250134,38.637028,-121.3129634901 MILLNER WAY,ELK GROVE,95757,CA,3,2,1843,Residential,Wed May 21 00:00:00 EDT 2008,254200,38.38692,-121.4473494818 BRITTNEY LEE CT,SACRAMENTO,95841,CA,4,2,1921,Residential,Wed May 21 00:00:00 EDT 2008,254200,38.653917,-121.342185529 LAGUNA PARK DR,ELK GROVE,95758,CA,5,3,2790,Residential,Wed May 21 00:00:00 EDT 2008,258000,38.42568,-121.438062230 CANDELA CIR,SACRAMENTO,95835,CA,3,2,1541,Residential,Wed May 21 00:00:00 EDT 2008,260000,38.656251,-121.5475724900 71ST ST,SACRAMENTO,95820,CA,3,1,1018,Residential,Wed May 21 00:00:00 EDT 2008,260014,38.53151,-121.42108912209 CONSERVANCY WAY,RANCHO CORDOVA,95742,CA,0,0,0,Residential,Wed May 21 00:00:00 EDT 2008,263500,38.553867,-121.2191414236 NATOMAS CENTRAL DR,SACRAMENTO,95834,CA,3,2,1672,Condo,Wed May 21 00:00:00 EDT 2008,265000,38.648879,-121.5440235615 LUPIN LN,POLLOCK PINES,95726,CA,3,2,1380,Residential,Wed May 21 00:00:00 EDT 2008,265000,38.708315,-120.6038725625 JAMES WAY,SACRAMENTO,95822,CA,3,1,975,Residential,Wed May 21 00:00:00 EDT 2008,271742,38.523947,-121.4849467842 LAHONTAN CT,SACRAMENTO,95829,CA,4,3,2372,Residential,Wed May 21 00:00:00 EDT 2008,273750,38.472976,-121.3186336850 21ST ST,SACRAMENTO,95822,CA,3,2,1446,Residential,Wed May 21 00:00:00 EDT 2008,275086,38.502194,-121.4907952900 BLAIR RD,POLLOCK PINES,95726,CA,2,2,1284,Residential,Wed May 21 00:00:00 EDT 2008,280908,38.75485,-120.604762064 EXPEDITION WAY,SACRAMENTO,95832,CA,4,3,3009,Residential,Wed May 21 00:00:00 EDT 2008,280987,38.474099,-121.4907112912 NORCADE CIR,SACRAMENTO,95826,CA,8,4,3612,Multi-Family,Wed May 21 00:00:00 EDT 2008,282400,38.559505,-121.3648399507 SEA CLIFF WAY,ELK GROVE,95758,CA,4,2,2056,Residential,Wed May 21 00:00:00 EDT 2008,285000,38.410992,-121.4790438882 AUTUMN GOLD CT,ELK GROVE,95624,CA,4,2,1993,Residential,Wed May 21 00:00:00 EDT 2008,287417,38.4439,-121.372555322 WHITE LOTUS WAY,ELK GROVE,95757,CA,3,2,1857,Residential,Wed May 21 00:00:00 EDT 2008,291000,38.391538,-121.4425961838 CASTRO WAY,SACRAMENTO,95818,CA,2,1,1126,Residential,Wed May 21 00:00:00 EDT 2008,292024,38.556098,-121.49078710158 CRAWFORD WAY,SACRAMENTO,95827,CA,4,4,2213,Multi-Family,Wed May 21 00:00:00 EDT 2008,297000,38.5703,-121.3157357731 MASTERS ST,ELK GROVE,95758,CA,5,3,2494,Residential,Wed May 21 00:00:00 EDT 2008,297000,38.442031,-121.4108734925 PERCHERON DR,ELK GROVE,95757,CA,3,2,1843,Residential,Wed May 21 00:00:00 EDT 2008,298000,38.40154,-121.4476492010 PROMONTORY POINT LN,GOLD RIVER,95670,CA,2,2,1520,Residential,Wed May 21 00:00:00 EDT 2008,299000,38.62869,-121.2616694727 SAVOIE WAY,SACRAMENTO,95835,CA,5,3,2800,Residential,Wed May 21 00:00:00 EDT 2008,304037,38.658182,-121.5495218664 MAGNOLIA HILL WAY,ELK GROVE,95624,CA,4,2,2309,Residential,Wed May 21 00:00:00 EDT 2008,311000,38.442352,-121.3896759570 HARVEST ROSE WAY,SACRAMENTO,95827,CA,5,3,2367,Residential,Wed May 21 00:00:00 EDT 2008,315537,38.555993,-121.3403524359 CREGAN CT,RANCHO CORDOVA,95742,CA,5,4,3516,Residential,Wed May 21 00:00:00 EDT 2008,320000,38.545128,-121.2249225337 DUSTY ROSE WAY,RANCHO CORDOVA,95742,CA,0,0,0,Residential,Wed May 21 00:00:00 EDT 2008,320000,38.528575,-121.22868929 SUTTERS GOLD DR,SACRAMENTO,95826,CA,4,3,1914,Residential,Wed May 21 00:00:00 EDT 2008,328360,38.550848,-121.3702248025 PEERLESS AVE,ORANGEVALE,95662,CA,2,1,1690,Residential,Wed May 21 00:00:00 EDT 2008,334150,38.71147,-121.2162144620 WELERA WAY,ELK GROVE,95757,CA,3,3,2725,Residential,Wed May 21 00:00:00 EDT 2008,335750,38.398609,-121.4501489723 TERRAPIN CT,ELK GROVE,95757,CA,4,3,2354,Residential,Wed May 21 00:00:00 EDT 2008,335750,38.403492,-121.4302242115 SMOKESTACK WAY,SACRAMENTO,95833,CA,0,0,0,Residential,Wed May 21 00:00:00 EDT 2008,339500,38.602416,-121.542965100 REBECCA WAY,FOLSOM,95630,CA,3,2,2185,Residential,Wed May 21 00:00:00 EDT 2008,344250,38.68479,-121.1491999488 OAK VILLAGE WAY,ELK GROVE,95758,CA,4,2,1801,Residential,Wed May 21 00:00:00 EDT 2008,346210,38.41333,-121.4049998495 DARTFORD DR,SACRAMENTO,95823,CA,3,3,1961,Residential,Wed May 21 00:00:00 EDT 2008,347029,38.448507,-121.4213466708 PONTA DO SOL WAY,ELK GROVE,95757,CA,4,2,3134,Residential,Wed May 21 00:00:00 EDT 2008,347650,38.380635,-121.4255384143 SEA MEADOW WAY,SACRAMENTO,95823,CA,4,3,1915,Residential,Wed May 21 00:00:00 EDT 2008,351300,38.46534,-121.4575193020 RICHARDSON CIR,EL DORADO HILLS,95762,CA,3,2,0,Residential,Wed May 21 00:00:00 EDT 2008,352000,38.691299,-121.0817528082 LINDA ISLE LN,SACRAMENTO,95831,CA,0,0,0,Residential,Wed May 21 00:00:00 EDT 2008,370000,38.4772,-121.521515300 MURIETA SOUTH PKWY,RANCHO MURIETA,95683,CA,4,3,2734,Residential,Wed May 21 00:00:00 EDT 2008,370500,38.4874,-121.07512911215 SHARRMONT CT,WILTON,95693,CA,3,2,2110,Residential,Wed May 21 00:00:00 EDT 2008,372000,38.35062,-121.2283497105 DANBERG WAY,ELK GROVE,95757,CA,5,3,3164,Residential,Wed May 21 00:00:00 EDT 2008,375000,38.4019,-121.4203885579 JERRY LITELL WAY,SACRAMENTO,95835,CA,5,3,3599,Residential,Wed May 21 00:00:00 EDT 2008,381300,38.677126,-121.5005191050 FOXHALL WAY,SACRAMENTO,95831,CA,4,2,2054,Residential,Wed May 21 00:00:00 EDT 2008,381942,38.509819,-121.5196617837 ABBINGTON WAY,ANTELOPE,95843,CA,4,2,1830,Residential,Wed May 21 00:00:00 EDT 2008,387731,38.709873,-121.3394721300 F ST,SACRAMENTO,95814,CA,3,3,1627,Residential,Wed May 21 00:00:00 EDT 2008,391000,38.58355,-121.4872896801 RAWLEY WAY,ELK GROVE,95757,CA,4,3,3440,Residential,Wed May 21 00:00:00 EDT 2008,394470,38.408351,-121.4239251693 SHELTER COVE DR,GREENWOOD,95635,CA,3,2,2846,Residential,Wed May 21 00:00:00 EDT 2008,395000,38.945357,-120.9088229361 WADDELL LN,ELK GROVE,95624,CA,4,3,2359,Residential,Wed May 21 00:00:00 EDT 2008,400186,38.450829,-121.34992810 SEA FOAM CT,SACRAMENTO,95831,CA,3,3,2052,Residential,Wed May 21 00:00:00 EDT 2008,415000,38.487885,-121.5459476945 RIO TEJO WAY,ELK GROVE,95757,CA,5,3,3433,Residential,Wed May 21 00:00:00 EDT 2008,425000,38.385638,-121.4226164186 TULIP PARK WAY,RANCHO CORDOVA,95742,CA,5,3,3615,Residential,Wed May 21 00:00:00 EDT 2008,430000,38.550617,-121.235269278 DAIRY CT,ELK GROVE,95624,CA,0,0,0,Residential,Wed May 21 00:00:00 EDT 2008,445000,38.420338,-121.363757207 ORANGE BLOSSOM CIR Unit C,FOLSOM,95630,CA,5,3,2687,Residential,Wed May 21 00:00:00 EDT 2008,460000,38.646273,-121.1753226507 RIO DE ONAR WAY,ELK GROVE,95757,CA,4,3,2724,Residential,Wed May 21 00:00:00 EDT 2008,461000,38.38253,-121.4280077004 RAWLEY WAY,ELK GROVE,95757,CA,4,3,3440,Residential,Wed May 21 00:00:00 EDT 2008,489332,38.406421,-121.4220816503 RIO DE ONAR WAY,ELK GROVE,95757,CA,5,4,3508,Residential,Wed May 21 00:00:00 EDT 2008,510000,38.38253,-121.4280382217 APPALOOSA CT,FOLSOM,95630,CA,4,2,2462,Residential,Wed May 21 00:00:00 EDT 2008,539000,38.655167,-121.090178868 HILDEBRAND CIR,FOLSOM,95630,CA,0,0,0,Residential,Wed May 21 00:00:00 EDT 2008,585000,38.670947,-121.0977276030 PALERMO WAY,EL DORADO HILLS,95762,CA,4,3,0,Residential,Wed May 21 00:00:00 EDT 2008,600000,38.672761,-121.0503784070 REDONDO DR,EL DORADO HILLS,95762,CA,4,3,0,Residential,Wed May 21 00:00:00 EDT 2008,606238,38.666807,-121.064834004 CRESTA WAY,SACRAMENTO,95864,CA,3,3,2325,Residential,Wed May 21 00:00:00 EDT 2008,660000,38.591618,-121.370626315 JUMEL CT,EL DORADO HILLS,95762,CA,6,5,0,Residential,Wed May 21 00:00:00 EDT 2008,830000,38.669931,-121.059586272 LONGFORD DR Unit 1,CITRUS HEIGHTS,95621,CA,2,1,795,Condo,Tue May 20 00:00:00 EDT 2008,69000,38.680923,-121.3139453432 Y ST,SACRAMENTO,95817,CA,4,2,1099,Residential,Tue May 20 00:00:00 EDT 2008,70000,38.554967,-121.4680469512 EMERALD PARK DR Unit 3,ELK GROVE,95624,CA,2,1,840,Condo,Tue May 20 00:00:00 EDT 2008,71000,38.40573,-121.3698323132 CLAY ST,SACRAMENTO,95815,CA,2,1,800,Residential,Tue May 20 00:00:00 EDT 2008,78000,38.624678,-121.4392035221 38TH AVE,SACRAMENTO,95824,CA,2,1,746,Residential,Tue May 20 00:00:00 EDT 2008,78400,38.518044,-121.4435556112 HERMOSA ST,SACRAMENTO,95822,CA,3,1,1067,Residential,Tue May 20 00:00:00 EDT 2008,80000,38.515125,-121.480416483 ARCADE BLVD,SACRAMENTO,95815,CA,4,2,1316,Residential,Tue May 20 00:00:00 EDT 2008,89000,38.623571,-121.454884671 SONOMA AVE,SACRAMENTO,95815,CA,3,1,1337,Residential,Tue May 20 00:00:00 EDT 2008,90000,38.622953,-121.4501425980 79TH ST,SACRAMENTO,95824,CA,2,1,868,Residential,Tue May 20 00:00:00 EDT 2008,90000,38.518373,-121.4117797607 ELDER CREEK RD,SACRAMENTO,95824,CA,3,1,924,Residential,Tue May 20 00:00:00 EDT 2008,92000,38.51055,-121.4147685028 14TH AVE,SACRAMENTO,95820,CA,2,1,610,Residential,Tue May 20 00:00:00 EDT 2008,93675,38.53942,-121.44689414788 NATCHEZ CT,RANCHO MURIETA,95683,CA,0,0,0,Residential,Tue May 20 00:00:00 EDT 2008,97750,38.492287,-121.1000321069 ACACIA AVE,SACRAMENTO,95815,CA,2,1,1220,Residential,Tue May 20 00:00:00 EDT 2008,98000,38.621998,-121.4422385201 LAGUNA OAKS DR Unit 199,ELK GROVE,95758,CA,1,1,722,Condo,Tue May 20 00:00:00 EDT 2008,98000,38.423251,-121.4444893847 LAS PASAS WAY,SACRAMENTO,95864,CA,3,1,1643,Residential,Tue May 20 00:00:00 EDT 2008,99000,38.588672,-121.3739165201 LAGUNA OAKS DR Unit 172,ELK GROVE,95758,CA,1,1,722,Condo,Tue May 20 00:00:00 EDT 2008,100000,38.423251,-121.4444891121 CREEKSIDE WAY,GALT,95632,CA,3,1,1080,Residential,Tue May 20 00:00:00 EDT 2008,106716,38.241514,-121.3121995307 CABRILLO WAY,SACRAMENTO,95820,CA,3,1,1039,Residential,Tue May 20 00:00:00 EDT 2008,111000,38.52712,-121.4353483725 DON JULIO BLVD,NORTH HIGHLANDS,95660,CA,3,1,1051,Residential,Tue May 20 00:00:00 EDT 2008,111000,38.67895,-121.3794064803 MCCLOUD DR,SACRAMENTO,95842,CA,2,2,967,Residential,Tue May 20 00:00:00 EDT 2008,114800,38.682279,-121.35281710542 SILVERWOOD WAY,RANCHO CORDOVA,95670,CA,3,1,1098,Residential,Tue May 20 00:00:00 EDT 2008,120108,38.587156,-121.2957786318 39TH AVE,SACRAMENTO,95824,CA,3,1,1050,Residential,Tue May 20 00:00:00 EDT 2008,123225,38.518942,-121.430158211 MCDANIEL CIR,SACRAMENTO,95838,CA,3,2,1110,Residential,Tue May 20 00:00:00 EDT 2008,123750,38.636565,-121.4603833800 LYNHURST WAY,NORTH HIGHLANDS,95660,CA,3,1,888,Residential,Tue May 20 00:00:00 EDT 2008,125000,38.650445,-121.3748616139 HERMOSA ST,SACRAMENTO,95822,CA,3,2,1120,Residential,Tue May 20 00:00:00 EDT 2008,125000,38.514665,-121.4804112505 RHINE WAY,ELVERTA,95626,CA,3,2,1080,Residential,Tue May 20 00:00:00 EDT 2008,126000,38.717976,-121.4076843692 PAYNE WAY,NORTH HIGHLANDS,95660,CA,3,1,957,Residential,Tue May 20 00:00:00 EDT 2008,129000,38.66654,-121.378298604 MORRISON AVE,SACRAMENTO,95838,CA,2,1,952,Residential,Tue May 20 00:00:00 EDT 2008,134000,38.637678,-121.452476648 SANTA ANA AVE,SACRAMENTO,95838,CA,3,2,1211,Residential,Tue May 20 00:00:00 EDT 2008,135000,38.658478,-121.45040914 ASHLEY OAKS CT,SACRAMENTO,95815,CA,3,2,1264,Residential,Tue May 20 00:00:00 EDT 2008,135500,38.61779,-121.4367653174 NORTHVIEW DR,SACRAMENTO,95833,CA,3,1,1080,Residential,Tue May 20 00:00:00 EDT 2008,140000,38.623817,-121.477827840 TRANQUIL LN,GALT,95632,CA,3,2,1266,Residential,Tue May 20 00:00:00 EDT 2008,140000,38.270617,-121.2992055333 PRIMROSE DR Unit 19A,FAIR OAKS,95628,CA,2,2,994,Condo,Tue May 20 00:00:00 EDT 2008,142500,38.662785,-121.2762721035 MILLET WAY,SACRAMENTO,95834,CA,3,2,1202,Residential,Tue May 20 00:00:00 EDT 2008,143500,38.631056,-121.485085201 LAGUNA OAKS DR Unit 126,ELK GROVE,95758,CA,0,0,0,Condo,Tue May 20 00:00:00 EDT 2008,145000,38.423251,-121.4444893328 22ND AVE,SACRAMENTO,95820,CA,2,1,722,Residential,Tue May 20 00:00:00 EDT 2008,145000,38.532727,-121.4707838001 HARTWICK WAY,SACRAMENTO,95828,CA,4,2,1448,Residential,Tue May 20 00:00:00 EDT 2008,145000,38.488623,-121.4105827812 HARTWICK WAY,SACRAMENTO,95828,CA,3,2,1188,Residential,Tue May 20 00:00:00 EDT 2008,145000,38.488611,-121.4128084207 PAINTER WAY,NORTH HIGHLANDS,95660,CA,4,2,1183,Residential,Tue May 20 00:00:00 EDT 2008,146000,38.692915,-121.3674977458 WINKLEY WAY,SACRAMENTO,95822,CA,3,1,1320,Residential,Tue May 20 00:00:00 EDT 2008,148500,38.487444,-121.4913668354 SUNRISE WOODS WAY,SACRAMENTO,95828,CA,3,2,1117,Residential,Tue May 20 00:00:00 EDT 2008,149000,38.473288,-121.39638116 COTTONMILL CIR,SACRAMENTO,95828,CA,3,2,1364,Residential,Tue May 20 00:00:00 EDT 2008,150000,38.482876,-121.4059124660 CEDARWOOD WAY,SACRAMENTO,95823,CA,4,2,1310,Residential,Tue May 20 00:00:00 EDT 2008,150000,38.484834,-121.4493169254 HARROGATE WAY,ELK GROVE,95758,CA,2,2,1006,Residential,Tue May 20 00:00:00 EDT 2008,152000,38.420138,-121.4121796716 TAREYTON WAY,CITRUS HEIGHTS,95621,CA,3,2,1104,Residential,Tue May 20 00:00:00 EDT 2008,156000,38.693724,-121.3071692028 ROBERT WAY,SACRAMENTO,95825,CA,2,1,810,Residential,Tue May 20 00:00:00 EDT 2008,156000,38.609982,-121.4192639346 AIZENBERG CIR,ELK GROVE,95624,CA,2,2,1123,Residential,Tue May 20 00:00:00 EDT 2008,156000,38.41875,-121.3700194524 LOCH HAVEN WAY,SACRAMENTO,95842,CA,2,1,904,Residential,Tue May 20 00:00:00 EDT 2008,157788,38.67273,-121.3596457140 BLUE SPRINGS WAY,CITRUS HEIGHTS,95621,CA,3,2,1156,Residential,Tue May 20 00:00:00 EDT 2008,161653,38.720653,-121.3022414631 11TH AVE,SACRAMENTO,95820,CA,2,1,1321,Residential,Tue May 20 00:00:00 EDT 2008,161829,38.541965,-121.4521323228 BAGGAN CT,ANTELOPE,95843,CA,3,2,1392,Residential,Tue May 20 00:00:00 EDT 2008,165000,38.715346,-121.3881638515 DARTFORD DR,SACRAMENTO,95823,CA,3,2,1439,Residential,Tue May 20 00:00:00 EDT 2008,168000,38.448288,-121.4207194500 TIPPWOOD WAY,SACRAMENTO,95842,CA,3,2,1159,Residential,Tue May 20 00:00:00 EDT 2008,169000,38.69951,-121.3599892460 EL ROCCO WAY,RANCHO CORDOVA,95670,CA,3,2,1671,Residential,Tue May 20 00:00:00 EDT 2008,175000,38.591477,-121.315348244 SUNBIRD WAY,SACRAMENTO,95823,CA,3,2,1740,Residential,Tue May 20 00:00:00 EDT 2008,176250,38.457654,-121.4313815841 VALLEY VALE WAY,SACRAMENTO,95823,CA,3,2,1265,Residential,Tue May 20 00:00:00 EDT 2008,179000,38.461283,-121.4343227863 CRESTLEIGH CT,ANTELOPE,95843,CA,2,2,1007,Residential,Tue May 20 00:00:00 EDT 2008,180000,38.710889,-121.3588767129 SPRINGMONT DR,ELK GROVE,95758,CA,3,2,1716,Residential,Tue May 20 00:00:00 EDT 2008,180400,38.417649,-121.4202948284 RED FOX WAY,ELK GROVE,95758,CA,4,2,1685,Residential,Tue May 20 00:00:00 EDT 2008,182000,38.417182,-121.3972312219 EL CANTO CIR,RANCHO CORDOVA,95670,CA,4,2,1829,Residential,Tue May 20 00:00:00 EDT 2008,184500,38.592383,-121.3186698907 GEMWOOD WAY,ELK GROVE,95758,CA,3,2,1555,Residential,Tue May 20 00:00:00 EDT 2008,185000,38.435471,-121.4411735925 MALEVILLE AVE,CARMICHAEL,95608,CA,4,2,1120,Residential,Tue May 20 00:00:00 EDT 2008,189000,38.666564,-121.3257177031 CANEVALLEY CIR,CITRUS HEIGHTS,95621,CA,3,2,1137,Residential,Tue May 20 00:00:00 EDT 2008,194000,38.718693,-121.3036193949 WILDROSE WAY,SACRAMENTO,95826,CA,3,1,1174,Residential,Tue May 20 00:00:00 EDT 2008,195000,38.543697,-121.3666834437 MITCHUM CT,ANTELOPE,95843,CA,3,2,1393,Residential,Tue May 20 00:00:00 EDT 2008,200000,38.704407,-121.361132778 KAWEAH CT,CAMERON PARK,95682,CA,3,1,0,Residential,Tue May 20 00:00:00 EDT 2008,201000,38.694052,-120.9955891636 ALLENWOOD CIR,LINCOLN,95648,CA,4,2,0,Residential,Tue May 20 00:00:00 EDT 2008,202500,38.879192,-121.3094778151 QUAIL RIDGE CT,SACRAMENTO,95828,CA,3,2,1289,Residential,Tue May 20 00:00:00 EDT 2008,205000,38.461296,-121.3908584899 WIND CREEK DR,SACRAMENTO,95838,CA,4,2,1799,Residential,Tue May 20 00:00:00 EDT 2008,205000,38.655887,-121.4461192370 BIG CANYON CREEK RD,PLACERVILLE,95667,CA,3,2,0,Residential,Tue May 20 00:00:00 EDT 2008,205000,38.74458,-120.7942546049 HAMBURG WAY,SACRAMENTO,95823,CA,4,3,1953,Residential,Tue May 20 00:00:00 EDT 2008,205000,38.443253,-121.4319924232 71ST ST,SACRAMENTO,95820,CA,2,1,723,Residential,Tue May 20 00:00:00 EDT 2008,207000,38.536741,-121.421153361 BOW MAR CT,CAMERON PARK,95682,CA,2,2,0,Residential,Tue May 20 00:00:00 EDT 2008,210000,38.69437,-120.9966021889 COLD SPRINGS RD,PLACERVILLE,95667,CA,2,1,948,Residential,Tue May 20 00:00:00 EDT 2008,211500,38.739774,-120.8602435805 HIMALAYA WAY,CITRUS HEIGHTS,95621,CA,4,2,1578,Residential,Tue May 20 00:00:00 EDT 2008,215000,38.696489,-121.3285557944 SYLVAN OAK WAY,CITRUS HEIGHTS,95610,CA,3,2,1317,Residential,Tue May 20 00:00:00 EDT 2008,215000,38.710388,-121.2610963139 SPOONWOOD WAY Unit 1,SACRAMENTO,95833,CA,0,0,0,Residential,Tue May 20 00:00:00 EDT 2008,215500,38.626582,-121.521516217 LEOLA WAY,SACRAMENTO,95824,CA,3,1,1360,Residential,Tue May 20 00:00:00 EDT 2008,222381,38.513066,-121.4519092340 HURLEY WAY,SACRAMENTO,95825,CA,0,0,0,Condo,Tue May 20 00:00:00 EDT 2008,225000,38.588816,-121.4085493035 BRUNNET LN,SACRAMENTO,95833,CA,3,2,1522,Residential,Tue May 20 00:00:00 EDT 2008,225000,38.624762,-121.5227753025 EL PRADO WAY,SACRAMENTO,95825,CA,4,2,1751,Residential,Tue May 20 00:00:00 EDT 2008,225000,38.606603,-121.3941479387 GRANITE FALLS CT,ELK GROVE,95624,CA,3,2,1465,Residential,Tue May 20 00:00:00 EDT 2008,225000,38.419214,-121.3485339257 CALDERA WAY,SACRAMENTO,95826,CA,4,2,1605,Residential,Tue May 20 00:00:00 EDT 2008,228000,38.55821,-121.355022441 ARLINGDALE CIR,RIO LINDA,95673,CA,4,2,1475,Residential,Tue May 20 00:00:00 EDT 2008,229665,38.702893,-121.4549492284 LOS ROBLES RD,MEADOW VISTA,95722,CA,3,1,1216,Residential,Tue May 20 00:00:00 EDT 2008,230000,39.008159,-121.036238164 CHENIN BLANC LN,FAIR OAKS,95628,CA,2,2,1315,Residential,Tue May 20 00:00:00 EDT 2008,230000,38.665644,-121.2599694620 CHAMBERLIN CIR,ELK GROVE,95757,CA,3,2,1567,Residential,Tue May 20 00:00:00 EDT 2008,230000,38.390557,-121.4498055340 BIRK WAY,SACRAMENTO,95835,CA,3,2,1776,Residential,Tue May 20 00:00:00 EDT 2008,234000,38.672495,-121.51525151 ANJOU CIR,SACRAMENTO,95835,CA,3,2,2187,Residential,Tue May 20 00:00:00 EDT 2008,235000,38.661658,-121.5406332125 22ND AVE,SACRAMENTO,95822,CA,3,1,1291,Residential,Tue May 20 00:00:00 EDT 2008,236250,38.534596,-121.493121611 BLOSSOM ROCK LN,FOLSOM,95630,CA,0,0,0,Condo,Tue May 20 00:00:00 EDT 2008,240000,38.6457,-121.11978830 ADUR RD,ELK GROVE,95624,CA,0,0,0,Residential,Tue May 20 00:00:00 EDT 2008,242000,38.43742,-121.3728767344 BUTTERBALL WAY,SACRAMENTO,95842,CA,3,2,1503,Residential,Tue May 20 00:00:00 EDT 2008,245000,38.699489,-121.3618288219 GWINHURST CIR,SACRAMENTO,95828,CA,4,3,2491,Residential,Tue May 20 00:00:00 EDT 2008,245000,38.459711,-121.3842833240 S ST,SACRAMENTO,95816,CA,2,1,1269,Residential,Tue May 20 00:00:00 EDT 2008,245000,38.562296,-121.467489221 PICASSO CIR,SACRAMENTO,95835,CA,0,0,0,Residential,Tue May 20 00:00:00 EDT 2008,250000,38.676658,-121.5281285706 GREENACRES WAY,ORANGEVALE,95662,CA,3,2,1176,Residential,Tue May 20 00:00:00 EDT 2008,250000,38.669882,-121.2135336900 LONICERA DR,ORANGEVALE,95662,CA,4,2,1456,Residential,Tue May 20 00:00:00 EDT 2008,250000,38.692199,-121.250975419 DAWNRIDGE RD,ROSEVILLE,95678,CA,3,2,1498,Residential,Tue May 20 00:00:00 EDT 2008,250000,38.725283,-121.2979535312 MARBURY WAY,ANTELOPE,95843,CA,3,2,1574,Residential,Tue May 20 00:00:00 EDT 2008,255000,38.710221,-121.3416516344 BONHAM CIR,CITRUS HEIGHTS,95610,CA,5,4,2085,Multi-Family,Tue May 20 00:00:00 EDT 2008,256054,38.682358,-121.2728768207 YORKTON WAY,SACRAMENTO,95829,CA,3,2,2170,Residential,Tue May 20 00:00:00 EDT 2008,257729,38.45967,-121.3604617922 MANSELL WAY,ELK GROVE,95758,CA,4,2,1595,Residential,Tue May 20 00:00:00 EDT 2008,260000,38.409634,-121.4107875712 MELBURY CIR,ANTELOPE,95843,CA,3,2,1567,Residential,Tue May 20 00:00:00 EDT 2008,261000,38.705849,-121.334701632 NEWBRIDGE LN,LINCOLN,95648,CA,4,2,0,Residential,Tue May 20 00:00:00 EDT 2008,261800,38.879084,-121.2985861570 GLIDDEN AVE,SACRAMENTO,95822,CA,4,2,1253,Residential,Tue May 20 00:00:00 EDT 2008,264469,38.482704,-121.5004338108 FILIFERA WAY,ANTELOPE,95843,CA,4,3,1768,Residential,Tue May 20 00:00:00 EDT 2008,265000,38.717042,-121.35468230 BANKSIDE WAY,SACRAMENTO,95835,CA,0,0,0,Residential,Tue May 20 00:00:00 EDT 2008,270000,38.676937,-121.5292445342 CALABRIA WAY,SACRAMENTO,95835,CA,4,3,2030,Residential,Tue May 20 00:00:00 EDT 2008,270000,38.671807,-121.49827447 NAPONEE CT,SACRAMENTO,95835,CA,3,2,1531,Residential,Tue May 20 00:00:00 EDT 2008,270000,38.665704,-121.5290964236 ADRIATIC SEA WAY,SACRAMENTO,95834,CA,0,0,0,Residential,Tue May 20 00:00:00 EDT 2008,270000,38.647961,-121.5431628864 REMBRANT CT,ELK GROVE,95624,CA,4,3,1653,Residential,Tue May 20 00:00:00 EDT 2008,275000,38.435288,-121.3757039455 SEA CLIFF WAY,ELK GROVE,95758,CA,4,2,2056,Residential,Tue May 20 00:00:00 EDT 2008,275000,38.411522,-121.4814069720 LITTLE HARBOR WAY,ELK GROVE,95624,CA,4,3,2494,Residential,Tue May 20 00:00:00 EDT 2008,280000,38.404934,-121.3524058806 PHOENIX AVE,FAIR OAKS,95628,CA,3,2,1450,Residential,Tue May 20 00:00:00 EDT 2008,286013,38.660322,-121.2301013578 LOGGERHEAD WAY,SACRAMENTO,95834,CA,4,2,2169,Residential,Tue May 20 00:00:00 EDT 2008,292000,38.633028,-121.5267551416 LOCKHART WAY,ROSEVILLE,95747,CA,3,2,1440,Residential,Tue May 20 00:00:00 EDT 2008,292000,38.752399,-121.3303285413 BUENA VENTURA WAY,FAIR OAKS,95628,CA,3,2,1527,Residential,Tue May 20 00:00:00 EDT 2008,293993,38.664552,-121.25593737 WHITE BIRCH CT,ROSEVILLE,95678,CA,3,2,1401,Residential,Tue May 20 00:00:00 EDT 2008,294000,38.776327,-121.284514405 MARLIN SPIKE WAY,SACRAMENTO,95838,CA,3,2,1411,Residential,Tue May 20 00:00:00 EDT 2008,296769,38.65783,-121.4568421102 CHESLEY LN,LINCOLN,95648,CA,4,4,0,Residential,Tue May 20 00:00:00 EDT 2008,297500,38.864864,-121.31398811281 STANFORD COURT LN Unit 604,GOLD RIVER,95670,CA,0,0,0,Condo,Tue May 20 00:00:00 EDT 2008,300000,38.625289,-121.2602867320 6TH ST,RIO LINDA,95673,CA,3,1,1284,Residential,Tue May 20 00:00:00 EDT 2008,300000,38.700553,-121.452223993 MANTON CT,GALT,95632,CA,4,3,2307,Residential,Tue May 20 00:00:00 EDT 2008,300000,38.272942,-121.2891484487 PANORAMA DR,PLACERVILLE,95667,CA,3,2,1329,Residential,Tue May 20 00:00:00 EDT 2008,300000,38.694559,-120.8481575651 OVERLEAF WAY,SACRAMENTO,95835,CA,4,2,1910,Residential,Tue May 20 00:00:00 EDT 2008,300500,38.677454,-121.4947912015 PROMONTORY POINT LN,GOLD RIVER,95670,CA,3,2,1981,Residential,Tue May 20 00:00:00 EDT 2008,305000,38.628732,-121.2611493224 PARKHAM DR,ROSEVILLE,95747,CA,0,0,0,Residential,Tue May 20 00:00:00 EDT 2008,306500,38.772771,-121.36487715 VANESSA PL,SACRAMENTO,95835,CA,0,0,0,Residential,Tue May 20 00:00:00 EDT 2008,312500,38.668692,-121.545491312 RENISON LN,LINCOLN,95648,CA,5,3,0,Residential,Tue May 20 00:00:00 EDT 2008,315000,38.866409,-121.3084858 RIVER RAFT CT,SACRAMENTO,95823,CA,4,2,2205,Residential,Tue May 20 00:00:00 EDT 2008,319789,38.447353,-121.4349692251 LAMPLIGHT LN,LINCOLN,95648,CA,2,2,1449,Residential,Tue May 20 00:00:00 EDT 2008,330000,38.849924,-121.275729106 FARHAM DR,FOLSOM,95630,CA,3,2,1258,Residential,Tue May 20 00:00:00 EDT 2008,330000,38.667834,-121.1685785405 NECTAR CIR,ELK GROVE,95757,CA,3,2,2575,Residential,Tue May 20 00:00:00 EDT 2008,331000,38.387014,-121.4409675411 10TH AVE,SACRAMENTO,95820,CA,2,1,539,Residential,Tue May 20 00:00:00 EDT 2008,334000,38.542727,-121.4424493512 RAINSONG CIR,RANCHO CORDOVA,95670,CA,4,3,2208,Residential,Tue May 20 00:00:00 EDT 2008,336000,38.573488,-121.2828091106 55TH ST,SACRAMENTO,95819,CA,3,1,1108,Residential,Tue May 20 00:00:00 EDT 2008,339000,38.563805,-121.436395411 ILLSLEY WAY,FOLSOM,95630,CA,4,2,1595,Residential,Tue May 20 00:00:00 EDT 2008,339000,38.652002,-121.129504796 BUTTERCUP CIR,GALT,95632,CA,4,2,2159,Residential,Tue May 20 00:00:00 EDT 2008,345000,38.279581,-121.3008281230 SANDRA CIR,PLACERVILLE,95667,CA,4,3,2295,Residential,Tue May 20 00:00:00 EDT 2008,350000,38.738141,-120.784145318 ANACAPA DR,ROSEVILLE,95678,CA,3,2,1838,Residential,Tue May 20 00:00:00 EDT 2008,356000,38.782094,-121.2971333975 SHINING STAR DR,SACRAMENTO,95823,CA,4,2,1900,Residential,Tue May 20 00:00:00 EDT 2008,361745,38.487409,-121.4614131620 BASLER ST,SACRAMENTO,95811,CA,4,2,1718,Residential,Tue May 20 00:00:00 EDT 2008,361948,38.591822,-121.4786449688 NATURE TRAIL WAY,ELK GROVE,95757,CA,5,3,3389,Residential,Tue May 20 00:00:00 EDT 2008,370000,38.405224,-121.4792755924 TANUS CIR,ROCKLIN,95677,CA,4,2,0,Residential,Tue May 20 00:00:00 EDT 2008,380000,38.778691,-121.2042929629 CEDAR OAK WAY,ELK GROVE,95757,CA,5,4,3260,Residential,Tue May 20 00:00:00 EDT 2008,385000,38.405527,-121.4317463429 FERNBROOK CT,CAMERON PARK,95682,CA,3,2,2016,Residential,Tue May 20 00:00:00 EDT 2008,399000,38.664225,-121.0071732121 HANNAH WAY,ROCKLIN,95765,CA,4,2,2607,Residential,Tue May 20 00:00:00 EDT 2008,402000,38.805749,-121.28093110104 ANNIE ST,ELK GROVE,95757,CA,4,3,2724,Residential,Tue May 20 00:00:00 EDT 2008,406026,38.390465,-121.4434791092 MAUGHAM CT,GALT,95632,CA,5,4,3746,Residential,Tue May 20 00:00:00 EDT 2008,420000,38.271646,-121.2868485404 ALMOND FALLS WAY,RANCHO CORDOVA,95742,CA,0,0,0,Residential,Tue May 20 00:00:00 EDT 2008,425000,38.527502,-121.2334926306 CONEJO,RANCHO MURIETA,95683,CA,4,2,3192,Residential,Tue May 20 00:00:00 EDT 2008,425000,38.512602,-121.08723314 CASA VATONI PL,SACRAMENTO,95834,CA,0,0,0,Residential,Tue May 20 00:00:00 EDT 2008,433500,38.650221,-121.5517041456 EAGLESFIELD LN,LINCOLN,95648,CA,4,3,0,Residential,Tue May 20 00:00:00 EDT 2008,436746,38.857635,-121.3113754100 BOTHWELL CIR,EL DORADO HILLS,95762,CA,5,3,0,Residential,Tue May 20 00:00:00 EDT 2008,438700,38.679136,-121.034329427 21ST ST,SACRAMENTO,95811,CA,2,1,1247,Residential,Tue May 20 00:00:00 EDT 2008,445000,38.582604,-121.475761044 GALSTON DR,FOLSOM,95630,CA,4,2,2581,Residential,Tue May 20 00:00:00 EDT 2008,450000,38.676306,-121.099544440 SYCAMORE AVE,SACRAMENTO,95841,CA,3,1,2068,Residential,Tue May 20 00:00:00 EDT 2008,460000,38.646374,-121.3536581032 SOUZA DR,EL DORADO HILLS,95762,CA,3,2,0,Residential,Tue May 20 00:00:00 EDT 2008,460000,38.668239,-121.0644379760 LAZULITE CT,ELK GROVE,95624,CA,4,3,3992,Residential,Tue May 20 00:00:00 EDT 2008,460000,38.403609,-121.335541241 LANFRANCO CIR,SACRAMENTO,95835,CA,4,4,3397,Residential,Tue May 20 00:00:00 EDT 2008,465000,38.665696,-121.5494375559 NORTHBOROUGH DR,SACRAMENTO,95835,CA,5,3,3881,Residential,Tue May 20 00:00:00 EDT 2008,471750,38.677225,-121.5196872125 BIG SKY DR,ROCKLIN,95765,CA,5,3,0,Residential,Tue May 20 00:00:00 EDT 2008,480000,38.801637,-121.2787982109 HAMLET PL,CARMICHAEL,95608,CA,2,2,1598,Residential,Tue May 20 00:00:00 EDT 2008,484000,38.602754,-121.3293269970 STATE HIGHWAY 193,PLACERVILLE,95667,CA,4,3,1929,Residential,Tue May 20 00:00:00 EDT 2008,485000,38.787877,-120.8166762901 PINTAIL WAY,ELK GROVE,95757,CA,4,3,3070,Residential,Tue May 20 00:00:00 EDT 2008,495000,38.398488,-121.473424201 FIRESTONE DR,ROSEVILLE,95678,CA,0,0,0,Residential,Tue May 20 00:00:00 EDT 2008,500500,38.770153,-121.3000391740 HIGH ST,AUBURN,95603,CA,3,3,0,Residential,Tue May 20 00:00:00 EDT 2008,504000,38.891935,-121.084342733 DANA LOOP,EL DORADO HILLS,95762,CA,0,0,0,Residential,Tue May 20 00:00:00 EDT 2008,541000,38.628459,-121.0550789741 SADDLEBRED CT,WILTON,95693,CA,0,0,0,Residential,Tue May 20 00:00:00 EDT 2008,560000,38.408841,-121.1980397756 TIGERWOODS DR,SACRAMENTO,95829,CA,5,3,3984,Residential,Tue May 20 00:00:00 EDT 2008,572500,38.47643,-121.3092435709 RIVER OAK WAY,CARMICHAEL,95608,CA,4,2,2222,Residential,Tue May 20 00:00:00 EDT 2008,582000,38.602461,-121.3309792981 WRINGER DR,ROSEVILLE,95661,CA,4,3,3838,Residential,Tue May 20 00:00:00 EDT 2008,613401,38.735373,-121.2270728616 ROCKPORTE CT,ROSEVILLE,95747,CA,4,2,0,Residential,Tue May 20 00:00:00 EDT 2008,614000,38.742118,-121.3599094128 HILL ST,FAIR OAKS,95628,CA,5,5,2846,Residential,Tue May 20 00:00:00 EDT 2008,680000,38.64167,-121.2620991409 47TH ST,SACRAMENTO,95819,CA,5,2,2484,Residential,Tue May 20 00:00:00 EDT 2008,699000,38.563244,-121.4468763935 EL MONTE DR,LOOMIS,95650,CA,4,4,1624,Residential,Tue May 20 00:00:00 EDT 2008,839000,38.813337,-121.1333485840 WALERGA RD,SACRAMENTO,95842,CA,2,1,840,Condo,Mon May 19 00:00:00 EDT 2008,40000,38.673678,-121.357471923 FULTON AVE,SACRAMENTO,95825,CA,1,1,484,Condo,Mon May 19 00:00:00 EDT 2008,48000,38.582279,-121.401482261 REDONDO AVE,SACRAMENTO,95815,CA,3,1,970,Residential,Mon May 19 00:00:00 EDT 2008,61500,38.620685,-121.4605394030 BROADWAY,SACRAMENTO,95817,CA,2,1,623,Residential,Mon May 19 00:00:00 EDT 2008,62050,38.546798,-121.4600383660 22ND AVE,SACRAMENTO,95820,CA,2,1,932,Residential,Mon May 19 00:00:00 EDT 2008,65000,38.532718,-121.467473924 HIGH ST,SACRAMENTO,95838,CA,2,1,796,Residential,Mon May 19 00:00:00 EDT 2008,65000,38.638797,-121.4350494734 14TH AVE,SACRAMENTO,95820,CA,2,1,834,Residential,Mon May 19 00:00:00 EDT 2008,68000,38.539447,-121.4508584734 14TH AVE,SACRAMENTO,95820,CA,2,1,834,Residential,Mon May 19 00:00:00 EDT 2008,68000,38.539447,-121.4508585050 RHODE ISLAND DR Unit 4,SACRAMENTO,95841,CA,2,1,924,Condo,Mon May 19 00:00:00 EDT 2008,77000,38.658739,-121.3335614513 GREENHOLME DR,SACRAMENTO,95842,CA,2,1,795,Condo,Mon May 19 00:00:00 EDT 2008,82732,38.669104,-121.3590083845 ELM ST,SACRAMENTO,95838,CA,3,1,1250,Residential,Mon May 19 00:00:00 EDT 2008,84000,38.637337,-121.4328353908 17TH AVE,SACRAMENTO,95820,CA,2,1,984,Residential,Mon May 19 00:00:00 EDT 2008,84675,38.53728,-121.4635317109 CHANDLER DR,SACRAMENTO,95828,CA,3,1,1013,Residential,Mon May 19 00:00:00 EDT 2008,85000,38.497237,-121.4241877541 SKELTON WAY,SACRAMENTO,95822,CA,3,1,1012,Residential,Mon May 19 00:00:00 EDT 2008,90000,38.484274,-121.4888519058 MONTOYA ST,SACRAMENTO,95826,CA,2,1,795,Condo,Mon May 19 00:00:00 EDT 2008,90000,38.559144,-121.3683871016 CONGRESS AVE,SACRAMENTO,95838,CA,2,2,918,Residential,Mon May 19 00:00:00 EDT 2008,91000,38.630151,-121.442789540 MORRISON AVE,SACRAMENTO,95838,CA,3,1,1082,Residential,Mon May 19 00:00:00 EDT 2008,95000,38.637704,-121.4539465303 JERRETT WAY,SACRAMENTO,95842,CA,2,1,964,Residential,Mon May 19 00:00:00 EDT 2008,97500,38.663282,-121.3596312820 DEL PASO BLVD,SACRAMENTO,95815,CA,4,2,1404,Multi-Family,Mon May 19 00:00:00 EDT 2008,100000,38.617718,-121.4400893715 TALLYHO DR Unit 78HIGH,SACRAMENTO,95826,CA,1,1,625,Condo,Mon May 19 00:00:00 EDT 2008,100000,38.544627,-121.357966013 ROWAN WAY,CITRUS HEIGHTS,95621,CA,2,1,888,Residential,Mon May 19 00:00:00 EDT 2008,101000,38.675893,-121.29632987 PONDEROSA LN,SACRAMENTO,95815,CA,4,2,1120,Residential,Mon May 19 00:00:00 EDT 2008,102750,38.622243,-121.4578633732 LANKERSHIM WAY,NORTH HIGHLANDS,95660,CA,3,1,1331,Residential,Mon May 19 00:00:00 EDT 2008,112500,38.68972,-121.3783992216 DUNLAP DR,SACRAMENTO,95821,CA,3,1,1014,Residential,Mon May 19 00:00:00 EDT 2008,113000,38.623738,-121.413053503 21ST AVE,SACRAMENTO,95820,CA,4,2,1448,Residential,Mon May 19 00:00:00 EDT 2008,114000,38.53361,-121.469308523 EXCHANGE ST,SACRAMENTO,95838,CA,3,1,966,Residential,Mon May 19 00:00:00 EDT 2008,114000,38.659414,-121.454088101 PORT ROYALE WAY,SACRAMENTO,95823,CA,2,1,779,Residential,Mon May 19 00:00:00 EDT 2008,114750,38.463929,-121.4386678020 WALERGA RD,ANTELOPE,95843,CA,2,2,836,Condo,Mon May 19 00:00:00 EDT 2008,115000,38.71607,-121.364468167 VALLEY OAK DR,ROSEVILLE,95678,CA,2,2,1100,Condo,Mon May 19 00:00:00 EDT 2008,115000,38.732429,-121.2880697876 BURLINGTON WAY,SACRAMENTO,95832,CA,3,1,1174,Residential,Mon May 19 00:00:00 EDT 2008,116100,38.470093,-121.4683473726 JONKO AVE,NORTH HIGHLANDS,95660,CA,3,2,1207,Residential,Mon May 19 00:00:00 EDT 2008,119250,38.656131,-121.3772657342 GIGI PL,SACRAMENTO,95828,CA,4,4,1995,Multi-Family,Mon May 19 00:00:00 EDT 2008,120000,38.490704,-121.4101762610 PHYLLIS AVE,SACRAMENTO,95820,CA,2,1,804,Residential,Mon May 19 00:00:00 EDT 2008,120000,38.53105,-121.4795744200 COMMERCE WAY Unit 711,SACRAMENTO,95834,CA,2,2,958,Condo,Mon May 19 00:00:00 EDT 2008,120000,38.647523,-121.5232174621 COUNTRY SCENE WAY,SACRAMENTO,95823,CA,3,2,1366,Residential,Mon May 19 00:00:00 EDT 2008,120108,38.470187,-121.4481495380 VILLAGE WOOD DR,SACRAMENTO,95823,CA,2,2,901,Residential,Mon May 19 00:00:00 EDT 2008,121500,38.454949,-121.4405782621 EVERGREEN ST,SACRAMENTO,95815,CA,3,1,696,Residential,Mon May 19 00:00:00 EDT 2008,121725,38.613103,-121.444085201 CARLO CT,GALT,95632,CA,3,2,1080,Residential,Mon May 19 00:00:00 EDT 2008,122000,38.24227,-121.310326743 21ST ST,SACRAMENTO,95822,CA,3,2,1104,Residential,Mon May 19 00:00:00 EDT 2008,123000,38.50372,-121.4906573128 VIA GRANDE,SACRAMENTO,95825,CA,2,1,972,Residential,Mon May 19 00:00:00 EDT 2008,125000,38.598321,-121.391612847 BELGRADE WAY,SACRAMENTO,95833,CA,4,2,1390,Residential,Mon May 19 00:00:00 EDT 2008,125573,38.617173,-121.4825417741 MILLDALE CIR,ELVERTA,95626,CA,4,2,1354,Residential,Mon May 19 00:00:00 EDT 2008,126714,38.705834,-121.439199013 CASALS ST,SACRAMENTO,95826,CA,2,1,795,Condo,Mon May 19 00:00:00 EDT 2008,126960,38.557045,-121.37167227 MAHAN CT Unit 1,ROSEVILLE,95678,CA,2,1,780,Condo,Mon May 19 00:00:00 EDT 2008,127000,38.749723,-121.270087349 FLETCHER FARM DR,SACRAMENTO,95828,CA,4,2,1587,Residential,Mon May 19 00:00:00 EDT 2008,127500,38.49069,-121.3826197226 LARCHMONT DR,NORTH HIGHLANDS,95660,CA,3,2,1209,Residential,Mon May 19 00:00:00 EDT 2008,130000,38.699269,-121.3763344114 35TH AVE,SACRAMENTO,95824,CA,2,1,1139,Residential,Mon May 19 00:00:00 EDT 2008,133105,38.520941,-121.459355617 M ST,RIO LINDA,95673,CA,2,2,1690,Residential,Mon May 19 00:00:00 EDT 2008,136500,38.691104,-121.4518327032 FAIR OAKS BLVD,CARMICHAEL,95608,CA,3,2,1245,Condo,Mon May 19 00:00:00 EDT 2008,139500,38.628563,-121.3282972421 SANTINA WAY,ELVERTA,95626,CA,3,2,1416,Residential,Mon May 19 00:00:00 EDT 2008,140000,38.71865,-121.4077632368 CRAIG AVE,SACRAMENTO,95832,CA,3,2,1300,Residential,Mon May 19 00:00:00 EDT 2008,140800,38.47807,-121.481142123 AMANDA WAY,SACRAMENTO,95822,CA,3,2,1120,Residential,Mon May 19 00:00:00 EDT 2008,145000,38.484896,-121.4869487620 DARLA WAY,SACRAMENTO,95828,CA,4,2,1590,Residential,Mon May 19 00:00:00 EDT 2008,147000,38.478502,-121.4035178344 FIELDPOPPY CIR,SACRAMENTO,95828,CA,3,2,1407,Residential,Mon May 19 00:00:00 EDT 2008,149600,38.479083,-121.4007023624 20TH AVE,SACRAMENTO,95820,CA,5,2,1516,Residential,Mon May 19 00:00:00 EDT 2008,150000,38.534508,-121.46790710001 WOODCREEK OAKS BLVD Unit 1415,ROSEVILLE,95747,CA,2,2,0,Condo,Mon May 19 00:00:00 EDT 2008,150000,38.795529,-121.3288192848 PROVO WAY,SACRAMENTO,95822,CA,3,2,1646,Residential,Mon May 19 00:00:00 EDT 2008,150000,38.489759,-121.4747546045 EHRHARDT AVE,SACRAMENTO,95823,CA,3,2,1676,Residential,Mon May 19 00:00:00 EDT 2008,155000,38.457157,-121.4330651223 LAMBERTON CIR,SACRAMENTO,95838,CA,3,2,1370,Residential,Mon May 19 00:00:00 EDT 2008,155435,38.646677,-121.4375731223 LAMBERTON CIR,SACRAMENTO,95838,CA,3,2,1370,Residential,Mon May 19 00:00:00 EDT 2008,155500,38.646677,-121.4375736000 BIRCHGLADE WAY,CITRUS HEIGHTS,95621,CA,4,2,1351,Residential,Mon May 19 00:00:00 EDT 2008,158000,38.70166,-121.3232497204 THOMAS DR,NORTH HIGHLANDS,95660,CA,3,2,1152,Residential,Mon May 19 00:00:00 EDT 2008,158000,38.697898,-121.3776878363 LANGTREE WAY,SACRAMENTO,95823,CA,3,2,1452,Residential,Mon May 19 00:00:00 EDT 2008,160000,38.45356,-121.4359591675 VERNON ST Unit 8,ROSEVILLE,95678,CA,2,1,990,Residential,Mon May 19 00:00:00 EDT 2008,160000,38.734136,-121.2996396632 IBEX WOODS CT,CITRUS HEIGHTS,95621,CA,2,2,1162,Residential,Mon May 19 00:00:00 EDT 2008,164000,38.720868,-121.309855117 EVCAR WAY,RIO LINDA,95673,CA,3,2,1182,Residential,Mon May 19 00:00:00 EDT 2008,164000,38.687659,-121.46336485 LAGUNA MIRAGE LN,ELK GROVE,95758,CA,2,2,1112,Residential,Mon May 19 00:00:00 EDT 2008,165000,38.42465,-121.430137746 MOOSE CREEK WAY,GALT,95632,CA,3,2,1100,Residential,Mon May 19 00:00:00 EDT 2008,167000,38.283085,-121.3020718306 CURLEW CT,CITRUS HEIGHTS,95621,CA,4,2,1280,Residential,Mon May 19 00:00:00 EDT 2008,167293,38.715781,-121.2985198306 CURLEW CT,CITRUS HEIGHTS,95621,CA,4,2,1280,Residential,Mon May 19 00:00:00 EDT 2008,167293,38.715781,-121.2985195217 ARGO WAY,SACRAMENTO,95820,CA,3,1,1039,Residential,Mon May 19 00:00:00 EDT 2008,168000,38.52774,-121.4336697108 HEATHER TREE DR,SACRAMENTO,95842,CA,3,2,1159,Residential,Mon May 19 00:00:00 EDT 2008,170000,38.695677,-121.360222956 DAVENPORT WAY,SACRAMENTO,95833,CA,4,2,1917,Residential,Mon May 19 00:00:00 EDT 2008,170000,38.620687,-121.48261910062 LINCOLN VILLAGE DR,SACRAMENTO,95827,CA,3,2,1520,Residential,Mon May 19 00:00:00 EDT 2008,170000,38.564,-121.320023332 PALIN AVE,GALT,95632,CA,3,2,1204,Residential,Mon May 19 00:00:00 EDT 2008,174000,38.260467,-121.3026364649 FREEWAY CIR,SACRAMENTO,95841,CA,3,2,1120,Residential,Mon May 19 00:00:00 EDT 2008,178000,38.658734,-121.3571968593 DERLIN WAY,SACRAMENTO,95823,CA,3,2,1436,Residential,Mon May 19 00:00:00 EDT 2008,180000,38.447585,-121.4266279273 PREMIER WAY,SACRAMENTO,95826,CA,3,2,1451,Residential,Mon May 19 00:00:00 EDT 2008,180000,38.55992,-121.3525398032 DUSENBERG CT,SACRAMENTO,95828,CA,4,2,1638,Residential,Mon May 19 00:00:00 EDT 2008,180000,38.466499,-121.3811197110 STELLA LN Unit 15,CARMICHAEL,95608,CA,2,2,1000,Condo,Mon May 19 00:00:00 EDT 2008,182000,38.637396,-121.3000551786 PIEDMONT WAY,ROSEVILLE,95661,CA,3,1,1152,Residential,Mon May 19 00:00:00 EDT 2008,188325,38.72748,-121.2565371347 HIDALGO CIR,ROSEVILLE,95747,CA,3,2,1154,Residential,Mon May 19 00:00:00 EDT 2008,191500,38.747878,-121.311279212 CAPPUCINO WAY,SACRAMENTO,95838,CA,3,2,1353,Residential,Mon May 19 00:00:00 EDT 2008,192000,38.657811,-121.4653275938 WOODBRIAR WAY,CITRUS HEIGHTS,95621,CA,3,2,1329,Residential,Mon May 19 00:00:00 EDT 2008,192700,38.706152,-121.3253993801 WILDROSE WAY,SACRAMENTO,95826,CA,3,1,1356,Residential,Mon May 19 00:00:00 EDT 2008,195000,38.544368,-121.369979508 SAMUEL WAY,SACRAMENTO,95838,CA,3,2,1505,Residential,Mon May 19 00:00:00 EDT 2008,197654,38.645689,-121.4527666128 CARL SANDBURG CIR,SACRAMENTO,95842,CA,3,1,1009,Residential,Mon May 19 00:00:00 EDT 2008,198000,38.681541,-121.3556161 KENNELFORD CIR,SACRAMENTO,95823,CA,3,2,1144,Residential,Mon May 19 00:00:00 EDT 2008,200345,38.46452,-121.427606909 SINGINGWOOD RD,SACRAMENTO,95864,CA,2,1,930,Residential,Mon May 19 00:00:00 EDT 2008,203000,38.581471,-121.388396671 FOXWOOD CT,SACRAMENTO,95841,CA,4,2,1766,Residential,Mon May 19 00:00:00 EDT 2008,207000,38.687943,-121.3288838165 AYN RAND CT,SACRAMENTO,95828,CA,4,3,1940,Residential,Mon May 19 00:00:00 EDT 2008,208000,38.468639,-121.4032659474 VILLAGE TREE DR,ELK GROVE,95758,CA,4,2,1776,Residential,Mon May 19 00:00:00 EDT 2008,210000,38.413947,-121.4082767213 CALVIN DR,CITRUS HEIGHTS,95621,CA,3,1,1258,Residential,Mon May 19 00:00:00 EDT 2008,212000,38.698154,-121.2983758167 DERBY PARK CT,SACRAMENTO,95828,CA,4,2,1872,Residential,Mon May 19 00:00:00 EDT 2008,213675,38.460492,-121.3733796344 LAGUNA MIRAGE LN,ELK GROVE,95758,CA,2,2,1112,Residential,Mon May 19 00:00:00 EDT 2008,213697,38.423963,-121.4288752945 RED HAWK WAY,SACRAMENTO,95833,CA,4,2,1856,Residential,Mon May 19 00:00:00 EDT 2008,215000,38.619675,-121.4969033228 I ST,SACRAMENTO,95816,CA,4,3,1939,Residential,Mon May 19 00:00:00 EDT 2008,215000,38.573844,-121.462839308 ATKINSON ST,ROSEVILLE,95678,CA,3,1,998,Residential,Mon May 19 00:00:00 EDT 2008,215100,38.746794,-121.29971624 HOVEY WAY,ROSEVILLE,95678,CA,3,2,1758,Residential,Mon May 19 00:00:00 EDT 2008,217500,38.756149,-121.306479110 COPPER LEAF WAY,SACRAMENTO,95838,CA,3,2,2142,Residential,Mon May 19 00:00:00 EDT 2008,218000,38.658466,-121.4606617535 ALMA VISTA WAY,SACRAMENTO,95831,CA,2,1,950,Residential,Mon May 19 00:00:00 EDT 2008,220000,38.48403,-121.5076417423 WILSALL CT,ELK GROVE,95758,CA,4,3,1739,Residential,Mon May 19 00:00:00 EDT 2008,221000,38.417026,-121.4168218629 VIA ALTA WAY,ELK GROVE,95624,CA,3,2,1516,Residential,Mon May 19 00:00:00 EDT 2008,222900,38.398245,-121.3806153318 DAVIDSON DR,ANTELOPE,95843,CA,3,1,988,Residential,Mon May 19 00:00:00 EDT 2008,223139,38.705753,-121.388917913 COBDEN CT,GALT,95632,CA,4,2,1555,Residential,Mon May 19 00:00:00 EDT 2008,225500,38.282001,-121.2959024419 79TH ST,SACRAMENTO,95820,CA,3,2,1212,Residential,Mon May 19 00:00:00 EDT 2008,228327,38.534827,-121.4125453012 SPOONWOOD WAY,SACRAMENTO,95833,CA,4,2,1871,Residential,Mon May 19 00:00:00 EDT 2008,230000,38.62478,-121.5234748728 CRYSTAL RIVER WAY,SACRAMENTO,95828,CA,3,2,1302,Residential,Mon May 19 00:00:00 EDT 2008,230000,38.47547,-121.3800554709 AMBER LN Unit 1,SACRAMENTO,95841,CA,2,1,756,Condo,Mon May 19 00:00:00 EDT 2008,230522,38.657789,-121.3549944508 OLD DAIRY DR,ANTELOPE,95843,CA,4,3,2026,Residential,Mon May 19 00:00:00 EDT 2008,231200,38.72286,-121.358939312 RIVER ISLE WAY,SACRAMENTO,95831,CA,3,2,1375,Residential,Mon May 19 00:00:00 EDT 2008,232000,38.49026,-121.550527301 OLIVADI WAY,SACRAMENTO,95834,CA,2,2,1250,Condo,Mon May 19 00:00:00 EDT 2008,232500,38.644406,-121.5490495636 25TH ST,SACRAMENTO,95822,CA,3,1,1058,Residential,Mon May 19 00:00:00 EDT 2008,233641,38.523828,-121.4811398721 SPRUCE RIDGE WAY,ANTELOPE,95843,CA,3,2,1187,Residential,Mon May 19 00:00:00 EDT 2008,234000,38.727657,-121.3910287461 WINDBRIDGE DR,SACRAMENTO,95831,CA,2,2,1324,Residential,Mon May 19 00:00:00 EDT 2008,234500,38.48797,-121.5302298101 LEMON COVE CT,SACRAMENTO,95828,CA,4,3,1936,Residential,Mon May 19 00:00:00 EDT 2008,235000,38.462981,-121.40828810949 SCOTSMAN WAY,RANCHO CORDOVA,95670,CA,5,4,2382,Multi-Family,Mon May 19 00:00:00 EDT 2008,236000,38.603686,-121.277844617 WILLOW CREEK DR,FOLSOM,95630,CA,3,2,1427,Residential,Mon May 19 00:00:00 EDT 2008,236073,38.679626,-121.1426093301 PARK DR Unit 1914,SACRAMENTO,95835,CA,3,2,1678,Condo,Mon May 19 00:00:00 EDT 2008,238000,38.665296,-121.531993709 CIMMARON CT,GALT,95632,CA,4,2,1798,Residential,Mon May 19 00:00:00 EDT 2008,238861,38.277177,-121.3037473305 RIO ROCA CT,ANTELOPE,95843,CA,4,3,2652,Residential,Mon May 19 00:00:00 EDT 2008,239700,38.725079,-121.3876989080 BEDROCK CT,SACRAMENTO,95829,CA,4,2,1816,Residential,Mon May 19 00:00:00 EDT 2008,240000,38.456939,-121.362965100 TOURMALINE CIR,SACRAMENTO,95834,CA,5,3,3076,Residential,Mon May 19 00:00:00 EDT 2008,240000,38.63437,-121.5107796411 RED BIRCH WAY,ELK GROVE,95758,CA,4,2,1844,Residential,Mon May 19 00:00:00 EDT 2008,241000,38.43461,-121.4293164867 LAGUNA DR,SACRAMENTO,95823,CA,3,2,1306,Residential,Mon May 19 00:00:00 EDT 2008,245000,38.46179,-121.4453713662 RIVER DR,SACRAMENTO,95833,CA,4,3,2447,Residential,Mon May 19 00:00:00 EDT 2008,246000,38.604969,-121.542556943 WOLFGRAM WAY,SACRAMENTO,95828,CA,4,2,1176,Residential,Mon May 19 00:00:00 EDT 2008,247234,38.489215,-121.41954677 RINETTI WAY,RIO LINDA,95673,CA,4,2,1182,Residential,Mon May 19 00:00:00 EDT 2008,247480,38.687021,-121.4631511316 I ST,RIO LINDA,95673,CA,3,1,1160,Residential,Mon May 19 00:00:00 EDT 2008,249862,38.683674,-121.4352042130 CATHERWOOD WAY,SACRAMENTO,95835,CA,3,2,1424,Residential,Mon May 19 00:00:00 EDT 2008,251000,38.675506,-121.5109878304 JUGLANS DR,ORANGEVALE,95662,CA,4,2,1574,Residential,Mon May 19 00:00:00 EDT 2008,252155,38.691829,-121.2490335308 MARBURY WAY,ANTELOPE,95843,CA,3,2,1830,Residential,Mon May 19 00:00:00 EDT 2008,254172,38.710221,-121.3417079182 LAKEMONT DR,ELK GROVE,95624,CA,4,2,1724,Residential,Mon May 19 00:00:00 EDT 2008,258000,38.451353,-121.3587762231 COUNTRY VILLA CT,AUBURN,95603,CA,2,2,1255,Condo,Mon May 19 00:00:00 EDT 2008,260000,38.931671,-121.0978628491 CRYSTAL WALK CIR,ELK GROVE,95758,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,261000,38.416916,-121.407554361 MAHONIA CIR,SACRAMENTO,95835,CA,4,3,2175,Residential,Mon May 19 00:00:00 EDT 2008,261000,38.676172,-121.5097613427 LA CADENA WAY,SACRAMENTO,95835,CA,4,2,1904,Residential,Mon May 19 00:00:00 EDT 2008,261000,38.681194,-121.537351955 BIG SUR CT,EL DORADO HILLS,95762,CA,4,2,1808,Residential,Mon May 19 00:00:00 EDT 2008,262500,38.664347,-121.07652911826 DIONYSUS WAY,RANCHO CORDOVA,95742,CA,4,2,2711,Residential,Mon May 19 00:00:00 EDT 2008,266000,38.551046,-121.2394115847 DEL CAMPO LN,CARMICHAEL,95608,CA,3,1,1713,Residential,Mon May 19 00:00:00 EDT 2008,266000,38.671995,-121.3243395635 FOXVIEW WAY,ELK GROVE,95757,CA,3,2,1457,Residential,Mon May 19 00:00:00 EDT 2008,270000,38.395256,-121.43824910372 VIA CINTA CT,ELK GROVE,95757,CA,4,3,2724,Residential,Mon May 19 00:00:00 EDT 2008,274425,38.380089,-121.4281866286 LONETREE BLVD,ROCKLIN,95765,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,274500,38.805036,-121.2936087744 SOUTHBREEZE DR,SACRAMENTO,95828,CA,3,2,1468,Residential,Mon May 19 00:00:00 EDT 2008,275336,38.476932,-121.3783492242 ABLE WAY,SACRAMENTO,95835,CA,4,3,2550,Residential,Mon May 19 00:00:00 EDT 2008,277980,38.666074,-121.5097431042 STARBROOK DR,GALT,95632,CA,4,2,1928,Residential,Mon May 19 00:00:00 EDT 2008,280000,38.285611,-121.2930631219 G ST,SACRAMENTO,95814,CA,3,3,1922,Residential,Mon May 19 00:00:00 EDT 2008,284686,38.582818,-121.4890966220 OPUS CT,CITRUS HEIGHTS,95621,CA,3,2,1343,Residential,Mon May 19 00:00:00 EDT 2008,284893,38.715853,-121.3170955419 HAVENHURST CIR,ROCKLIN,95677,CA,3,2,1510,Residential,Mon May 19 00:00:00 EDT 2008,285000,38.786746,-121.209957220 OLD AIRPORT RD,AUBURN,95603,CA,2,2,960,Multi-Family,Mon May 19 00:00:00 EDT 2008,285000,38.939802,-121.0545754622 MEYER WAY,CARMICHAEL,95608,CA,4,2,1559,Residential,Mon May 19 00:00:00 EDT 2008,285000,38.64913,-121.3106674885 SUMMIT VIEW DR,EL DORADO,95623,CA,3,2,1624,Residential,Mon May 19 00:00:00 EDT 2008,289000,38.673285,-120.87917626 JEANROSS CT,SACRAMENTO,95832,CA,5,3,2992,Residential,Mon May 19 00:00:00 EDT 2008,295000,38.473162,-121.4910854800 MAPLEPLAIN AVE,ELK GROVE,95758,CA,4,2,2109,Residential,Mon May 19 00:00:00 EDT 2008,296000,38.432848,-121.44923710629 BASIE WAY,RANCHO CORDOVA,95670,CA,4,2,1524,Residential,Mon May 19 00:00:00 EDT 2008,296056,38.579,-121.2926278612 WILLOW GROVE WAY,SACRAMENTO,95828,CA,3,2,1248,Residential,Mon May 19 00:00:00 EDT 2008,297359,38.464994,-121.38696262 DE FER CIR,SACRAMENTO,95823,CA,4,2,1876,Residential,Mon May 19 00:00:00 EDT 2008,299940,38.49254,-121.4633162513 OLD KENMARE RD,LINCOLN,95648,CA,5,3,0,Residential,Mon May 19 00:00:00 EDT 2008,304000,38.847396,-121.2595863253 ABOTO WAY,RANCHO CORDOVA,95670,CA,4,3,1851,Residential,Mon May 19 00:00:00 EDT 2008,305000,38.57727,-121.2855913072 VILLAGE PLAZA DR,ROSEVILLE,95747,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,307000,38.773094,-121.365905251 CHANGO CIR,SACRAMENTO,95835,CA,4,2,2218,Residential,Mon May 19 00:00:00 EDT 2008,311328,38.68237,-121.5391478205 WEYBURN CT,SACRAMENTO,95828,CA,3,2,1394,Residential,Mon May 19 00:00:00 EDT 2008,313138,38.47316,-121.4038938788 LA MARGARITA WAY,SACRAMENTO,95828,CA,3,2,1410,Residential,Mon May 19 00:00:00 EDT 2008,316630,38.468185,-121.3756945912 DEEPDALE WAY,ELK GROVE,95758,CA,5,3,3468,Residential,Mon May 19 00:00:00 EDT 2008,320000,38.439565,-121.4366064712 PISMO BEACH DR,ANTELOPE,95843,CA,5,3,2346,Residential,Mon May 19 00:00:00 EDT 2008,320000,38.707705,-121.3541534741 PACIFIC PARK DR,ANTELOPE,95843,CA,5,3,2347,Residential,Mon May 19 00:00:00 EDT 2008,325000,38.709299,-121.353056310 GROTH CIR,SACRAMENTO,95834,CA,4,2,1659,Residential,Mon May 19 00:00:00 EDT 2008,328578,38.638764,-121.5318276121 WILD FOX CT,ELK GROVE,95757,CA,3,3,2442,Residential,Mon May 19 00:00:00 EDT 2008,331000,38.406758,-121.43166912241 CANYONLANDS DR,RANCHO CORDOVA,95742,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,331500,38.557293,-121.21761129 COOL FOUNTAIN CT,SACRAMENTO,95833,CA,4,2,2155,Residential,Mon May 19 00:00:00 EDT 2008,340000,38.606906,-121.54132907 RIO ROBLES AVE,SACRAMENTO,95838,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,344755,38.664765,-121.4450068909 BILLFISH WAY,SACRAMENTO,95828,CA,3,2,1810,Residential,Mon May 19 00:00:00 EDT 2008,345746,38.475433,-121.3725846232 GUS WAY,ELK GROVE,95757,CA,4,2,2789,Residential,Mon May 19 00:00:00 EDT 2008,351000,38.388129,-121.43117200 OAKWILDE ST,GALT,95632,CA,4,2,1606,Residential,Mon May 19 00:00:00 EDT 2008,353767,38.2535,-121.318121033 PARK STREAM DR,GALT,95632,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,355000,38.287785,-121.289903200 ALLAIRE CIR,SACRAMENTO,95835,CA,4,2,2166,Residential,Mon May 19 00:00:00 EDT 2008,356035,38.68318,-121.534841322 SUTTER WALK,SACRAMENTO,95816,CA,0,0,0,Condo,Mon May 19 00:00:00 EDT 2008,360000,38.53805,-121.50475479 NICKMAN WAY,SACRAMENTO,95835,CA,4,2,1871,Residential,Mon May 19 00:00:00 EDT 2008,360552,38.672966,-121.5027482103 BURBERRY WAY,SACRAMENTO,95835,CA,3,2,1800,Residential,Mon May 19 00:00:00 EDT 2008,362305,38.67342,-121.5085422450 SAN JOSE WAY,SACRAMENTO,95817,CA,3,1,1683,Residential,Mon May 19 00:00:00 EDT 2008,365000,38.553596,-121.4594837641 ROSEHALL DR,ROSEVILLE,95678,CA,3,2,0,Residential,Mon May 19 00:00:00 EDT 2008,367554,38.791617,-121.2861471336 LAYSAN TEAL DR,ROSEVILLE,95747,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,368500,38.796121,-121.3199632802 BLACK OAK DR,ROCKLIN,95765,CA,2,2,1596,Residential,Mon May 19 00:00:00 EDT 2008,370000,38.837006,-121.2320242113 FALL TRAIL CT,PLACERVILLE,95667,CA,4,2,0,Residential,Mon May 19 00:00:00 EDT 2008,371086,38.733155,-120.74803910112 LAMBEAU CT,ELK GROVE,95757,CA,3,2,1179,Residential,Mon May 19 00:00:00 EDT 2008,378000,38.390328,-121.4480226313 CASTRO VERDE WAY,ELK GROVE,95757,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,383000,38.381102,-121.429013622 CURTIS DR,SACRAMENTO,95818,CA,3,1,1639,Residential,Mon May 19 00:00:00 EDT 2008,388000,38.541735,-121.48009811817 OPAL RIDGE WAY,RANCHO CORDOVA,95742,CA,5,3,3281,Residential,Mon May 19 00:00:00 EDT 2008,395100,38.551083,-121.237476170 LAGOMARSINO WAY,SACRAMENTO,95819,CA,3,2,1697,Residential,Mon May 19 00:00:00 EDT 2008,400000,38.574894,-121.4358062743 DEAKIN PL,EL DORADO HILLS,95762,CA,3,2,0,Residential,Mon May 19 00:00:00 EDT 2008,400000,38.69288,-121.0735513361 ALDER CANYON WAY,ANTELOPE,95843,CA,4,3,2085,Residential,Mon May 19 00:00:00 EDT 2008,408431,38.727649,-121.3856562148 RANCH VIEW DR,ROCKLIN,95765,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,413000,38.837455,-121.289337398 LINDLEY DR,SACRAMENTO,95815,CA,4,2,1744,Multi-Family,Mon May 19 00:00:00 EDT 2008,416767,38.622359,-121.4575823013 BRIDLEWOOD DR,EL DORADO HILLS,95762,CA,4,3,0,Residential,Mon May 19 00:00:00 EDT 2008,420000,38.675519,-121.015862169 BAURER CIR,FOLSOM,95630,CA,4,3,1939,Residential,Mon May 19 00:00:00 EDT 2008,423000,38.66695,-121.1207292809 LOON CT,CAMERON PARK,95682,CA,4,2,0,Residential,Mon May 19 00:00:00 EDT 2008,423000,38.687072,-121.0047291315 KONDOS AVE,SACRAMENTO,95814,CA,2,3,1788,Residential,Mon May 19 00:00:00 EDT 2008,427500,38.571943,-121.4921064966 CHARTER RD,ROCKLIN,95765,CA,3,2,1691,Residential,Mon May 19 00:00:00 EDT 2008,430922,38.82553,-121.2546989516 LAGUNA LAKE WAY,ELK GROVE,95758,CA,4,2,2002,Residential,Mon May 19 00:00:00 EDT 2008,445000,38.411258,-121.4313485201 BLOSSOM RANCH DR,ELK GROVE,95757,CA,4,4,4303,Residential,Mon May 19 00:00:00 EDT 2008,450000,38.399436,-121.4440413027 PALMATE WAY,SACRAMENTO,95834,CA,5,3,4246,Residential,Mon May 19 00:00:00 EDT 2008,452000,38.628955,-121.529269500 WINCHESTER CT,ROSEVILLE,95661,CA,3,2,2274,Residential,Mon May 19 00:00:00 EDT 2008,470000,38.73988,-121.2489295746 GELSTON WAY,EL DORADO HILLS,95762,CA,4,3,0,Residential,Mon May 19 00:00:00 EDT 2008,471000,38.677015,-121.0340836935 ELM TREE LN,ORANGEVALE,95662,CA,4,4,3056,Residential,Mon May 19 00:00:00 EDT 2008,475000,38.693041,-121.232949605 GOLF COURSE LN,ELK GROVE,95758,CA,3,3,2503,Residential,Mon May 19 00:00:00 EDT 2008,484500,38.409689,-121.446059719 BAYWOOD CT,EL DORADO HILLS,95762,CA,5,3,0,Residential,Mon May 19 00:00:00 EDT 2008,487500,38.647598,-121.0778015954 TANUS CIR,ROCKLIN,95677,CA,3,3,0,Residential,Mon May 19 00:00:00 EDT 2008,488750,38.777585,-121.2036100 CHELSEA CT,FOLSOM,95630,CA,3,2,1905,Residential,Mon May 19 00:00:00 EDT 2008,500000,38.69435,-121.1772591500 ORANGE HILL LN,PENRYN,95663,CA,3,2,1320,Residential,Mon May 19 00:00:00 EDT 2008,506688,38.862708,-121.162092408 KIRKWOOD CT,LINCOLN,95648,CA,2,2,0,Residential,Mon May 19 00:00:00 EDT 2008,512000,38.861615,-121.268691732 TUSCAN GROVE CIR,ROSEVILLE,95747,CA,5,3,0,Residential,Mon May 19 00:00:00 EDT 2008,520000,38.796683,-121.3425552049 EMPIRE MINE CIR,GOLD RIVER,95670,CA,4,2,3037,Residential,Mon May 19 00:00:00 EDT 2008,528000,38.629299,-121.2490219360 MAGOS RD,WILTON,95693,CA,5,2,3741,Residential,Mon May 19 00:00:00 EDT 2008,579093,38.416809,-121.240628104 CATLIN CT,FOLSOM,95630,CA,4,3,2660,Residential,Mon May 19 00:00:00 EDT 2008,636000,38.684459,-121.1459354734 GIBBONS DR,CARMICHAEL,95608,CA,4,3,3357,Residential,Mon May 19 00:00:00 EDT 2008,668365,38.63558,-121.3536394629 DORCHESTER LN,GRANITE BAY,95746,CA,5,3,2896,Residential,Mon May 19 00:00:00 EDT 2008,676200,38.723545,-121.2160252400 COUNTRYSIDE DR,PLACERVILLE,95667,CA,3,2,2025,Residential,Mon May 19 00:00:00 EDT 2008,677048,38.737452,-120.91096312901 FURLONG DR,WILTON,95693,CA,5,3,3788,Residential,Mon May 19 00:00:00 EDT 2008,691659,38.413535,-121.1882116222 CALLE MONTALVO CIR,GRANITE BAY,95746,CA,5,3,3670,Residential,Mon May 19 00:00:00 EDT 2008,760000,38.779435,-121.14667620 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.885327,-121.28941224 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.885132,-121.28940528 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.884936,-121.28939732 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.884741,-121.2893936 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.884599,-121.28940640 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.884535,-121.28961944 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.88459,-121.28983548 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.884667,-121.28989652 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.88478,-121.28991168 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.885236,-121.28992872 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.88535,-121.28992676 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.885464,-121.28992280 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.885578,-121.28991984 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.885692,-121.28991588 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.885806,-121.28991192 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.88592,-121.28990896 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.886024,-121.289859100 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.886091,-121.289744434 1ST ST,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.88653,-121.2894063 E ST,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.884692,-121.29028811 E ST,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.884879,-121.29025719 E ST,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.885017,-121.29026227 E ST,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.885173,-121.2902735 E ST,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.885328,-121.29027543 E ST,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.885483,-121.29027751 E ST,LINCOLN,95648,CA,4,2,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.885638,-121.29027959 E ST,LINCOLN,95648,CA,3,2,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.885794,-121.29028175 E ST,LINCOLN,95648,CA,3,2,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.886104,-121.29028563 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.885093,-121.289932398 1ST ST,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.88653,-121.288952386 1ST ST,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.886528,-121.288869374 1ST ST,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.886525,-121.288787116 CRYSTALWOOD WAY,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.886282,-121.289586108 CRYSTALWOOD WAY,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.886282,-121.289646100 CRYSTALWOOD WAY,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.886282,-121.28970655 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.884865,-121.28992251 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.884752,-121.28990747 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.884638,-121.28989343 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.884568,-121.28978439 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.884546,-121.28956235 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.884645,-121.28939731 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.88479,-121.28939227 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.884985,-121.28939923 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.885181,-121.28940619 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.885376,-121.28941415 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.885571,-121.2894217 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.885962,-121.2894367 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.885962,-121.2894363 CRYSTALWOOD CIR,LINCOLN,95648,CA,0,0,0,Residential,Mon May 19 00:00:00 EDT 2008,4897,38.886093,-121.2895848208 WOODYARD WAY,CITRUS HEIGHTS,95621,CA,3,2,1166,Residential,Fri May 16 00:00:00 EDT 2008,30000,38.715322,-121.314787113 RINETTI WAY,RIO LINDA,95673,CA,0,0,0,Residential,Fri May 16 00:00:00 EDT 2008,30000,38.687172,-121.46393315 LOORZ CT,SACRAMENTO,95823,CA,2,1,838,Residential,Fri May 16 00:00:00 EDT 2008,55422,38.471646,-121.4351585805 DOTMAR WAY,NORTH HIGHLANDS,95660,CA,2,1,904,Residential,Fri May 16 00:00:00 EDT 2008,63000,38.672642,-121.3803432332 CAMBRIDGE ST,SACRAMENTO,95815,CA,2,1,1032,Residential,Fri May 16 00:00:00 EDT 2008,65000,38.608085,-121.4496513812 BELDEN ST,SACRAMENTO,95838,CA,2,1,904,Residential,Fri May 16 00:00:00 EDT 2008,65000,38.636833,-121.441643348 40TH ST,SACRAMENTO,95817,CA,2,1,1080,Residential,Fri May 16 00:00:00 EDT 2008,65000,38.544162,-121.460652127 QUASAR CIR,SACRAMENTO,95822,CA,2,2,990,Residential,Fri May 16 00:00:00 EDT 2008,66500,38.493504,-121.4753043812 CYPRESS ST,SACRAMENTO,95838,CA,2,1,900,Residential,Fri May 16 00:00:00 EDT 2008,71000,38.636877,-121.4449485821 64TH ST,SACRAMENTO,95824,CA,2,1,861,Residential,Fri May 16 00:00:00 EDT 2008,75000,38.521202,-121.4281468248 CENTER PKWY,SACRAMENTO,95823,CA,2,1,906,Condo,Fri May 16 00:00:00 EDT 2008,77000,38.459002,-121.4287941171 SONOMA AVE,SACRAMENTO,95815,CA,2,1,1011,Residential,Fri May 16 00:00:00 EDT 2008,85000,38.6238,-121.4398724250 ARDWELL WAY,SACRAMENTO,95823,CA,3,2,1089,Residential,Fri May 16 00:00:00 EDT 2008,95625,38.466938,-121.4556313104 CLAY ST,SACRAMENTO,95815,CA,2,1,832,Residential,Fri May 16 00:00:00 EDT 2008,96140,38.62391,-121.4392086063 LAND PARK DR,SACRAMENTO,95822,CA,2,1,800,Condo,Fri May 16 00:00:00 EDT 2008,104250,38.517029,-121.5138094738 OAKHOLLOW DR,SACRAMENTO,95842,CA,4,2,1292,Residential,Fri May 16 00:00:00 EDT 2008,105000,38.679598,-121.3560351401 STERLING ST,SACRAMENTO,95822,CA,2,1,810,Residential,Fri May 16 00:00:00 EDT 2008,108000,38.520319,-121.5047273715 DIDCOT CIR,SACRAMENTO,95838,CA,4,2,1064,Residential,Fri May 16 00:00:00 EDT 2008,109000,38.635232,-121.4600982426 RASHAWN DR,RANCHO CORDOVA,95670,CA,2,1,911,Residential,Fri May 16 00:00:00 EDT 2008,115000,38.610852,-121.2732784800 WESTLAKE PKWY Unit 410,SACRAMENTO,95835,CA,1,1,846,Condo,Fri May 16 00:00:00 EDT 2008,115000,38.658812,-121.5423453409 VIRGO ST,SACRAMENTO,95827,CA,3,2,1320,Residential,Fri May 16 00:00:00 EDT 2008,115500,38.563402,-121.3277471110 PINEDALE AVE,SACRAMENTO,95838,CA,3,2,1410,Residential,Fri May 16 00:00:00 EDT 2008,115620,38.660173,-121.4402162361 LA LOMA DR,RANCHO CORDOVA,95670,CA,3,2,1115,Residential,Fri May 16 00:00:00 EDT 2008,116000,38.59368,-121.3160541455 64TH AVE,SACRAMENTO,95822,CA,3,2,1169,Residential,Fri May 16 00:00:00 EDT 2008,122000,38.492177,-121.5033927328 SPRINGMAN ST,SACRAMENTO,95822,CA,3,2,1164,Residential,Fri May 16 00:00:00 EDT 2008,122500,38.491991,-121.477636119 SAINT MARIE CIR,SACRAMENTO,95823,CA,4,2,1341,Residential,Fri May 16 00:00:00 EDT 2008,123000,38.481454,-121.44664412 COSTA BRASE CT,SACRAMENTO,95838,CA,3,2,1219,Residential,Fri May 16 00:00:00 EDT 2008,124000,38.655554,-121.4642756813 SCOTER WAY,SACRAMENTO,95842,CA,4,2,1127,Residential,Fri May 16 00:00:00 EDT 2008,124000,38.69043,-121.3610356548 GRAYLOCK LN,NORTH HIGHLANDS,95660,CA,3,2,1272,Residential,Fri May 16 00:00:00 EDT 2008,124413,38.686061,-121.3699491630 GLIDDEN AVE,SACRAMENTO,95822,CA,4,2,1253,Residential,Fri May 16 00:00:00 EDT 2008,125000,38.482717,-121.4996837825 DALEWOODS WAY,SACRAMENTO,95828,CA,3,2,1120,Residential,Fri May 16 00:00:00 EDT 2008,130000,38.477297,-121.4115134073 TRESLER AVE,NORTH HIGHLANDS,95660,CA,2,2,1118,Residential,Fri May 16 00:00:00 EDT 2008,131750,38.659016,-121.3704574288 DYMIC WAY,SACRAMENTO,95838,CA,4,3,1890,Residential,Fri May 16 00:00:00 EDT 2008,137721,38.646541,-121.4411391158 SAN IGNACIO WAY,SACRAMENTO,95833,CA,3,2,1260,Residential,Fri May 16 00:00:00 EDT 2008,137760,38.623045,-121.4862794904 J PKWY,SACRAMENTO,95823,CA,3,2,1400,Residential,Fri May 16 00:00:00 EDT 2008,138000,38.487297,-121.442952931 HOWE AVE,SACRAMENTO,95821,CA,3,1,1264,Residential,Fri May 16 00:00:00 EDT 2008,140000,38.619012,-121.4153295531 JANSEN DR,SACRAMENTO,95824,CA,3,1,1060,Residential,Fri May 16 00:00:00 EDT 2008,145000,38.522015,-121.4387137836 ORCHARD WOODS CIR,SACRAMENTO,95828,CA,2,2,1132,Residential,Fri May 16 00:00:00 EDT 2008,145000,38.47955,-121.4108674055 DEERBROOK DR,SACRAMENTO,95823,CA,3,2,1466,Residential,Fri May 16 00:00:00 EDT 2008,150000,38.472117,-121.4595899937 BURLINE ST,SACRAMENTO,95827,CA,3,2,1092,Residential,Fri May 16 00:00:00 EDT 2008,150000,38.559641,-121.323166948 MIRADOR WAY,SACRAMENTO,95828,CA,4,2,1628,Residential,Fri May 16 00:00:00 EDT 2008,151000,38.493484,-121.420354909 RUGER CT,SACRAMENTO,95842,CA,3,2,960,Residential,Fri May 16 00:00:00 EDT 2008,155000,38.68747,-121.3492347204 KERSTEN ST,CITRUS HEIGHTS,95621,CA,3,2,1075,Residential,Fri May 16 00:00:00 EDT 2008,155800,38.695863,-121.3008143150 ROSEMONT DR,SACRAMENTO,95826,CA,3,2,1428,Residential,Fri May 16 00:00:00 EDT 2008,156142,38.554927,-121.355218200 STEINBECK WAY,SACRAMENTO,95828,CA,4,2,1358,Residential,Fri May 16 00:00:00 EDT 2008,158000,38.474854,-121.4047268198 STEVENSON AVE,SACRAMENTO,95828,CA,6,4,2475,Multi-Family,Fri May 16 00:00:00 EDT 2008,159900,38.465271,-121.404266824 OLIVE TREE WAY,CITRUS HEIGHTS,95610,CA,3,2,1410,Residential,Fri May 16 00:00:00 EDT 2008,160000,38.689239,-121.2677373536 SUN MAIDEN WAY,ANTELOPE,95843,CA,3,2,1711,Residential,Fri May 16 00:00:00 EDT 2008,161500,38.70968,-121.3823284517 OLYMPIAD WAY,SACRAMENTO,95826,CA,4,2,1483,Residential,Fri May 16 00:00:00 EDT 2008,161600,38.536751,-121.359154925 COBDEN CT,GALT,95632,CA,3,2,1140,Residential,Fri May 16 00:00:00 EDT 2008,162000,38.282047,-121.2958128225 SCOTTSDALE DR,SACRAMENTO,95828,CA,4,2,1549,Residential,Fri May 16 00:00:00 EDT 2008,165000,38.487864,-121.4024768758 LEMAS RD,SACRAMENTO,95828,CA,3,2,1410,Residential,Fri May 16 00:00:00 EDT 2008,165000,38.467487,-121.3770556121 ALPINESPRING WAY,ELK GROVE,95758,CA,3,2,1240,Residential,Fri May 16 00:00:00 EDT 2008,167293,38.434075,-121.4326235937 YORK GLEN WAY,SACRAMENTO,95842,CA,5,2,1712,Residential,Fri May 16 00:00:00 EDT 2008,168000,38.677003,-121.3544546417 SUNNYFIELD WAY,SACRAMENTO,95823,CA,4,2,1580,Residential,Fri May 16 00:00:00 EDT 2008,168000,38.449153,-121.4282724008 GREY LIVERY WAY,ANTELOPE,95843,CA,3,2,1669,Residential,Fri May 16 00:00:00 EDT 2008,168750,38.71846,-121.3708628920 ROSETTA CIR,SACRAMENTO,95826,CA,3,1,1029,Residential,Fri May 16 00:00:00 EDT 2008,168750,38.544374,-121.3708748300 LICHEN DR,CITRUS HEIGHTS,95621,CA,3,1,1103,Residential,Fri May 16 00:00:00 EDT 2008,170000,38.71641,-121.3062398884 AMBERJACK WAY,SACRAMENTO,95828,CA,3,2,2161,Residential,Fri May 16 00:00:00 EDT 2008,170250,38.479343,-121.3725534480 VALLEY HI DR,SACRAMENTO,95823,CA,3,2,1650,Residential,Fri May 16 00:00:00 EDT 2008,173000,38.466781,-121.4509552250 FOREBAY RD,POLLOCK PINES,95726,CA,3,1,1320,Residential,Fri May 16 00:00:00 EDT 2008,175000,38.77491,-120.5975993529 FABERGE WAY,SACRAMENTO,95826,CA,3,2,1200,Residential,Fri May 16 00:00:00 EDT 2008,176095,38.553275,-121.3462181792 DAWNELLE WAY,SACRAMENTO,95835,CA,3,2,1170,Residential,Fri May 16 00:00:00 EDT 2008,176250,38.68271,-121.5016977800 TABARE CT,CITRUS HEIGHTS,95621,CA,3,2,1199,Residential,Fri May 16 00:00:00 EDT 2008,178000,38.70799,-121.3029798531 HERMITAGE WAY,SACRAMENTO,95823,CA,4,2,1695,Residential,Fri May 16 00:00:00 EDT 2008,179000,38.448452,-121.4285362421 BERRYWOOD DR,RANCHO CORDOVA,95670,CA,3,2,1157,Residential,Fri May 16 00:00:00 EDT 2008,180000,38.60868,-121.278491005 MORENO WAY,SACRAMENTO,95838,CA,3,2,1410,Residential,Fri May 16 00:00:00 EDT 2008,180000,38.646206,-121.4427671675 VERNON ST Unit 24,ROSEVILLE,95678,CA,3,2,1174,Residential,Fri May 16 00:00:00 EDT 2008,180000,38.734136,-121.29963924 WINDCHIME CT,SACRAMENTO,95823,CA,3,2,1593,Residential,Fri May 16 00:00:00 EDT 2008,181000,38.44617,-121.427824540 HARLING CT,RIO LINDA,95673,CA,3,2,1093,Residential,Fri May 16 00:00:00 EDT 2008,182000,38.68279,-121.4535091207 CRESCENDO DR,ROSEVILLE,95678,CA,3,2,1770,Residential,Fri May 16 00:00:00 EDT 2008,182587,38.72446,-121.2928297577 EDDYLEE WAY,SACRAMENTO,95822,CA,4,2,1436,Residential,Fri May 16 00:00:00 EDT 2008,185074,38.48291,-121.4915098369 FOPPIANO WAY,SACRAMENTO,95829,CA,3,2,1124,Residential,Fri May 16 00:00:00 EDT 2008,185833,38.453839,-121.3579198817 SAWTELLE WAY,SACRAMENTO,95826,CA,4,2,1139,Residential,Fri May 16 00:00:00 EDT 2008,186785,38.565322,-121.3742511910 BONAVISTA WAY,SACRAMENTO,95832,CA,3,2,1638,Residential,Fri May 16 00:00:00 EDT 2008,187000,38.476048,-121.4949618 TIDE CT,SACRAMENTO,95833,CA,3,2,1328,Residential,Fri May 16 00:00:00 EDT 2008,188335,38.609864,-121.4923048952 ROCKY CREEK CT,ELK GROVE,95758,CA,3,2,1273,Residential,Fri May 16 00:00:00 EDT 2008,190000,38.431239,-121.44001435 EXCHANGE ST,SACRAMENTO,95838,CA,3,1,1082,Residential,Fri May 16 00:00:00 EDT 2008,190000,38.659434,-121.45523610105 MONTE VALLO CT,SACRAMENTO,95827,CA,4,2,1578,Residential,Fri May 16 00:00:00 EDT 2008,190000,38.573917,-121.3169163930 ANNABELLE AVE,ROSEVILLE,95661,CA,2,1,796,Residential,Fri May 16 00:00:00 EDT 2008,190000,38.727609,-121.2264944854 TANGERINE AVE,SACRAMENTO,95823,CA,3,2,1386,Residential,Fri May 16 00:00:00 EDT 2008,191250,38.478239,-121.4463262909 SHAWN WAY,RANCHO CORDOVA,95670,CA,3,2,1452,Residential,Fri May 16 00:00:00 EDT 2008,193000,38.589925,-121.2990594290 BLACKFORD WAY,SACRAMENTO,95823,CA,3,2,1513,Residential,Fri May 16 00:00:00 EDT 2008,193500,38.470494,-121.4541625890 TT TRAK,FORESTHILL,95631,CA,0,0,0,Residential,Fri May 16 00:00:00 EDT 2008,194818,39.020808,-120.8215187015 WOODSIDE DR,SACRAMENTO,95842,CA,4,2,1578,Residential,Fri May 16 00:00:00 EDT 2008,195000,38.693071,-121.3323656019 CHESHIRE WAY,CITRUS HEIGHTS,95610,CA,4,3,1736,Residential,Fri May 16 00:00:00 EDT 2008,195000,38.676437,-121.2791653330 VILLAGE CT,CAMERON PARK,95682,CA,2,2,0,Residential,Fri May 16 00:00:00 EDT 2008,195000,38.690504,-120.9962452561 VERNA WAY,SACRAMENTO,95821,CA,3,1,1473,Residential,Fri May 16 00:00:00 EDT 2008,195000,38.611055,-121.3699643522 22ND AVE,SACRAMENTO,95820,CA,3,1,1150,Residential,Fri May 16 00:00:00 EDT 2008,198000,38.532725,-121.4690782880 CANDIDO DR,SACRAMENTO,95833,CA,3,2,1127,Residential,Fri May 16 00:00:00 EDT 2008,199900,38.618019,-121.5102156908 PIN OAK CT,FAIR OAKS,95628,CA,3,1,1144,Residential,Fri May 16 00:00:00 EDT 2008,200000,38.66424,-121.3036755733 ANGELINA AVE,CARMICHAEL,95608,CA,3,1,972,Residential,Fri May 16 00:00:00 EDT 2008,201000,38.622634,-121.3308467849 BONNY DOWNS WAY,ELK GROVE,95758,CA,4,2,2306,Residential,Fri May 16 00:00:00 EDT 2008,204918,38.42139,-121.4113398716 LONGSPUR WAY,ANTELOPE,95843,CA,3,2,1479,Residential,Fri May 16 00:00:00 EDT 2008,205000,38.724083,-121.35846320 EL DORADO ST,EL DORADO,95623,CA,2,1,1040,Residential,Fri May 16 00:00:00 EDT 2008,205000,38.678758,-120.8441182328 DOROTHY JUNE WAY,SACRAMENTO,95838,CA,3,2,1430,Residential,Fri May 16 00:00:00 EDT 2008,205878,38.641727,-121.4127031986 DANVERS WAY,SACRAMENTO,95832,CA,4,2,1800,Residential,Fri May 16 00:00:00 EDT 2008,207000,38.47723,-121.4925687901 GAZELLE TRAIL WAY,ANTELOPE,95843,CA,4,2,1953,Residential,Fri May 16 00:00:00 EDT 2008,207744,38.71174,-121.3426756080 BRIDGECROSS DR,SACRAMENTO,95835,CA,3,2,1120,Residential,Fri May 16 00:00:00 EDT 2008,209000,38.681952,-121.50500920 GROTH CIR,SACRAMENTO,95834,CA,3,2,1232,Residential,Fri May 16 00:00:00 EDT 2008,210000,38.640807,-121.5335221900 DANBROOK DR,SACRAMENTO,95835,CA,1,1,984,Condo,Fri May 16 00:00:00 EDT 2008,210944,38.668433,-121.503471140 VENTO CT,ROSEVILLE,95678,CA,3,2,0,Condo,Fri May 16 00:00:00 EDT 2008,212500,38.793533,-121.2896858442 KEUSMAN ST,ELK GROVE,95758,CA,4,2,2329,Residential,Fri May 16 00:00:00 EDT 2008,213750,38.449651,-121.4147049552 SUNLIGHT LN,ELK GROVE,95758,CA,3,2,1351,Residential,Fri May 16 00:00:00 EDT 2008,215000,38.410561,-121.4043272733 YUMA CT,CAMERON PARK,95682,CA,2,2,0,Residential,Fri May 16 00:00:00 EDT 2008,215000,38.691215,-120.9949491407 TIFFANY CIR,ROSEVILLE,95661,CA,4,1,1376,Residential,Fri May 16 00:00:00 EDT 2008,215000,38.736392,-121.2664636 CRESTVIEW DR,DIAMOND SPRINGS,95619,CA,3,2,1300,Residential,Fri May 16 00:00:00 EDT 2008,216033,38.688255,-120.8102351528 HESKET WAY,SACRAMENTO,95825,CA,4,2,1566,Residential,Fri May 16 00:00:00 EDT 2008,220000,38.593598,-121.4036372327 32ND ST,SACRAMENTO,95817,CA,2,1,1115,Residential,Fri May 16 00:00:00 EDT 2008,220000,38.557433,-121.470341833 2ND AVE,SACRAMENTO,95818,CA,2,1,1032,Residential,Fri May 16 00:00:00 EDT 2008,220000,38.556818,-121.4906697252 CARRIAGE DR,CITRUS HEIGHTS,95621,CA,4,2,1419,Residential,Fri May 16 00:00:00 EDT 2008,220000,38.698058,-121.2948939815 PASO FINO WAY,ELK GROVE,95757,CA,3,2,1261,Residential,Fri May 16 00:00:00 EDT 2008,220000,38.404888,-121.4439985532 ENGLE RD,CARMICHAEL,95608,CA,2,2,1637,Residential,Fri May 16 00:00:00 EDT 2008,220702,38.63173,-121.3352861139 CLINTON RD,SACRAMENTO,95825,CA,4,2,1776,Multi-Family,Fri May 16 00:00:00 EDT 2008,221250,38.585291,-121.4068249176 SAGE GLEN WAY,ELK GROVE,95758,CA,3,2,1338,Residential,Fri May 16 00:00:00 EDT 2008,222000,38.423913,-121.4391159967 HATHERTON WAY,ELK GROVE,95757,CA,0,0,0,Residential,Fri May 16 00:00:00 EDT 2008,222500,38.3052,-121.40339264 BOULDER RIVER WAY,ELK GROVE,95624,CA,5,2,2254,Residential,Fri May 16 00:00:00 EDT 2008,222750,38.421713,-121.345191320 GROTH CIR,SACRAMENTO,95834,CA,3,2,1441,Residential,Fri May 16 00:00:00 EDT 2008,225000,38.638882,-121.531883137 GUNNISON AVE,SACRAMENTO,95838,CA,4,2,1991,Residential,Fri May 16 00:00:00 EDT 2008,225000,38.650729,-121.4664838209 RIVALLO WAY,SACRAMENTO,95829,CA,4,3,2126,Residential,Fri May 16 00:00:00 EDT 2008,228750,38.459524,-121.35018637 PERIWINKLE CIR,ELK GROVE,95624,CA,3,2,1094,Residential,Fri May 16 00:00:00 EDT 2008,229000,38.443184,-121.3643883425 MEADOW WAY,ROCKLIN,95677,CA,3,2,1462,Residential,Fri May 16 00:00:00 EDT 2008,230095,38.798028,-121.235364107 JARVIS CIR,SACRAMENTO,95834,CA,5,3,2258,Residential,Fri May 16 00:00:00 EDT 2008,232500,38.639891,-121.5376032319 THORES ST,RANCHO CORDOVA,95670,CA,3,2,1074,Residential,Fri May 16 00:00:00 EDT 2008,233000,38.59675,-121.3127168935 MOUNTAIN HOME CT,ELK GROVE,95624,CA,4,2,2111,Residential,Fri May 16 00:00:00 EDT 2008,233500,38.38751,-121.3702762566 SERENATA WAY,SACRAMENTO,95835,CA,3,2,1686,Residential,Fri May 16 00:00:00 EDT 2008,239000,38.671556,-121.5209164085 COUNTRY DR,ANTELOPE,95843,CA,4,3,1915,Residential,Fri May 16 00:00:00 EDT 2008,240000,38.706209,-121.3695099297 TROUT WAY,ELK GROVE,95624,CA,4,2,2367,Residential,Fri May 16 00:00:00 EDT 2008,240000,38.420637,-121.3757987 ARCHIBALD CT,SACRAMENTO,95823,CA,3,2,1962,Residential,Fri May 16 00:00:00 EDT 2008,240971,38.443305,-121.43529611130 EEL RIVER CT,RANCHO CORDOVA,95670,CA,2,2,1406,Residential,Fri May 16 00:00:00 EDT 2008,242000,38.625932,-121.2715178323 REDBANK WAY,SACRAMENTO,95829,CA,3,2,1789,Residential,Fri May 16 00:00:00 EDT 2008,243450,38.455753,-121.34927316 BRONCO CREEK CT,SACRAMENTO,95835,CA,4,2,1876,Residential,Fri May 16 00:00:00 EDT 2008,243500,38.674226,-121.5254978316 NORTHAM DR,ANTELOPE,95843,CA,3,2,1235,Residential,Fri May 16 00:00:00 EDT 2008,246544,38.720767,-121.3766784240 WINJE DR,ANTELOPE,95843,CA,4,2,2504,Residential,Fri May 16 00:00:00 EDT 2008,246750,38.70884,-121.3595593569 SODA WAY,SACRAMENTO,95834,CA,0,0,0,Residential,Fri May 16 00:00:00 EDT 2008,247000,38.631139,-121.5018795118 ROBANDER ST,CARMICHAEL,95608,CA,3,2,1676,Residential,Fri May 16 00:00:00 EDT 2008,247000,38.657267,-121.3103525976 KYLENCH CT,CITRUS HEIGHTS,95621,CA,3,2,1367,Residential,Fri May 16 00:00:00 EDT 2008,249000,38.708966,-121.324679247 DELAIR WAY,ELK GROVE,95758,CA,4,3,1899,Residential,Fri May 16 00:00:00 EDT 2008,249000,38.422241,-121.4580229054 DESCENDANT DR,ELK GROVE,95758,CA,3,2,1636,Residential,Fri May 16 00:00:00 EDT 2008,250000,38.428852,-121.4156283450 WHITNOR CT,SACRAMENTO,95821,CA,3,2,1828,Residential,Fri May 16 00:00:00 EDT 2008,250000,38.627698,-121.3696986288 LONETREE BLVD,ROCKLIN,95765,CA,0,0,0,Residential,Fri May 16 00:00:00 EDT 2008,250000,38.804993,-121.2936099355 MATADOR WAY,SACRAMENTO,95826,CA,4,2,1438,Residential,Fri May 16 00:00:00 EDT 2008,252000,38.555633,-121.3506918671 SUMMER SUN WAY,ELK GROVE,95624,CA,3,2,1451,Residential,Fri May 16 00:00:00 EDT 2008,255000,38.442845,-121.3732721890 GENEVA PL,SACRAMENTO,95825,CA,3,1,1520,Residential,Fri May 16 00:00:00 EDT 2008,255000,38.599449,-121.4003051813 AVENIDA MARTINA,ROSEVILLE,95747,CA,3,2,1506,Residential,Fri May 16 00:00:00 EDT 2008,255000,38.776649,-121.339589191 BARNHART CIR,SACRAMENTO,95835,CA,4,2,2605,Residential,Fri May 16 00:00:00 EDT 2008,257200,38.675594,-121.5158786221 GREEN TOP WAY,ORANGEVALE,95662,CA,3,2,1196,Residential,Fri May 16 00:00:00 EDT 2008,260000,38.679409,-121.2191072298 PRIMROSE LN,LINCOLN,95648,CA,3,2,1621,Residential,Fri May 16 00:00:00 EDT 2008,260000,38.89918,-121.3225145635 LOS PUEBLOS WAY,SACRAMENTO,95835,CA,3,2,1811,Residential,Fri May 16 00:00:00 EDT 2008,263500,38.679191,-121.53762210165 LOFTON WAY,ELK GROVE,95757,CA,3,2,1540,Residential,Fri May 16 00:00:00 EDT 2008,266510,38.387708,-121.4365221251 GREEN RAVINE DR,LINCOLN,95648,CA,4,2,0,Residential,Fri May 16 00:00:00 EDT 2008,267750,38.88156,-121.3013436001 SHOO FLY RD,PLACERVILLE,95667,CA,0,0,0,Residential,Fri May 16 00:00:00 EDT 2008,270000,38.813546,-120.8092543040 PARKHAM DR,ROSEVILLE,95747,CA,0,0,0,Residential,Fri May 16 00:00:00 EDT 2008,271000,38.770835,-121.3669962674 TAM O SHANTER DR,EL DORADO HILLS,95762,CA,4,2,0,Residential,Fri May 16 00:00:00 EDT 2008,272700,38.695801,-121.0792166007 MARYBELLE LN,SHINGLE SPRINGS,95682,CA,0,0,0,Unkown,Fri May 16 00:00:00 EDT 2008,275000,38.64347,-120.8881839949 NESTLING CIR,ELK GROVE,95757,CA,3,2,1543,Residential,Fri May 16 00:00:00 EDT 2008,275000,38.397455,-121.4683912915 HOLDREGE WAY,SACRAMENTO,95835,CA,5,3,2494,Residential,Fri May 16 00:00:00 EDT 2008,276000,38.663728,-121.5258332678 BRIARTON DR,LINCOLN,95648,CA,3,2,1650,Residential,Fri May 16 00:00:00 EDT 2008,276500,38.844116,-121.274806294 SPARROW DR,GALT,95632,CA,4,3,2214,Residential,Fri May 16 00:00:00 EDT 2008,278000,38.258976,-121.3212662987 DIORITE WAY,SACRAMENTO,95835,CA,5,3,2280,Residential,Fri May 16 00:00:00 EDT 2008,279000,38.667332,-121.5282766326 APPIAN WAY,CARMICHAEL,95608,CA,3,2,1443,Residential,Fri May 16 00:00:00 EDT 2008,280000,38.66266,-121.3168586905 COBALT WAY,CITRUS HEIGHTS,95621,CA,4,2,1582,Residential,Fri May 16 00:00:00 EDT 2008,280000,38.691393,-121.3052158986 HAFLINGER WAY,ELK GROVE,95757,CA,3,2,1857,Residential,Fri May 16 00:00:00 EDT 2008,285000,38.397923,-121.4502192916 BABSON DR,ELK GROVE,95758,CA,3,2,1735,Residential,Fri May 16 00:00:00 EDT 2008,288000,38.417191,-121.47389710133 NEBBIOLO CT,ELK GROVE,95624,CA,4,3,2096,Residential,Fri May 16 00:00:00 EDT 2008,289000,38.391085,-121.3472311103 COMMONS DR,SACRAMENTO,95825,CA,3,2,1720,Residential,Fri May 16 00:00:00 EDT 2008,290000,38.567865,-121.4106994636 TEAL BAY CT,ANTELOPE,95843,CA,4,2,2160,Residential,Fri May 16 00:00:00 EDT 2008,290000,38.704554,-121.3547531524 YOUNGS AVE,SACRAMENTO,95838,CA,4,2,1382,Residential,Fri May 16 00:00:00 EDT 2008,293996,38.644927,-121.43054865 CONRAD CT,PLACERVILLE,95667,CA,3,2,0,Residential,Fri May 16 00:00:00 EDT 2008,294000,38.729993,-120.8024588463 TERRACOTTA CT,ELK GROVE,95624,CA,4,2,1721,Residential,Fri May 16 00:00:00 EDT 2008,294173,38.450548,-121.3630025747 KING RD,LOOMIS,95650,CA,4,2,1328,Residential,Fri May 16 00:00:00 EDT 2008,295000,38.825096,-121.1984328253 KEEGAN WAY,ELK GROVE,95624,CA,0,0,0,Residential,Fri May 16 00:00:00 EDT 2008,298000,38.446286,-121.4008179204 TROUT WAY,ELK GROVE,95624,CA,4,2,1982,Residential,Fri May 16 00:00:00 EDT 2008,298000,38.422221,-121.3757991828 2ND AVE,SACRAMENTO,95818,CA,2,1,1144,Residential,Fri May 16 00:00:00 EDT 2008,299000,38.556844,-121.4907691113 COMMONS DR,SACRAMENTO,95825,CA,2,2,1623,Residential,Fri May 16 00:00:00 EDT 2008,300000,38.567795,-121.4107032341 BIG STRIKE TRL,COOL,95614,CA,3,2,1457,Residential,Fri May 16 00:00:00 EDT 2008,300000,38.905927,-120.9751699452 RED SPRUCE WAY,ELK GROVE,95624,CA,6,3,2555,Residential,Fri May 16 00:00:00 EDT 2008,300000,38.404505,-121.3469385776 TERRACE DR,ROCKLIN,95765,CA,3,2,1577,Residential,Fri May 16 00:00:00 EDT 2008,300567,38.800539,-121.2609795908 MCLEAN DR,ELK GROVE,95757,CA,5,3,2592,Residential,Fri May 16 00:00:00 EDT 2008,303000,38.38912,-121.4343898215 PEREGRINE WAY,CITRUS HEIGHTS,95610,CA,3,2,1401,Residential,Fri May 16 00:00:00 EDT 2008,305000,38.715493,-121.262931104 HILLSDALE LN,LINCOLN,95648,CA,4,2,0,Residential,Fri May 16 00:00:00 EDT 2008,306000,38.865017,-121.323022949 PANAMA AVE,CARMICHAEL,95608,CA,3,2,1502,Residential,Fri May 16 00:00:00 EDT 2008,310000,38.618369,-121.3261871356 HARTLEY WAY,FOLSOM,95630,CA,3,2,1327,Residential,Fri May 16 00:00:00 EDT 2008,310000,38.651617,-121.131674633 HANISCH DR,ROSEVILLE,95678,CA,4,3,1800,Residential,Fri May 16 00:00:00 EDT 2008,310000,38.76349,-121.27588163 ANGEL ISLAND CIR,SACRAMENTO,95831,CA,4,2,2169,Residential,Fri May 16 00:00:00 EDT 2008,311518,38.490408,-121.5476641571 WILD OAK LN,LINCOLN,95648,CA,5,3,2457,Residential,Fri May 16 00:00:00 EDT 2008,312000,38.844144,-121.2741745222 COPPER SUNSET WAY,RANCHO CORDOVA,95742,CA,0,0,0,Residential,Fri May 16 00:00:00 EDT 2008,313000,38.529181,-121.2247555601 SPINDRIFT LN,ORANGEVALE,95662,CA,4,2,2004,Residential,Fri May 16 00:00:00 EDT 2008,315000,38.668289,-121.192316652 FIFTEEN MILE DR,ROSEVILLE,95678,CA,4,3,2212,Residential,Fri May 16 00:00:00 EDT 2008,315000,38.775872,-121.2988647921 DOE TRAIL WAY,ANTELOPE,95843,CA,5,3,3134,Residential,Fri May 16 00:00:00 EDT 2008,315000,38.711927,-121.3436084204 LUSK DR,SACRAMENTO,95864,CA,3,2,1360,Residential,Fri May 16 00:00:00 EDT 2008,315000,38.606569,-121.3684245321 DELTA DR,ROCKLIN,95765,CA,4,2,0,Residential,Fri May 16 00:00:00 EDT 2008,315000,38.815493,-121.2629085608 ROSEDALE WAY,SACRAMENTO,95822,CA,3,2,1276,Residential,Fri May 16 00:00:00 EDT 2008,320000,38.525115,-121.5186893372 BERETANIA WAY,SACRAMENTO,95834,CA,4,3,2962,Residential,Fri May 16 00:00:00 EDT 2008,322000,38.64977,-121.534482422 STEFANIE DR,ROCKLIN,95765,CA,4,2,1888,Residential,Fri May 16 00:00:00 EDT 2008,325000,38.82273,-121.264243232 PARKHAM DR,ROSEVILLE,95747,CA,0,0,0,Residential,Fri May 16 00:00:00 EDT 2008,325500,38.772821,-121.364821448 ELMWOOD CT,ROSEVILLE,95678,CA,3,2,0,Residential,Fri May 16 00:00:00 EDT 2008,326951,38.771917,-121.3044391214 DAWNWOOD DR,GALT,95632,CA,3,2,1548,Residential,Fri May 16 00:00:00 EDT 2008,328370,38.290119,-121.2860231440 EMERALD LN,LINCOLN,95648,CA,2,2,0,Residential,Fri May 16 00:00:00 EDT 2008,330000,38.861864,-121.2674783349 CORVINA DR,RANCHO CORDOVA,95670,CA,4,3,2109,Residential,Fri May 16 00:00:00 EDT 2008,330000,38.580545,-121.27901610254 JULIANA WAY,SACRAMENTO,95827,CA,4,2,2484,Residential,Fri May 16 00:00:00 EDT 2008,331200,38.56803,-121.309966149 OPUS CIR,SACRAMENTO,95834,CA,4,3,2258,Residential,Fri May 16 00:00:00 EDT 2008,332000,38.6354,-121.53499580 REGENCY PARK CIR,SACRAMENTO,95835,CA,3,3,2212,Residential,Fri May 16 00:00:00 EDT 2008,334000,38.674864,-121.49585544 CAMAS CT,ORANGEVALE,95662,CA,3,2,1616,Residential,Fri May 16 00:00:00 EDT 2008,335000,38.667703,-121.2094565102 ARCHCREST WAY,SACRAMENTO,95835,CA,4,2,2372,Residential,Fri May 16 00:00:00 EDT 2008,341000,38.66841,-121.4946395725 BALFOR RD,ROCKLIN,95765,CA,5,3,2606,Residential,Fri May 16 00:00:00 EDT 2008,346375,38.807816,-121.2700087697 ROSEHALL DR,ROSEVILLE,95678,CA,5,3,0,Residential,Fri May 16 00:00:00 EDT 2008,347225,38.79218,-121.285954821 HUTSON WAY,ELK GROVE,95757,CA,5,3,2877,Residential,Fri May 16 00:00:00 EDT 2008,349000,38.386239,-121.4481594509 WINJE DR,ANTELOPE,95843,CA,3,2,2960,Residential,Fri May 16 00:00:00 EDT 2008,350000,38.709513,-121.3593571965 LAURELHURST LN,LINCOLN,95648,CA,2,2,0,Residential,Fri May 16 00:00:00 EDT 2008,350000,38.853869,-121.2717426709 ROSE BRIDGE DR,ROSEVILLE,95678,CA,3,2,2172,Residential,Fri May 16 00:00:00 EDT 2008,350000,38.792461,-121.275711281 SPYGLASS HL,ROSEVILLE,95678,CA,3,2,2100,Condo,Fri May 16 00:00:00 EDT 2008,350000,38.762153,-121.2834517709 RIVER VILLAGE DR,SACRAMENTO,95831,CA,3,2,1795,Residential,Fri May 16 00:00:00 EDT 2008,351000,38.483212,-121.540194165 BRISBANE CIR,EL DORADO HILLS,95762,CA,3,2,0,Residential,Fri May 16 00:00:00 EDT 2008,356200,38.686067,-121.073413506 BEDFORD CT,ROSEVILLE,95661,CA,4,2,2295,Residential,Fri May 16 00:00:00 EDT 2008,360000,38.733985,-121.2367669048 PINTO CANYON WAY,ROSEVILLE,95747,CA,4,3,2577,Residential,Fri May 16 00:00:00 EDT 2008,367463,38.792493,-121.3318992274 IVY BRIDGE DR,ROSEVILLE,95747,CA,0,0,0,Residential,Fri May 16 00:00:00 EDT 2008,375000,38.778561,-121.36200814004 WALNUT AVE,WALNUT GROVE,95690,CA,3,1,1727,Residential,Fri May 16 00:00:00 EDT 2008,380000,38.247659,-121.5151296905 FRANKFORT CT,ELK GROVE,95758,CA,3,2,1485,Residential,Fri May 16 00:00:00 EDT 2008,380578,38.429139,-121.4234443621 WINTUN DR,CARMICHAEL,95608,CA,3,2,1655,Residential,Fri May 16 00:00:00 EDT 2008,386222,38.629929,-121.323086201 KIRKLAND CT,LINCOLN,95648,CA,0,0,0,Residential,Fri May 16 00:00:00 EDT 2008,389000,38.867125,-121.31908512075 APPLESBURY CT,RANCHO CORDOVA,95742,CA,0,0,0,Residential,Fri May 16 00:00:00 EDT 2008,390000,38.5357,-121.22491975 SIDESADDLE WAY,ROSEVILLE,95661,CA,3,2,2049,Residential,Fri May 16 00:00:00 EDT 2008,395500,38.737872,-121.2490255420 ALMOND FALLS WAY,RANCHO CORDOVA,95742,CA,0,0,0,Residential,Fri May 16 00:00:00 EDT 2008,396000,38.527384,-121.2335319677 PILLITERI CT,ELK GROVE,95757,CA,5,3,2875,Residential,Fri May 16 00:00:00 EDT 2008,397000,38.405571,-121.4451861515 EL CAMINO VERDE DR,LINCOLN,95648,CA,0,0,0,Residential,Fri May 16 00:00:00 EDT 2008,400000,38.904869,-121.32075556 PLATT CIR,EL DORADO HILLS,95762,CA,4,2,2199,Residential,Fri May 16 00:00:00 EDT 2008,400000,38.656299,-121.0797831792 DIAMOND WOODS CIR,ROSEVILLE,95747,CA,4,3,0,Residential,Fri May 16 00:00:00 EDT 2008,412500,38.808581,-121.327851124 PERKINS WAY,SACRAMENTO,95818,CA,2,1,1304,Residential,Fri May 16 00:00:00 EDT 2008,413500,38.551611,-121.5044374748 SALEM WAY,CARMICHAEL,95608,CA,3,2,2334,Residential,Fri May 16 00:00:00 EDT 2008,415000,38.634111,-121.3533761484 RADCLIFFE WAY,AUBURN,95603,CA,4,3,2278,Residential,Fri May 16 00:00:00 EDT 2008,420454,38.935579,-121.07901851 AIKEN WAY,SACRAMENTO,95819,CA,3,1,1493,Residential,Fri May 16 00:00:00 EDT 2008,425000,38.579326,-121.442522818 KNOLLWOOD DR,CAMERON PARK,95682,CA,3,2,0,Residential,Fri May 16 00:00:00 EDT 2008,425000,38.669805,-120.9990071536 STONEY CROSS LN,LINCOLN,95648,CA,0,0,0,Residential,Fri May 16 00:00:00 EDT 2008,433500,38.860007,-121.310946509 CASTILLIAN CT,ROSEVILLE,95747,CA,5,3,0,Residential,Fri May 16 00:00:00 EDT 2008,438000,38.804773,-121.341195700 HUNTER PL,FOLSOM,95630,CA,5,3,2787,Residential,Fri May 16 00:00:00 EDT 2008,441000,38.66051,-121.1636891240 FAY CIR,SACRAMENTO,95831,CA,5,3,2824,Residential,Fri May 16 00:00:00 EDT 2008,445000,38.506371,-121.5144561113 SANDWICK WAY,FOLSOM,95630,CA,4,3,3261,Residential,Fri May 16 00:00:00 EDT 2008,446000,38.673882,-121.1050773108 DELWOOD WAY,SACRAMENTO,95821,CA,4,2,2053,Residential,Fri May 16 00:00:00 EDT 2008,450000,38.621566,-121.3708823212 CORNICHE LN,ROSEVILLE,95661,CA,4,3,2379,Residential,Fri May 16 00:00:00 EDT 2008,455000,38.750577,-121.2327682159 BECKETT DR,EL DORADO HILLS,95762,CA,3,2,0,Residential,Fri May 16 00:00:00 EDT 2008,460000,38.680092,-121.0364674320 FOUR SEASONS RD,PLACERVILLE,95667,CA,3,2,0,Residential,Fri May 16 00:00:00 EDT 2008,475000,38.690867,-120.6936416401 MARSHALL RD,GARDEN VALLEY,95633,CA,3,2,0,Residential,Fri May 16 00:00:00 EDT 2008,490000,38.84255,-120.87542089 BECKETT DR,EL DORADO HILLS,95762,CA,4,2,0,Residential,Fri May 16 00:00:00 EDT 2008,493000,38.681778,-121.0358386196 EDGEHILL DR,EL DORADO HILLS,95762,CA,5,4,0,Residential,Fri May 16 00:00:00 EDT 2008,508000,38.676131,-121.038931200 HILLSFORD CT,ROSEVILLE,95747,CA,0,0,0,Residential,Fri May 16 00:00:00 EDT 2008,511000,38.780051,-121.3787188217 PLUMERIA AVE,FAIR OAKS,95628,CA,3,2,3173,Residential,Fri May 16 00:00:00 EDT 2008,525000,38.650735,-121.2586284841 VILLAGE GREEN DR,EL DORADO HILLS,95762,CA,4,3,0,Residential,Fri May 16 00:00:00 EDT 2008,533000,38.664066,-121.0567353863 LAS PASAS WAY,SACRAMENTO,95864,CA,3,1,1348,Residential,Fri May 16 00:00:00 EDT 2008,545000,38.588936,-121.373606820 DANA CT,AUBURN,95603,CA,4,3,0,Residential,Fri May 16 00:00:00 EDT 2008,560000,38.865246,-121.0948691165 37TH ST,SACRAMENTO,95816,CA,2,1,1252,Residential,Fri May 16 00:00:00 EDT 2008,575000,38.568438,-121.457854203 CASCADE FALLS DR,FOLSOM,95630,CA,4,3,3229,Residential,Fri May 16 00:00:00 EDT 2008,575000,38.703962,-121.18719880 IZILDA CT,SACRAMENTO,95829,CA,5,4,3863,Residential,Fri May 16 00:00:00 EDT 2008,598695,38.45326,-121.325731800 AVONDALE DR,ROSEVILLE,95747,CA,5,3,0,Residential,Fri May 16 00:00:00 EDT 2008,600000,38.798448,-121.3440544620 BROMWICH CT,ROCKLIN,95677,CA,4,3,0,Residential,Fri May 16 00:00:00 EDT 2008,600000,38.772672,-121.220232620 KESWICK CT,GRANITE BAY,95746,CA,4,3,2356,Residential,Fri May 16 00:00:00 EDT 2008,600000,38.732096,-121.2191424478 GREENBRAE RD,ROCKLIN,95677,CA,0,0,0,Residential,Fri May 16 00:00:00 EDT 2008,600000,38.781134,-121.2228018432 BRIGGS DR,ROSEVILLE,95747,CA,5,3,3579,Residential,Fri May 16 00:00:00 EDT 2008,610000,38.78861,-121.339495200 CRADLE MOUNTAIN CT,EL DORADO HILLS,95762,CA,0,0,0,Residential,Fri May 16 00:00:00 EDT 2008,622500,38.6478,-121.03092065 IMPRESSIONIST WAY,EL DORADO HILLS,95762,CA,0,0,0,Residential,Fri May 16 00:00:00 EDT 2008,680000,38.682961,-121.0332532982 ABERDEEN LN,EL DORADO HILLS,95762,CA,4,3,0,Residential,Fri May 16 00:00:00 EDT 2008,879000,38.706692,-121.0588699401 BARREL RACER CT,WILTON,95693,CA,4,3,4400,Residential,Fri May 16 00:00:00 EDT 2008,884790,38.415298,-121.1948583720 VISTA DE MADERA,LINCOLN,95648,CA,3,3,0,Residential,Fri May 16 00:00:00 EDT 2008,1551,38.851645,-121.23174214151 INDIO DR,SLOUGHHOUSE,95683,CA,3,4,5822,Residential,Fri May 16 00:00:00 EDT 2008,2000,38.490447,-121.1293377401 TOULON LN,SACRAMENTO,95828,CA,4,2,1512,Residential,Thu May 15 00:00:00 EDT 2008,56950,38.488628,-121.3877599127 NEWHALL DR Unit 34,SACRAMENTO,95826,CA,1,1,611,Condo,Thu May 15 00:00:00 EDT 2008,60000,38.542419,-121.3599045937 BAMFORD DR,SACRAMENTO,95823,CA,2,1,876,Residential,Thu May 15 00:00:00 EDT 2008,61000,38.471139,-121.4322555672 HILLSDALE BLVD,SACRAMENTO,95842,CA,2,1,933,Condo,Thu May 15 00:00:00 EDT 2008,62000,38.670467,-121.3597993920 39TH ST,SACRAMENTO,95820,CA,2,1,864,Residential,Thu May 15 00:00:00 EDT 2008,68566,38.539213,-121.46393701 JESSIE AVE,SACRAMENTO,95838,CA,2,1,1011,Residential,Thu May 15 00:00:00 EDT 2008,70000,38.643978,-121.44956283 ARCADE BLVD,SACRAMENTO,95815,CA,4,2,1158,Residential,Thu May 15 00:00:00 EDT 2008,80000,38.618716,-121.466327601 REGGINALD WAY,SACRAMENTO,95838,CA,3,2,1092,Residential,Thu May 15 00:00:00 EDT 2008,85500,38.64472,-121.452228550 DEL VERDE CIR,SACRAMENTO,95833,CA,2,1,956,Condo,Thu May 15 00:00:00 EDT 2008,92000,38.627147,-121.5007994113 DAYSTAR CT,SACRAMENTO,95824,CA,2,2,1139,Residential,Thu May 15 00:00:00 EDT 2008,93600,38.520469,-121.4586067374 TISDALE WAY,SACRAMENTO,95822,CA,3,1,1058,Residential,Thu May 15 00:00:00 EDT 2008,95000,38.488238,-121.4725613348 RIO LINDA BLVD,SACRAMENTO,95838,CA,3,2,1040,Residential,Thu May 15 00:00:00 EDT 2008,97750,38.628842,-121.4461273935 LIMESTONE WAY,SACRAMENTO,95823,CA,3,2,1354,Residential,Thu May 15 00:00:00 EDT 2008,104000,38.484374,-121.4631576208 GRATTAN WAY,NORTH HIGHLANDS,95660,CA,3,1,1051,Residential,Thu May 15 00:00:00 EDT 2008,105000,38.679279,-121.376615739 E WOODSIDE LN Unit E,SACRAMENTO,95825,CA,1,1,682,Condo,Thu May 15 00:00:00 EDT 2008,107666,38.578675,-121.4099514225 46TH AVE,SACRAMENTO,95824,CA,3,1,1161,Residential,Thu May 15 00:00:00 EDT 2008,109000,38.511893,-121.4576761434 BELL AVE,SACRAMENTO,95838,CA,3,1,1004,Residential,Thu May 15 00:00:00 EDT 2008,110000,38.647398,-121.4329145628 GEORGIA DR,NORTH HIGHLANDS,95660,CA,3,1,1229,Residential,Thu May 15 00:00:00 EDT 2008,110000,38.669587,-121.3798797629 BETH ST,SACRAMENTO,95832,CA,3,2,1249,Residential,Thu May 15 00:00:00 EDT 2008,112500,38.480126,-121.4878692277 BABETTE WAY,SACRAMENTO,95832,CA,3,2,1161,Residential,Thu May 15 00:00:00 EDT 2008,114800,38.479593,-121.484346561 WEATHERFORD WAY,SACRAMENTO,95823,CA,3,1,1010,Residential,Thu May 15 00:00:00 EDT 2008,116000,38.465551,-121.426613035 ESTEPA DR Unit 5C,CAMERON PARK,95682,CA,0,0,0,Condo,Thu May 15 00:00:00 EDT 2008,119000,38.681393,-120.9967135136 CABOT CIR,SACRAMENTO,95820,CA,4,2,1462,Residential,Thu May 15 00:00:00 EDT 2008,121500,38.528479,-121.4118067730 ROBINETTE RD,SACRAMENTO,95828,CA,3,2,1269,Residential,Thu May 15 00:00:00 EDT 2008,122000,38.47709,-121.41056987 LACAM CIR,SACRAMENTO,95820,CA,2,2,1188,Residential,Thu May 15 00:00:00 EDT 2008,123675,38.532359,-121.411671691 NOGALES ST,SACRAMENTO,95838,CA,4,2,1570,Residential,Thu May 15 00:00:00 EDT 2008,126854,38.631925,-121.4277753118 42ND ST,SACRAMENTO,95817,CA,3,2,1093,Residential,Thu May 15 00:00:00 EDT 2008,127059,38.546091,-121.4577457517 50TH AVE,SACRAMENTO,95828,CA,3,1,962,Residential,Thu May 15 00:00:00 EDT 2008,128687,38.507339,-121.4162674071 EVALITA WAY,SACRAMENTO,95823,CA,3,2,1089,Residential,Thu May 15 00:00:00 EDT 2008,129500,38.466388,-121.4588617928 36TH AVE,SACRAMENTO,95824,CA,3,2,1127,Residential,Thu May 15 00:00:00 EDT 2008,130000,38.52049,-121.4113836631 DEMARET DR,SACRAMENTO,95822,CA,4,2,1309,Residential,Thu May 15 00:00:00 EDT 2008,131750,38.506382,-121.4835747043 9TH AVE,RIO LINDA,95673,CA,2,1,970,Residential,Thu May 15 00:00:00 EDT 2008,132000,38.695589,-121.44413397 KENNELFORD CIR,SACRAMENTO,95823,CA,3,2,1144,Residential,Thu May 15 00:00:00 EDT 2008,134000,38.462376,-121.4265562636 TRONERO WAY,RANCHO CORDOVA,95670,CA,3,1,1000,Residential,Thu May 15 00:00:00 EDT 2008,134000,38.593049,-121.303041530 TOPANGA LN Unit 204,LINCOLN,95648,CA,0,0,0,Condo,Thu May 15 00:00:00 EDT 2008,138000,38.88415,-121.2702773604 KODIAK WAY,ANTELOPE,95843,CA,3,2,1206,Residential,Thu May 15 00:00:00 EDT 2008,142000,38.706175,-121.3797762149 COTTAGE WAY,SACRAMENTO,95825,CA,3,1,1285,Residential,Thu May 15 00:00:00 EDT 2008,143012,38.603593,-121.4170118632 PRAIRIEWOODS DR,SACRAMENTO,95828,CA,3,2,1543,Residential,Thu May 15 00:00:00 EDT 2008,145846,38.477563,-121.384382612 STONE BLVD,WEST SACRAMENTO,95691,CA,2,1,884,Residential,Thu May 15 00:00:00 EDT 2008,147000,38.563084,-121.5355794180 12TH AVE,SACRAMENTO,95817,CA,3,1,1019,Residential,Thu May 15 00:00:00 EDT 2008,148750,38.54117,-121.4581298025 ARROYO VISTA DR,SACRAMENTO,95823,CA,4,2,1392,Residential,Thu May 15 00:00:00 EDT 2008,150000,38.46654,-121.4190295754 WALERGA RD Unit 4,SACRAMENTO,95842,CA,2,1,924,Condo,Thu May 15 00:00:00 EDT 2008,150454,38.672567,-121.3567548 LA ROCAS CT,SACRAMENTO,95823,CA,3,2,1217,Residential,Thu May 15 00:00:00 EDT 2008,151087,38.46616,-121.4482838636 LONGSPUR WAY,ANTELOPE,95843,CA,3,2,1670,Residential,Thu May 15 00:00:00 EDT 2008,157296,38.725873,-121.358561941 EXPEDITION WAY,SACRAMENTO,95832,CA,3,2,1302,Residential,Thu May 15 00:00:00 EDT 2008,157500,38.473775,-121.4937774351 TURNBRIDGE DR,SACRAMENTO,95823,CA,3,2,1488,Residential,Thu May 15 00:00:00 EDT 2008,160000,38.502034,-121.4560276513 HOLIDAY WAY,NORTH HIGHLANDS,95660,CA,3,2,1373,Residential,Thu May 15 00:00:00 EDT 2008,160000,38.685361,-121.3769388321 MISTLETOE WAY,CITRUS HEIGHTS,95621,CA,4,2,1381,Residential,Thu May 15 00:00:00 EDT 2008,161250,38.717738,-121.3083225920 VALLEY GLEN WAY,SACRAMENTO,95823,CA,3,2,1265,Residential,Thu May 15 00:00:00 EDT 2008,164000,38.462821,-121.4331352601 SAN FERNANDO WAY,SACRAMENTO,95818,CA,2,1,881,Residential,Thu May 15 00:00:00 EDT 2008,165000,38.556178,-121.476256501 POPLAR AVE,WEST SACRAMENTO,95691,CA,0,0,0,Residential,Thu May 15 00:00:00 EDT 2008,165000,38.584526,-121.5346098008 SAINT HELENA CT,SACRAMENTO,95829,CA,4,2,1608,Residential,Thu May 15 00:00:00 EDT 2008,165750,38.467012,-121.3599696517 DONEGAL DR,CITRUS HEIGHTS,95621,CA,3,1,1344,Residential,Thu May 15 00:00:00 EDT 2008,166000,38.681554,-121.3129341001 RIO NORTE WAY,SACRAMENTO,95834,CA,3,2,1202,Residential,Thu May 15 00:00:00 EDT 2008,169000,38.634292,-121.485106604 P ST,LINCOLN,95648,CA,3,2,1104,Residential,Thu May 15 00:00:00 EDT 2008,170000,38.893168,-121.30539810001 WOODCREEK OAKS BLVD Unit 815,ROSEVILLE,95747,CA,2,2,0,Condo,Thu May 15 00:00:00 EDT 2008,170000,38.795529,-121.3288197351 GIGI PL,SACRAMENTO,95828,CA,4,2,1859,Multi-Family,Thu May 15 00:00:00 EDT 2008,170000,38.490606,-121.4101737740 DIXIE LOU ST,SACRAMENTO,95832,CA,3,2,1232,Residential,Thu May 15 00:00:00 EDT 2008,170000,38.475853,-121.4770397342 DAVE ST,SACRAMENTO,95828,CA,3,1,1638,Residential,Thu May 15 00:00:00 EDT 2008,170725,38.490822,-121.4016437687 HOWERTON DR,SACRAMENTO,95831,CA,2,2,1177,Residential,Thu May 15 00:00:00 EDT 2008,171750,38.480859,-121.53974526 KAMSON CT,SACRAMENTO,95833,CA,3,2,1582,Residential,Thu May 15 00:00:00 EDT 2008,172000,38.622794,-121.4991737045 PEEVEY CT,SACRAMENTO,95823,CA,2,2,904,Residential,Thu May 15 00:00:00 EDT 2008,173056,38.502254,-121.4514448916 GABLES MILL PL,ELK GROVE,95758,CA,3,2,1340,Residential,Thu May 15 00:00:00 EDT 2008,174000,38.433919,-121.4223471140 EDMONTON DR,SACRAMENTO,95833,CA,3,2,1204,Residential,Thu May 15 00:00:00 EDT 2008,174250,38.62457,-121.4869138879 APPLE PEAR CT,ELK GROVE,95624,CA,4,2,1477,Residential,Thu May 15 00:00:00 EDT 2008,176850,38.44574,-121.37259 WIND CT,SACRAMENTO,95823,CA,4,2,1497,Residential,Thu May 15 00:00:00 EDT 2008,179500,38.45073,-121.4275288570 SHERATON DR,FAIR OAKS,95628,CA,3,1,960,Residential,Thu May 15 00:00:00 EDT 2008,185000,38.667254,-121.2407081550 TOPANGA LN Unit 207,LINCOLN,95648,CA,0,0,0,Condo,Thu May 15 00:00:00 EDT 2008,188000,38.88417,-121.2702221080 RIO NORTE WAY,SACRAMENTO,95834,CA,3,2,1428,Residential,Thu May 15 00:00:00 EDT 2008,188700,38.634335,-121.4860985501 VALLETTA WAY,SACRAMENTO,95820,CA,3,1,1039,Residential,Thu May 15 00:00:00 EDT 2008,189000,38.530144,-121.437495624 MEMORY LN,FAIR OAKS,95628,CA,3,1,1529,Residential,Thu May 15 00:00:00 EDT 2008,189000,38.66745,-121.23646622 WILLOWLEAF DR,CITRUS HEIGHTS,95621,CA,4,3,1892,Residential,Thu May 15 00:00:00 EDT 2008,189836,38.699714,-121.31163527 MEGAN CT,SACRAMENTO,95838,CA,4,2,1887,Residential,Thu May 15 00:00:00 EDT 2008,190000,38.649258,-121.4653086601 WOODMORE OAKS DR,ORANGEVALE,95662,CA,3,2,1294,Residential,Thu May 15 00:00:00 EDT 2008,191250,38.687006,-121.2543191973 DANVERS WAY,SACRAMENTO,95832,CA,3,2,1638,Residential,Thu May 15 00:00:00 EDT 2008,191675,38.477568,-121.4925748001 ARROYO VISTA DR,SACRAMENTO,95823,CA,3,2,1677,Residential,Thu May 15 00:00:00 EDT 2008,195500,38.46734,-121.4198437409 VOYAGER WAY,CITRUS HEIGHTS,95621,CA,3,1,1073,Residential,Thu May 15 00:00:00 EDT 2008,198000,38.700717,-121.3133815 CROSSWIND DR,SACRAMENTO,95838,CA,3,2,1231,Residential,Thu May 15 00:00:00 EDT 2008,200000,38.651386,-121.450425509 LAGUNA CREST WAY,ELK GROVE,95758,CA,3,2,1175,Residential,Thu May 15 00:00:00 EDT 2008,200000,38.42442,-121.4403578424 MERRY HILL WAY,ELK GROVE,95624,CA,3,2,1416,Residential,Thu May 15 00:00:00 EDT 2008,200000,38.452075,-121.3664611525 PENNSYLVANIA AVE,WEST SACRAMENTO,95691,CA,0,0,0,Residential,Thu May 15 00:00:00 EDT 2008,200100,38.569943,-121.5275395954 BRIDGECROSS DR,SACRAMENTO,95835,CA,3,2,1358,Residential,Thu May 15 00:00:00 EDT 2008,201528,38.68197,-121.5000258789 SEQUOIA WOOD CT,ELK GROVE,95624,CA,4,2,1609,Residential,Thu May 15 00:00:00 EDT 2008,204750,38.438818,-121.374436600 SILVERTHORNE CIR,SACRAMENTO,95842,CA,4,3,1968,Residential,Thu May 15 00:00:00 EDT 2008,205000,38.68607,-121.3423692221 2ND AVE,SACRAMENTO,95818,CA,2,2,1089,Residential,Thu May 15 00:00:00 EDT 2008,205000,38.555781,-121.4853313230 SMATHERS WAY,CARMICHAEL,95608,CA,3,2,1296,Residential,Thu May 15 00:00:00 EDT 2008,205900,38.623372,-121.3476655209 LAGUNA CREST WAY,ELK GROVE,95758,CA,2,2,1189,Residential,Thu May 15 00:00:00 EDT 2008,207000,38.424421,-121.443915416 LEITCH AVE,SACRAMENTO,95815,CA,2,1,795,Residential,Thu May 15 00:00:00 EDT 2008,207973,38.612694,-121.4566692100 BEATTY WAY,ROSEVILLE,95747,CA,3,2,1371,Residential,Thu May 15 00:00:00 EDT 2008,208250,38.737882,-121.3081426920 GILLINGHAM WAY,NORTH HIGHLANDS,95660,CA,3,1,1310,Residential,Thu May 15 00:00:00 EDT 2008,208318,38.694279,-121.37339582 WILDFLOWER DR,GALT,95632,CA,3,2,1262,Residential,Thu May 15 00:00:00 EDT 2008,209347,38.259708,-121.3116168652 BANTON CIR,ELK GROVE,95624,CA,4,2,1740,Residential,Thu May 15 00:00:00 EDT 2008,211500,38.444,-121.3709938428 MISTY PASS WAY,ANTELOPE,95843,CA,3,2,1517,Residential,Thu May 15 00:00:00 EDT 2008,212000,38.722959,-121.3471157958 ROSEVIEW WAY,SACRAMENTO,95828,CA,3,2,1450,Residential,Thu May 15 00:00:00 EDT 2008,213000,38.467836,-121.4103669020 LUKEN CT,ELK GROVE,95624,CA,3,2,1416,Residential,Thu May 15 00:00:00 EDT 2008,216000,38.451398,-121.3666147809 VALLECITOS WAY,SACRAMENTO,95828,CA,3,1,888,Residential,Thu May 15 00:00:00 EDT 2008,216021,38.508217,-121.4112078445 OLD AUBURN RD,CITRUS HEIGHTS,95610,CA,3,2,1882,Residential,Thu May 15 00:00:00 EDT 2008,219000,38.715423,-121.24674310085 ATKINS DR,ELK GROVE,95757,CA,3,2,1302,Residential,Thu May 15 00:00:00 EDT 2008,219794,38.390893,-121.4378219185 CERROLINDA CIR,ELK GROVE,95758,CA,3,2,1418,Residential,Thu May 15 00:00:00 EDT 2008,220000,38.424497,-121.4265959197 CORTINA CIR,ROSEVILLE,95678,CA,3,2,0,Condo,Thu May 15 00:00:00 EDT 2008,220000,38.793152,-121.2900255429 HESPER WAY,CARMICHAEL,95608,CA,4,2,1319,Residential,Thu May 15 00:00:00 EDT 2008,220000,38.665104,-121.3159011178 WARMWOOD CT,GALT,95632,CA,4,2,1770,Residential,Thu May 15 00:00:00 EDT 2008,220000,38.289544,-121.2846074900 ELUDE CT,SACRAMENTO,95842,CA,4,2,1627,Residential,Thu May 15 00:00:00 EDT 2008,223000,38.69674,-121.3505193557 SODA WAY,SACRAMENTO,95834,CA,0,0,0,Residential,Thu May 15 00:00:00 EDT 2008,224000,38.631026,-121.5018793528 SAINT GEORGE DR,SACRAMENTO,95821,CA,3,1,1040,Residential,Thu May 15 00:00:00 EDT 2008,224000,38.629468,-121.3764457381 WASHBURN WAY,NORTH HIGHLANDS,95660,CA,3,1,960,Residential,Thu May 15 00:00:00 EDT 2008,224252,38.70355,-121.3751032181 WINTERHAVEN CIR,CAMERON PARK,95682,CA,3,2,0,Residential,Thu May 15 00:00:00 EDT 2008,224500,38.69757,-120.9957397540 HICKORY AVE,ORANGEVALE,95662,CA,3,1,1456,Residential,Thu May 15 00:00:00 EDT 2008,225000,38.703056,-121.2352215024 CHAMBERLIN CIR,ELK GROVE,95757,CA,3,2,1450,Residential,Thu May 15 00:00:00 EDT 2008,228000,38.389756,-121.4462462400 INVERNESS DR,LINCOLN,95648,CA,3,2,1358,Residential,Thu May 15 00:00:00 EDT 2008,229027,38.897814,-121.3246915 BISHOPGATE CT,SACRAMENTO,95823,CA,4,2,1329,Residential,Thu May 15 00:00:00 EDT 2008,229500,38.467936,-121.4454775601 REXLEIGH DR,SACRAMENTO,95823,CA,4,2,1715,Residential,Thu May 15 00:00:00 EDT 2008,230000,38.445342,-121.4415041909 YARNELL WAY,ELK GROVE,95758,CA,3,2,1262,Residential,Thu May 15 00:00:00 EDT 2008,230000,38.417382,-121.4843259169 GARLINGTON CT,SACRAMENTO,95829,CA,4,3,2280,Residential,Thu May 15 00:00:00 EDT 2008,232425,38.457679,-121.359626932 RUSKUT WAY,SACRAMENTO,95823,CA,3,2,1477,Residential,Thu May 15 00:00:00 EDT 2008,234000,38.499893,-121.458897933 DAFFODIL WAY,CITRUS HEIGHTS,95610,CA,3,2,1216,Residential,Thu May 15 00:00:00 EDT 2008,235000,38.708824,-121.2568038304 RED FOX WAY,ELK GROVE,95758,CA,4,2,1685,Residential,Thu May 15 00:00:00 EDT 2008,235301,38.417,-121.3974243882 YELLOWSTONE LN,EL DORADO HILLS,95762,CA,3,2,1362,Residential,Thu May 15 00:00:00 EDT 2008,235738,38.655245,-121.075915"; }, - thumbnail_uri: function () { return null; } - } - - , - "fig1.svg": { - name: "fig1.svg", - filename: "fig1.svg", - path: "fig1.svg", - size: "28.3 kB", - mime_type: "image/svg+xml", - caption: "

This is a caption with a link.

\n", - job_properties: { - rule: "a", - wildcards: "", - params: "" - }, - data_uri: function () { return "data:image/svg+xml;charset=utf8;filename=fig1.svg;base64,<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" width="800px" height="600px" viewBox="0 0 800 600" enable-background="new 0 0 800 600" xml:space="preserve">  <image id="image0" width="800" height="600" x="0" y="0"
    xlink:href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAyAAAAJYCAYAAACadoJwAAAABGdBTUEAALGPC/xhBQAAACBjSFJN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" />
</svg>
"; }, - thumbnail_uri: function () { return null; } - } - - , - "testmodel.fig2.png": { - name: "testmodel.fig2.png", - filename: "testmodel.fig2.png", - path: "testmodel.fig2.png", - size: "9.1 kB", - mime_type: "image/png", - caption: "

Some math \u2211ii2.

\n", - job_properties: { - rule: "b", - wildcards: "model=testmodel", - params: "" - }, - data_uri: function () { return "data:image/png;charset=utf8;filename=testmodel.fig2.png;base64,iVBORw0KGgoAAAANSUhEUgAAAyAAAAJYCAYAAACadoJwAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAIABJREFUeJzt3W2QlfV5wOF7t+sLgQJmWQobRiSLkmSLQyBC2BiDpo1vRRsDbLdDEkgaZ1LFYtLgtHHwgzFjNm2kljTENNlgQ2lHDKl22ial0YaZrCBsmrYSBAkvRRZZrShKUMHTDw6kG15kdzn3A3uua4aZ8JzzOPf+547y45yzW1UqlUoBAACQoLroAQAAgMohQAAAgDQCBAAASCNAAACANAIEAABII0AAAIA0AgQAAEgjQAAAgDQCBAAASCNAAACANAIEAABII0AAAIA0AgQAAEgjQAAAgDQCBAAASCNAAACANAIEAABII0AAAIA0AgQAAEgjQAAAgDQCBAAASCNAAACANAIEAABII0AAAIA0AgQAAEgjQAAAgDQCBAAASCNAAACANAIEAABII0AAAIA0AgQAAEgjQAAAgDQCBAAASCNAAACANAIEAABII0AAAIA0AgQAAEgjQAAAgDQCBAAASCNAAACANAIEAABII0AAAIA0AgQAAEgjQAAAgDQCBAAASCNAAACANAIEAABII0AAAIA0AgQAAEgjQAAAgDQCBAAASCNAyqyjoyOuu+66qK2tjYEDB8b48ePjL//yL4seCwAAClFT9AD92Q9+8IOYPn16TJo0KRYuXBiDBg2Kp556Kp5++umiRwMAgEJUlUqlUtFD9EcvvvhiXHTRRXHppZfGihUrih4HAABOC96CVSZ/+7d/G3v27Im77rorIiJefvnleP311wueCgAAiiVAymTVqlUxePDg+J//+Z8YN25c/Pqv/3oMGTIk/vAP/zBeeeWVoscDAIBCCJAy2bx5cxw8eDB+93d/N66++ur47ne/G5/4xCdiyZIlMXfu3KLHAwCAQvgMSJk0NDTE1q1b49Of/nR89atfPXL905/+dHz961+PTZs2xdixYwucEAAA8vkuWGUyYMCAiIhoaWnpdr2lpSW+/vWvx2OPPXbMAOns7IzOzs6UGQEA6LmRI0fGyJEjix7jjCVAyqS+vj42bNgQv/Ebv9Ht+vDhwyMi4vnnnz/qns7OznjPe94Tu3btSpkRAICeq6+vj3Xr1omQXhIgZfKe97wnVq1aFTt37owLL7zwyPXDcVFXV3fUPZ2dnbFr1674zne+E+985zvTZu0P5s+fH4sWLSp6jDOKM+sd59Zzzqx3nNubmzFjRmzduvW4j48ZM8a3wj8Jdq1nfvazn8Xs2bOjs7NTgPSSACmTWbNmxd133x3f/OY34/LLLz9y/a//+q/jrLPOimnTph333ne+850xceLEhCn7j6FDhzqzHnJmvePces6Z9Y5ze3Mf+MAHThggH/jAB5zhSbBrZBMgZTJhwoT4xCc+Ed/61rfi4MGDcdlll8Wjjz4aK1asiD/90z+NESNGFD0iAJzRWltbY/Xq1bFly5ajHmtoaIjW1tYCpgLejAApoyVLlsT5558fbW1tsXLlyrjgggti0aJFccsttxQ9GgCc8erq6qK9vT0WLFgQa9euje3bt8fo0aNj8uTJ0draesy3OwPFEyBlVFNTEwsXLoyFCxcWPQoA9Et1dXXR1tYWERHXXXddPPTQQwVPBLwZP4iQfuFXv90xb86Z9Y5z6zln1jvOreecWe84N7L5QYSnkY6Ojpg0aVKsX7/eh8EAAE5D/rzWd14BAQAA0ggQAAAgjQABAADSCBAAACCNAAEAANIIEAAAII0AAQAA0ggQAAAgjQABAADSCBAAACCNAAEAANIIEAAAII0AAQAA0ggQAAAgjQABAADSCBAAACCNAAEAANIIEAAAII0AAQAA0ggQAAAgjQABAADSCBAAACCNAAEAANIIEAAAII0AAQAA0ggQAAAgjQABAADSCBAAACCNAAEAANIIEAAAII0AAQAA0ggQAAAgjQABAADSCBAAACCNAAEAANIIEAAAII0AAQAA0ggQAAAgjQABAADSCBAAACCNAAEAANIIEAAAII0AAQAA0ggQAAAgjQABAADSCBAAACCNAAEAANIIEAAAII0AAQAA0ggQAAAgjQABAADSCBAAACCNAAEAANIIEAAAII0AAQAA0ggQAAAgjQABAADSCBAAACCNAAEAANIIEAAAII0AAQAA0ggQAAAgjQABAADSCBAAACCNAAEAANIIEAAAII0AAQAA0ggQAAAgjQABAADSCBAAACCNAAEAANIIEAAAII0AAQAA0ggQAAAgjQABAADSCBAAACCNAAEAANIIEAAAII0AAQAA0ggQAAAgjQApo0cffTSqq6uP+Wvt2rVFjwcAAOlqih6gEvzRH/1RXHLJJd2uNTQ0FDQNAAAUR4AkeP/73x833HBD0WMAAEDhvAUrQalUin379sXBgweLHgUAAAolQBLMnTs3hgwZEgMGDIgrrrgi1q9fX/RIAABQCG/BKqNzzjknZsyYEddcc00MGzYsnnjiifizP/uzeP/73x8//vGPY8KECUWPCAAAqQRIGU2dOjWmTp165Pe/8zu/EzNmzIiLL744/uRP/iT++Z//ucDpAAAgn7dgJWtoaIjrr78+HnnkkSiVSkWPAwAAqbwCUoBRo0bFq6++Gi+//HIMGjToqMfnz58fQ4cO7XatpaUlWlpaskYEAKh4y5cvj+XLl3e7tnfv3oKm6T8ESAF+/vOfx4ABA44ZHxERixYtiokTJyZPBQDA/3esvwDu6OiISZMmFTRR/+AtWGXU1dV11LWf/vSn8dBDD8WHPvShAiYCAIBieQWkjJqbm+Mtb3lLTJ06NYYPHx4bNmyI++67LwYNGhR333130eMBAEA6AVJGH/7wh2PZsmVxzz33xIsvvhjDhw+PGTNmxB133BFvf/vbix4PAADSCZAymjdvXsybN6/oMQAA4LThMyAAAEAaAQIAAKQRIAAAQBoBAgAApBEgAABAGgECAACkESAAAEAaAQIAAKQRIAAAQBoBAgAApBEgAABAGgECAACkESAAAEAaAQIAAKQRIAAAQBoBAgAApBEgAABAGgECAACkESAAAEAaAQIAAKQRIAAAQBoBAgAApBEgAABAGgECAACkESAAAEAaAQIAAKQRIAAAQBoBAgAApBEgAABAGgECAACkESAAAEAaAQIAAKQRIAAAQBoBAgAApBEgAABAGgECAACkESAAAEAaAQIAAKQRIAAAQBoBAgAApBEgAABAGgECAACkESAAAEAaAQIAAKQRIAAAQBoBAgAApBEgAABAGgECAACkESAAAEAaAQIAAKQRIAAAQBoBAgAApBEgAABAGgECAACkESAAAEAaAQIAAKQRIAAAQBoBAgAApBEgAABAGgECAACkESAAAEAaAQIAAKQRIAAAQBoBAgAApBEgAABAGgECAACkESAAAEAaAQIAAKQRIAAAQBoBAgAApBEgAABAGgECAACkESAAAEAaAQIAAKQRIAAAQBoBAgAApBEgAABAGgECAACkESAAAEAaAQIAAKQRIAAAQBoBAgAApBEgie66666orq6O8ePHFz0KAAAUQoAk2blzZ3zxi1+MgQMHRlVVVdHjAABAIWqKHqBS/PEf/3E0NTXFwYMH49lnny16HAAAKIRXQBL86Ec/igcffDAWLVoUpVLJKyAAAFQsAVJmhw4dinnz5sWnPvWpaGxsLHocAAB6oaurK+bOnRszZswoepQznrdgldmSJUtix44d8cMf/rDoUQAA6IU9e/ZEU1NTbNmypehR+gWvgJTRc889FwsXLoyFCxdGbW1t0eMAANALt912m/g4hQRIGd1+++0xbNiwmDdvXtGjAADQS2vXri16hH7FW7DKZPPmzfGNb3wjFi1aFDt37jxy/cCBA/Hqq6/G9u3bY/DgwXHeeecdde/8+fNj6NCh3a61tLRES0tL2ecGAOANy5cvj+XLl8f27duLHqVfqSqVSqWih+iPHn300bjiiitO+Jz58+fHV77ylSO/7+joiEmTJsX69etj4sSJ5R4RAICT0NjYGBs2bOh2zZ/Xes8rIGUyfvz4WLlyZbdvuVsqleL222+Pl156Kf7iL/4iGhoaCpwQAICTMXny5KMChN4TIGVSW1sb119//VHX77nnnoiIuO6667JHAgCgF1pbW2P16tU+iH6K+BB6sqqqKj+IEADgDFJXVxft7e0xZ86cGDNmTNHjnPG8ApLskUceKXoEAAB6qK6uLtra2o58Zpfe8woIAACQRoAAAABpBAgAAJBGgAAAAGkECAAAkEaAAAAAaQQIAACQRoAAAABpBAgAAJBGgAAAAGkECAAAkEaAAAAAaQQIAACQRoAAAABpBAgAAJBGgAAAAGkECAAAkEaAAAAAaQQIAACQRoAAAABpBAgAAJBGgAAAAGkECAAAkEaAAAAAaQQIAACQRoAAAABpBAgAAJBGgAAAAGkECAAAkEaAAAAAaQQIAACQRoAAAABpBAgAAJBGgAAAAGkECAAAkEaAAAAAaQQIAACQRoAAAABpBAgAAJBGgAAAAGkECAAAkEaAAAAAaQQIAACQRoAAAABpBAgAAJBGgAAAAGkECAAAkEaAAAAAaQQIAACQRoAAAABpBAgAAJBGgAAAAGkECAAAkEaAAAAAaQQIAACQRoAAAABpBAgAAJBGgAAAAGkECAAAkEaAAAAAaQQIAACQRoAAAABpBAgAAJBGgAAAAGkECAAAkEaAAAAAaQQIAACQRoAAAABpBAgAAJBGgAAAAGkECAAAkEaAAAAAaQQIAACQRoAAAABpBAgAAJBGgAAAAGkECAAAkEaAAAAAaQQIAACQRoAAAABpBAgAAJBGgAAAAGkESBk98cQTMXPmzGhoaIiBAwdGbW1tNDU1xbJly4oeDQAAClFT9AD92Y4dO+Kll16KOXPmRH19fezfvz9WrFgRH/3oR2Pbtm3x+c9/vugRAQAgVVWpVCoVPUQlef3112PSpEnxv//7v7F9+/Zuj3V0dMSkSZNi/fr1MXHixIImBADgePx5re+8BStZdXV1jBo1Ks4666yiRwEAgHTegpVg//79sX///njhhRfioYceiu9///uxePHioscCKJuurq5YsGBBrF27Ng4ePBg1NTUxefLkaG1tjbq6uqLHA6BAAiTBZz7zmbjvvvsiIqKmpibuvffeuPHGGwueCqA89uzZE01NTbFly5Zu1zds2BCrV6+O9vZ2EQJQwbwFK8Gtt94aq1ativvvvz8++MEPxs033xxLly4teiyAsrjtttuOio/DtmzZEgsWLEieCIDTiVdAEowbNy7GjRsXERGzZ8+OK6+8MubPnx+zZs2KAQMGFDwdwKm1du3aPj0OQP8mQArwkY98JP71X/81nnzyyZgwYcJRj8+fPz+GDh3a7VpLS0u0tLRkjQjQawcPHuzT4wCni+XLl8fy5cu7Xdu7d29B0/QfAqQAv/jFLyLije+IdSyLFi3ybd2AM1ZNzYn/0/JmjwOcLo71F8CHvw0vveczIGXU1dV11LXXXnst7r///qitrY3GxsYCpgIor8mTJ/fpcQD6N38NVUY33nhj7Nu3Ly677LKor6+P3bt3x7Jly2LTpk3R1tYWv/Zrv1b0iACnXGtra6xevfqYH0RvaGiI1tbWAqYC4HQhQMro937v9+Kb3/xmfO1rX4vnnnsuBg8eHFOmTInFixfHBz/4waLHAyiLurq6aG9v93NAADgmAVJGzc3N0dzcXPQYAOnq6uqira2t6DEAOA35DAgAAJBGgAAAAGkECAAAkEaAAAAAaQQIAACQRoAAAABpBAgAAJBGgAAAAGkECAAAkEaAAAAAaQQIAACQRoAAAABpBAgAAJBGgAAAAGkECAAAkEaAAAAAaQQIAACQRoAAAABpBAgAAJBGgAAAAGkECAAAkEaAAAAAaQQIAACQRoAAAABpBAgAAJBGgAAAAGkECAAAkEaAAAAAaQQIAACQRoAAAABpBAgAAJBGgAAAAGkECAAAkEaAAAAAaQQIAACQRoAAAABpBAgAAJBGgAAAAGkECAAAkEaAAAAAaQQIAACQRoAAAABpBAgAAJBGgAAAAGkECAAAkEaAAAAAaQQIAACQRoAAAABpBAgAAJBGgAAAAGkECAAAkEaAAAAAaQQIAACQRoAAAABpBAgAAJBGgAAAAGkECAAAkEaAAAAAaQQIAACQRoAAAABpBAgAAJBGgAAAAGkECAAAkEaAAAAAaQQIAACQRoAAAABpBAgAAJBGgAAAAGkECAAAkEaAAAAAaQQIAACQRoAAAABpBAgAAJBGgAAAAGkECAAAkEaAAAAAaQQIAACQRoAAAABpBAgAAJBGgAAAAGkECAAAkEaAAAAAaQRIGT3++ONx8803R2NjYwwaNChGjx4dzc3NsXnz5qJHAwCAQtQUPUB/9qUvfSna29tj5syZcfHFF0dnZ2csXrw4Jk6cGI899lg0NjYWPSIAAKQSIGX02c9+Ni655JKoqfnlMTc3N8f48ePj7rvvjr/5m78pcDoAAMgnQMpo6tSpR10bO3ZsvOtd74qNGzcWMBEAABTLZ0CSlUqleOaZZ2LYsGFFj0IF6urqirlz50ZjY2OMGzcuGhsbY+7cudHV1VX0aABAhfAKSLJly5bFrl274gtf+ELRo1Bh9uzZE01NTbFly5Zu1zds2BCrV6+O9vb2qKurK2g6AKBSeAUk0caNG+Omm26Kpqam+PjHP170OFSY22677aj4OGzLli2xYMGC5IkAgEokQJLs3r07rr322jjvvPNixYoVUVVVVfRIVJi1a9f26XEAgFPBW7ASvPDCC3H11VfHiy++GKtXr44RI0ac8Pnz58+PoUOHdrvW0tISLS0t5RyTfu7gwYN9ehwAKs3y5ctj+fLl3a7t3bu3oGn6DwFSZgcOHIjp06fHU089FatWrYp3vOMdb3rPokWLYuLEiQnTUUn+/7eD7s3jAFBpjvUXwB0dHTFp0qSCJuofvAWrjA4dOhTNzc2xZs2aeOCBB2LKlClFj0QFmzx5cp8eBwA4FfyVZxl99rOfjYcffjimT58ezz77bHznO9/p9vjs2bMLmoxK1NraGqtXrz7mB9EbGhqitbW1gKkAgEojQMropz/9aVRVVcXDDz8cDz/8cLfHqqqqBAip6urqor29PRYsWBBr166NgwcPRk1NTUyePDlaW1t9C14AIIUAKaNHHnmk6BGgm7q6umhrayt6DACggvkMCAAAkEaAAAAAaQQIAACQRoAAAABpBAgAAJBGgAAAAGkECAAAkEaAAAAAaQQIAACQRoAAAABpBAgAAJBGgAAAAGkECAAAkEaAAAAAaQQIAACQRoAAAABpBAgAAJBGgAAAAGkECAAAkEaAAAAAaQQIAACQRoAAAABpBAgAAJBGgAAAAGkECAAAkEaAAAAAaQQIAACQRoAAAABpBAgAAJBGgAAAAGkECAAAkEaAAAAAaQQIAACQRoAAAABpBAgAAJBGgAAAAGkECAAAkEaAAAAAaQQIAACQRoAAAABpBAgAAJBGgAAAAGkECAAAkEaAAAAAaQQIAACQRoAAAABpBAgAAJBGgAAAAGkECAAAkEaAAAAAaQQIAACQRoAAAABpBAgAAJBGgAAAAGkECAAAkEaAAAAAaQQIAACQRoAAAABpBAgAAJBGgAAAAGkECAAAkEaAAAAAaQQIAACQRoAAAABpBAgAAJBGgAAAAGkECAAAkEaAAAAAaQQIAACQRoAAAABpBAgAAJBGgAAAAGkECAAAkEaAAAAAaQQIAACQRoAAAABpBAgAAJBGgAAAAGkECAAAkEaAAAAAaQQIAACQRoAAAABpBEgZvfzyy3HHHXfEVVddFW9961ujuro6li5dWvRYAABQGAFSRl1dXXHnnXfGk08+GRMmTIiIiKqqqoKnAgCA4giQMqqvr4/du3fH1q1b48tf/nLR4/Rry5cvL3qEM44z6x3n1nPOrHecW885s95xbmQTIGV09tlnx/DhwyMiolQqFTxN/+Zfnj3nzHrHufWcM+sd59Zzzqx3nBvZBMhpaMaMGTF37tzo6uoqehQAADilaooegKNt3bo1tm7dGqtXr4729vaoq6sreiQAADglvAJyGtuyZUssWLCg6DEAAOCU8QrIae7f//3fo6Ojo+gxTnt79+51Tj3kzHrHufWcM+sd59Zzzqx3nFvP/OxnPyt6hDNeVcmno1OsW7cuJk+eHN/+9rfjYx/72DGf09nZGfX19cmTAQDQE/X19bFu3boYOXJk0aOckbwCchoZOXJk7Nq1Kzo7O4seBQCA4xg5cqT46AMBcpqx0AAA9GcCpMwWL14ce/fujV27dkVExEMPPRQ7duyIiIhbbrklBg8eXOR4AACQymdAymzMmDGxffv2iIioqqqKiDd+KGFVVVVs3bo1zj///CLHAwCAVAIEAABI4+eAAAAAaQRIgldeeSVuu+22qK+vj7e85S3x3ve+N1atWnVS9+7duzduvPHGqKuri0GDBsUVV1wRP/nJT8o88emht+f27W9/O6qrq4/5a8+ePQmTF+Pll1+OO+64I6666qp461vfGtXV1bF06dKTvr9Sd60v51apu/b444/HzTffHI2NjTFo0KAYPXp0NDc3x+bNm0/q/krdtb6cW6Xu2hNPPBEzZ86MhoaGGDhwYNTW1kZTU1MsW7bspO6v1F3ry7lV6q4dy1133RXV1dUxfvz4k3p+pe5bb/gQeoI5c+bEgw8+GLfeemtceOGF0dbWFtdcc0088sgj8b73ve+4973++utx7bXXxn/+53/GggULora2Nv7qr/4qpk2bFuvXr4+xY8cmfhX5entuh915550xZsyYbteGDBlSrnEL19XVFXfeeWeMHj06JkyYEI8++uiRzx29mUretb6c22GVtmtf+tKXor29PWbOnBkXX3xxdHZ2xuLFi2PixInx2GOPRWNj43HvreRd68u5HVZpu7Zjx4546aWXYs6cOVFfXx/79++PFStWxEc/+tHYtm1bfP7znz/uvZW8a305t8Mqbdd+1c6dO+OLX/xiDBw48KT+m1DJ+9YrJcpqzZo1paqqqtKf//mfH7l24MCB0tixY0tNTU0nvPfv//7vS1VVVaUHH3zwyLWurq7SeeedV/r93//9ss18OujLubW1tZWqqqpK69evL/eYp5VXXnml9Mwzz5RKpVJp3bp1paqqqtLSpUtP6t5K3rW+nFul7tqPf/zj0muvvdbt2ubNm0vnnntuafbs2Se8t5J3rS/nVqm7diyHDh0qTZgwoXT++eef8HmVvGvHcrLnZtfe0NzcXPqt3/qt0rRp00q/+Zu/+abPt2894y1YZbZixYqoqamJG2+88ci1c845Jz75yU9Ge3t7PP300ye8d8SIEXHDDTccuTZs2LCYNWtW/MM//EO89tprZZ29SH05t8NKpVLs27cvDh06VM5RTxtnn312DB8+PCLe+Np7opJ3rS/ndlil7drUqVOjpqb7C+hjx46Nd73rXbFx48YT3lvJu9aXczus0nbtWKqrq2PUqFFx1llnnfB5lbxrx3Ky53ZYJe/aj370o3jwwQdj0aJFR75z6Zuxbz0jQMrsJz/5SVx00UUxaNCgbtcvueSSiIj4j//4jxPeO3HixKOuX3LJJbF///7YtGnTqR32NNKXczvs8ssvjyFDhsTAgQPj+uuvj6eeeqoss/YHlbxrp4Jde+MPK88880wMGzbshM+za92d7LkdVqm7tn///nj22Wdjy5Ytcc8998T3v//9WLBgwQnvsWu9O7fDKnXXDh06FPPmzYtPfepTJ/W2yMPsW8/4DEiZdXZ2HvMnmx++dvgHFB7v3mnTpp3w3p78n+NM0pdzGzhwYMydOzcuv/zyGDx4cKxbty6+8pWvRFNTU3R0dMSoUaPKNveZqpJ3rS/s2i8tW7Ysdu3aFV/4whdO+Dy71t3Jnlul79pnPvOZuO+++yIioqamJu69995ur5Afi13r3blV+q4tWbIkduzYET/84Q97dJ996xkBUma/+MUv4pxzzjnq+rnnnnvk8eM5cOBAr+890/Xl3GbOnBkzZ8488vvrrrsurrzyyrjsssvirrvuiq997WunfuAzXCXvWl/YtTds3LgxbrrppmhqaoqPf/zjJ3yuXfulnpxbpe/arbfeGrNmzYpdu3bFsmXL4uabb44BAwac8NzsWu/OrZJ37bnnnouFCxfGwoULo7a2tkf32reeESBlNmDAgHjllVeOun7gwIEjj5fj3jPdqf7a3/e+98WUKVNO+tsfV5pK3rVTrdJ2bffu3XHttdfGeeedFytWrHjT90rbtTf09NyOpZJ2bdy4cTFu3LiIiJg9e3ZceeWVMX/+/Jg1a9Zxd8au9e7cjqVSdu3222+PYcOGxbx583p8r33rGZ8BKbORI0ce8+1CnZ2dERFRX19flnvPdOX42keNGhXPP/98n2frjyp518qhUnbthRdeiKuvvjpefPHF+Jd/+ZcYMWLEm95j13p3bsdTKbv2qz7ykY/ECy+8EE8++eRxn2PXjnYy53Y8/X3XNm/eHN/4xjdi3rx5sXPnzti2bVts27YtDhw4EK+++mps3779hF+/fesZAVJm7373u2PTpk2xb9++btfXrFkTERETJkw47r0TJkyIjo6Oo74zz5o1a2LgwIFx0UUXnfqBTxN9Obfj+fnPfx51dXWnZL7+ppJ3rRwqYdcOHDgQ06dPj6eeeir+8R//Md7xjnec1H2Vvmu9PbfjqYRdO5bDb2eprj7+H2MqfdeO5WTO7Xj6+649/fTT8frrr8ctt9wSb3/724/8Wrt2bWzatCnGjBkTd95553Hvt289I0DKbMaMGXHo0KEjHwKLeOMnfLe1tcV73/veeNvb3hYRb7wcv3Hjxjh48GC3e5955pn47ne/e+Tas88+Gw888EBMnz79pL+V3pmoL+fW1dV11D/vn/7pn6KjoyOuuuqq8g9/mrNrvWPXfunQoUPR3Nwca9asiQceeCCmTJlyzOfZte76cm6VumvH+rrLggk3AAADF0lEQVRfe+21uP/++6O2tvbIh3o7Ozvt2v/Tl3Or1F0bP358rFy5Mr73ve8d+bVy5cpobGyM0aNHx/e+97345Cc/GRH27VSoKvX2G99z0pqbm2PlypVx6623RkNDQyxdujTWrVsX//Zv/xaXXnppRLzxU7/vv//+2LZtW5x//vkR8cZP1bz00kvjv//7v+Nzn/vckZ+quXPnznj88cfjwgsvLPLLKrventuFF14YEydOjEmTJsWQIUOio6MjvvWtb8Xb3va2ePzxx/v13+AsXrw49u7dG7t27YolS5bEDTfccOTVoltuuSUGDx5s146ht+dWqbs2f/78uPfee2P69OndPqx62OzZsyPCv9d+VV/OrVJ37cMf/nDs27cvLrvssqivr4/du3fHsmXLYtOmTdHW1hYf+9jHIsKu/aq+nFul7trxTJs2LZ577rn4r//6ryPX7NspkP+zDyvPgQMHSp/73OdKI0eOLJ177rmlKVOmlH7wgx90e86cOXNK1dXVpe3bt3e7/vzzz5f+4A/+oDRs2LDSwIEDS5dffnnF/HTS3p7b7bffXnr3u99dGjp0aOnss88uXXDBBaWbbrqptGfPnuwvId0FF1xQqqqqKlVVVZWqq6tL1dXVR/734TOya0fr7blV6q5NmzbtyBn96q/q6uojz7Nr3fXl3Cp11/7u7/6u9Nu//dulESNGlM4666xSbW1t6ZprrimtWrWq2/PsWnd9ObdK3bXjmTZtWmn8+PHdrtm3vvMKCAAAkMZnQAAAgDQCBAAASCNAAACANAIEAABII0AAAIA0AgQAAEgjQAAAgDQCBAAASCNAAACANAIEAABII0AAAIA0AgQAAEgjQAAAgDQCBAAASCNAAACANAIEAABII0AAAIA0AgQAAEgjQAAAgDQCBAAASCNAAACANAIEAABII0AAAIA0AgQAAEgjQAAAgDQCBAAASCNAAACANAIEAABII0AAAIA0AgQAAEgjQAAAgDQCBAAASCNAAACANAIEAABII0AAAIA0AgQAAEgjQAAAgDQCBAAASCNAAACANP8H3KyZU9NTlqcAAAAASUVORK5CYII="; }, - thumbnail_uri: function () { return null; } - } - - -}; \ No newline at end of file diff --git a/snakemake/report/template/rulegraph.js b/snakemake/report/template/rulegraph.js deleted file mode 100644 index 8c9225d58..000000000 --- a/snakemake/report/template/rulegraph.js +++ /dev/null @@ -1,142 +0,0 @@ -var rulegraph_spec = { - "$schema": "https://vega.github.io/schema/vega/v5.json", - "padding": 0, - - "signals": [ - { "name": "cx", "update": "width / 2" }, - { "name": "cy", "update": "height / 2" } - ], - - "data": [ - { - "name": "node-data", - "values": [{ 'rule': 'c', 'fx': 10, 'fy': 0 }, { 'rule': 'd', 'fx': 10, 'fy': 50 }, { 'rule': 'e', 'fx': 10, 'fy': 100 }, { 'rule': 'a', 'fx': 10, 'fy': 150 }, { 'rule': 'b', 'fx': 10, 'fy': 200 }, { 'rule': 'all', 'fx': 10, 'fy': 250 }] - }, - { - "name": "link-data", - "values": [{ 'target': 3, 'source': 0, 'value': 1 }, { 'target': 3, 'source': 0, 'value': 1 }, { 'target': 3, 'source': 0, 'value': 1 }, { 'target': 3, 'source': 0, 'value': 1 }, { 'target': 3, 'source': 0, 'value': 1 }, { 'target': 3, 'source': 0, 'value': 1 }, { 'target': 3, 'source': 0, 'value': 1 }, { 'target': 3, 'source': 0, 'value': 1 }, { 'target': 3, 'source': 0, 'value': 1 }, { 'target': 3, 'source': 0, 'value': 1 }, { 'target': 4, 'source': 0, 'value': 1 }, { 'target': 4, 'source': 0, 'value': 1 }, { 'target': 4, 'source': 0, 'value': 1 }, { 'target': 4, 'source': 0, 'value': 1 }, { 'target': 4, 'source': 0, 'value': 1 }, { 'target': 4, 'source': 0, 'value': 1 }, { 'target': 4, 'source': 0, 'value': 1 }, { 'target': 4, 'source': 0, 'value': 1 }, { 'target': 4, 'source': 0, 'value': 1 }, { 'target': 4, 'source': 0, 'value': 1 }, { 'target': 5, 'source': 3, 'value': 1 }, { 'target': 5, 'source': 1, 'value': 1 }, { 'target': 5, 'source': 2, 'value': 1 }] - }, - { - "name": "link-data-direct", - "values": [{ 'target': 5, 'source': 4, 'value': 1 }] - } - ], - - "scales": [ - { - "name": "color", - "type": "ordinal", - "range": { "scheme": "category20c" } - }, - { - "name": "x", - "type": "linear" - }, - { - "name": "y", - "type": "linear" - } - ], - - "marks": [ - { - "name": "nodes", - "type": "symbol", - "zindex": 1, - "from": { "data": "node-data" }, - "encode": { - "enter": { - "fill": { "scale": "color", "field": "rule" }, - "x": { "field": "fx", "scale": "x" }, - "y": { "field": "fy", "scale": "y" }, - "tooltip": { "value": "Click to show rule details." } - }, - "update": { - "size": { "value": 70 } - }, - "hover": { - "size": { "value": 140 } - } - }, - - "transform": [ - { - "type": "force", - "iterations": 1, - "static": true, - "forces": [ - { - "force": "link", - "links": "link-data" - } - ] - }, - { - "type": "force", - "iterations": 1, - "static": true, - "forces": [ - { - "force": "link", - "links": "link-data-direct" - } - ] - } - ] - }, - { - "name": "labels", - "type": "text", - "zindex": 2, - "from": { "data": "node-data" }, - "encode": { - "enter": { - "fill": { "value": "black" }, - "fontWeight": { "value": "normal" }, - "text": { "field": "rule" }, - "x": { "field": "fx", "scale": "x" }, - "y": { "field": "fy", "scale": "y" }, - "dx": { "value": -5 }, - "dy": { "value": -5 }, - "align": { "value": "right" } - } - } - }, - { - "type": "path", - "from": { "data": "link-data-direct" }, - "interactive": false, - "encode": { - "update": { - "stroke": { "value": "#ccc" }, - "strokeWidth": { "value": 1.0 } - } - }, - "transform": [ - { - "type": "linkpath", "shape": "diagonal", - "sourceX": "datum.source.x", "sourceY": "datum.source.y", - "targetX": "datum.target.x", "targetY": "datum.target.y" - } - ] - }, - { - "type": "path", - "from": { "data": "link-data" }, - "interactive": false, - "encode": { - "update": { - "stroke": { "value": "#ccc" }, - "strokeWidth": { "value": 1.0 } - } - }, - "transform": [ - { - "type": "linkpath", "shape": "curve", "orient": "horizontal", - "sourceX": "datum.source.x", "sourceY": "datum.source.y", - "targetX": "datum.target.x", "targetY": "datum.target.y" - } - ] - } - ] -}; \ No newline at end of file diff --git a/snakemake/report/template/rulegraph_spec.js b/snakemake/report/template/rulegraph_spec.js deleted file mode 100644 index fd694a608..000000000 --- a/snakemake/report/template/rulegraph_spec.js +++ /dev/null @@ -1,142 +0,0 @@ -var rulegraph_spec = { - "$schema": "https://vega.github.io/schema/vega/v5.json", - "padding": 0, - - "signals": [ - { "name": "cx", "update": "width / 2" }, - { "name": "cy", "update": "height / 2" } - ], - - "data": [ - { - "name": "node-data", - "values": {{ rulegraph_nodes }} - }, -{ - "name": "link-data", - "values": { { rulegraph_links } } -}, -{ - "name": "link-data-direct", - "values": { { rulegraph_links_direct } } -} - ], - -"scales": [ - { - "name": "color", - "type": "ordinal", - "range": { "scheme": "category20c" } - }, - { - "name": "x", - "type": "linear" - }, - { - "name": "y", - "type": "linear" - } -], - - "marks": [ - { - "name": "nodes", - "type": "symbol", - "zindex": 1, - "from": { "data": "node-data" }, - "encode": { - "enter": { - "fill": { "scale": "color", "field": "rule" }, - "x": { "field": "fx", "scale": "x" }, - "y": { "field": "fy", "scale": "y" }, - "tooltip": { "value": "Click to show rule details." } - }, - "update": { - "size": { "value": 70 } - }, - "hover": { - "size": { "value": 140 } - } - }, - - "transform": [ - { - "type": "force", - "iterations": 1, - "static": true, - "forces": [ - { - "force": "link", - "links": "link-data" - } - ] - }, - { - "type": "force", - "iterations": 1, - "static": true, - "forces": [ - { - "force": "link", - "links": "link-data-direct" - } - ] - } - ] - }, - { - "name": "labels", - "type": "text", - "zindex": 2, - "from": { "data": "node-data" }, - "encode": { - "enter": { - "fill": { "value": "black" }, - "fontWeight": { "value": "normal" }, - "text": { "field": "rule" }, - "x": { "field": "fx", "scale": "x" }, - "y": { "field": "fy", "scale": "y" }, - "dx": { "value": -5 }, - "dy": { "value": -5 }, - "align": { "value": "right" } - } - } - }, - { - "type": "path", - "from": { "data": "link-data-direct" }, - "interactive": false, - "encode": { - "update": { - "stroke": { "value": "#ccc" }, - "strokeWidth": { "value": 1.0 } - } - }, - "transform": [ - { - "type": "linkpath", "shape": "diagonal", - "sourceX": "datum.source.x", "sourceY": "datum.source.y", - "targetX": "datum.target.x", "targetY": "datum.target.y" - } - ] - }, - { - "type": "path", - "from": { "data": "link-data" }, - "interactive": false, - "encode": { - "update": { - "stroke": { "value": "#ccc" }, - "strokeWidth": { "value": 1.0 } - } - }, - "transform": [ - { - "type": "linkpath", "shape": "curve", "orient": "horizontal", - "sourceX": "datum.source.x", "sourceY": "datum.source.y", - "targetX": "datum.target.x", "targetY": "datum.target.y" - } - ] - } - ] - }; \ No newline at end of file diff --git a/snakemake/report/template/rules.js b/snakemake/report/template/rules.js deleted file mode 100644 index 4c6097bf7..000000000 --- a/snakemake/report/template/rules.js +++ /dev/null @@ -1,20 +0,0 @@ -var rules = { - "a": { - "input": [ - "x.txt", - "y.txt" - ], - "output": [ - "z.txt", - "y2.txt" - ], - "conda": [ - "bwa =0.74" - ], - "container": "docker://miniconda", - "code": [ - "codeblock1(1.4)", - "codeblock2(1.5)" - ] - } -} \ No newline at end of file diff --git a/snakemake/report/template/runtimes.js b/snakemake/report/template/runtimes.js deleted file mode 100644 index 81b4cd85d..000000000 --- a/snakemake/report/template/runtimes.js +++ /dev/null @@ -1,15 +0,0 @@ -var runtimes_spec = { - "$schema": "https://vega.github.io/schema/vega-lite/v3.json", - "description": "Runtimes of jobs.", - "data": { "values": [{ 'rule': 'a', 'runtime': 2.0280115604400635 }, { 'rule': 'c', 'runtime': 3.028017282485962 }, { 'rule': 'c', 'runtime': 3.020017147064209 }, { 'rule': 'c', 'runtime': 2.0160114765167236 }, { 'rule': 'c', 'runtime': 3.016017198562622 }, { 'rule': 'c', 'runtime': 1.0240058898925781 }, { 'rule': 'c', 'runtime': 3.016016960144043 }, { 'rule': 'c', 'runtime': 1.0160057544708252 }, { 'rule': 'c', 'runtime': 2.0120115280151367 }, { 'rule': 'c', 'runtime': 3.024017095565796 }, { 'rule': 'c', 'runtime': 1.0160057544708252 }, { 'rule': 'd', 'runtime': 1.0520060062408447 }, { 'rule': 'e', 'runtime': 0.012000083923339844 }] }, - "mark": "point", - "encoding": { - "x": { - "field": "runtime", "type": "quantitative", - "axis": { "title": "runtime [s]", "labelAngle": -90 }, - "scale": { "type": "log" } - }, - "y": { "field": "rule", "type": "nominal" }, - "color": { "value": "#007bff" } - } -}; \ No newline at end of file diff --git a/snakemake/report/template/timeline.js b/snakemake/report/template/timeline.js deleted file mode 100644 index 294a3e018..000000000 --- a/snakemake/report/template/timeline.js +++ /dev/null @@ -1,20 +0,0 @@ -var timeline_spec = { - "$schema": "https://vega.github.io/schema/vega-lite/v3.json", - "description": "Timeline of jobs.", - "data": { - "values": [{ 'rule': 'a', 'starttime': '2020-03-27T14:58:42.460061', 'endtime': '2020-03-27T14:58:44.488072' }, { 'rule': 'c', 'starttime': '2020-03-27T14:58:39.404043', 'endtime': '2020-03-27T14:58:42.432060' }, { 'rule': 'c', 'starttime': '2020-03-27T14:58:38.368037', 'endtime': '2020-03-27T14:58:41.388055' }, { 'rule': 'c', 'starttime': '2020-03-27T14:58:38.384037', 'endtime': '2020-03-27T14:58:40.400049' }, { 'rule': 'c', 'starttime': '2020-03-27T14:58:38.352037', 'endtime': '2020-03-27T14:58:41.368054' }, { 'rule': 'c', 'starttime': '2020-03-27T14:58:39.356043', 'endtime': '2020-03-27T14:58:40.380049' }, { 'rule': 'c', 'starttime': '2020-03-27T14:58:38.344037', 'endtime': '2020-03-27T14:58:41.360054' }, { 'rule': 'c', 'starttime': '2020-03-27T14:58:38.332037', 'endtime': '2020-03-27T14:58:39.348043' }, { 'rule': 'c', 'starttime': '2020-03-27T14:58:38.340037', 'endtime': '2020-03-27T14:58:40.352049' }, { 'rule': 'c', 'starttime': '2020-03-27T14:58:39.424043', 'endtime': '2020-03-27T14:58:42.448061' }, { 'rule': 'c', 'starttime': '2020-03-27T14:58:38.376037', 'endtime': '2020-03-27T14:58:39.392043' }, { 'rule': 'd', 'starttime': '2020-03-27T14:58:38.360037', 'endtime': '2020-03-27T14:58:39.412043' }, { 'rule': 'e', 'starttime': '2020-03-27T14:58:38.356037', 'endtime': '2020-03-27T14:58:38.368037' }] - }, - "mark": "point", - "encoding": { - "x": { - "field": "endtime", "type": "temporal", - "timeUnit": "yearmonthdatehoursminutes", - "axis": { - "labelAngle": -90, - "title": "creation date" - } - }, - "y": { "field": "rule", "type": "nominal" }, - "color": { "value": "#007bff" } - } -}; \ No newline at end of file From f96647549fae8f01f51b31f40574bebc5b4d404d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Johannes=20K=C3=B6ster?= Date: Fri, 11 Mar 2022 12:19:58 +0100 Subject: [PATCH 41/45] add graphviz for testing --- test-environment.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/test-environment.yml b/test-environment.yml index 327024e74..1ac2c14d3 100644 --- a/test-environment.yml +++ b/test-environment.yml @@ -62,3 +62,4 @@ dependencies: - filelock - tabulate - retry + - graphviz From fc6faf5edba3fe4d5153ae79d21c4b0a2e08e469 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Johannes=20K=C3=B6ster?= Date: Fri, 11 Mar 2022 14:58:54 +0100 Subject: [PATCH 42/45] fix lints and add hover and tooltip effects to rulegraph --- snakemake/report/__init__.py | 52 +-------------- snakemake/report/data/rulegraph.py | 19 ++++-- snakemake/report/rulegraph_spec.py | 64 +++++++++++++++++++ snakemake/report/template/components/app.js | 1 - snakemake/report/template/components/icon.js | 1 - .../report/template/components/navbar.js | 1 - .../template/components/search_results.js | 2 +- 7 files changed, 81 insertions(+), 59 deletions(-) create mode 100644 snakemake/report/rulegraph_spec.py diff --git a/snakemake/report/__init__.py b/snakemake/report/__init__.py index eb513a28e..d016c2852 100644 --- a/snakemake/report/__init__.py +++ b/snakemake/report/__init__.py @@ -53,6 +53,7 @@ ) from snakemake import logging from snakemake.report import data +from snakemake.report.rulegraph_spec import rulegraph_spec class EmbeddedMixin(object): @@ -539,57 +540,6 @@ def filename(self): return os.path.basename(self.path) -def rulegraph_spec(dag): - # get toposorting, and keep only one job of each rule per level - representatives = dict() - - def get_representatives(level): - unique = dict() - for job in level: - if job.rule.name in unique: - representatives[job] = unique[job.rule.name] - else: - representatives[job] = job - unique[job.rule.name] = job - return sorted(unique.values(), key=lambda job: job.rule.name) - - toposorted = [get_representatives(level) for level in dag.toposorted()] - - jobs = [job for level in toposorted for job in level] - - nodes = [ - {"rule": job.rule.name, "fx": 10, "fy": i * 50} for i, job in enumerate(jobs) - ] - idx = {job: i for i, job in enumerate(jobs)} - - def get_links(direct: bool): - for u in jobs: - for v in dag.dependencies[u]: - target = idx[u] - source = idx[representatives[v]] - if target - source == 1: - if not direct: - continue - else: - if direct: - continue - - yield {"target": target, "source": source, "value": 1} - - xmax = 100 - ymax = max(node["fy"] for node in nodes) - - return ( - { - "nodes": nodes, - "links": list(get_links(direct=False)), - "links_direct": list(get_links(direct=True)), - }, - xmax, - ymax, - ) - - def get_resource_as_string(path_or_uri): if is_local_file(path_or_uri): return open(Path(__file__).parent / "template" / path_or_uri).read() diff --git a/snakemake/report/data/rulegraph.py b/snakemake/report/data/rulegraph.py index f9fb64110..6aa84f4d9 100644 --- a/snakemake/report/data/rulegraph.py +++ b/snakemake/report/data/rulegraph.py @@ -76,12 +76,15 @@ def render_rulegraph(nodes, links, links_direct): { "type": "path", "from": {"data": "link-data-direct"}, - "interactive": False, + "interactive": True, "encode": { "update": { "stroke": {"value": "#ccc"}, "strokeWidth": {"value": 1.0}, - } + }, + "hover": { + "strokeWidth": {"value": 4.0}, + }, }, "transform": [ { @@ -97,12 +100,20 @@ def render_rulegraph(nodes, links, links_direct): { "type": "path", "from": {"data": "link-data"}, - "interactive": False, + "interactive": True, "encode": { + "enter": { + "tooltip": { + "signal": "{\"from rule\": datum['sourcerule'], \"to rule\": datum['targetrule']}" + }, + }, "update": { "stroke": {"value": "#ccc"}, "strokeWidth": {"value": 1.0}, - } + }, + "hover": { + "strokeWidth": {"value": 4.0}, + }, }, "transform": [ { diff --git a/snakemake/report/rulegraph_spec.py b/snakemake/report/rulegraph_spec.py new file mode 100644 index 000000000..eee2bb998 --- /dev/null +++ b/snakemake/report/rulegraph_spec.py @@ -0,0 +1,64 @@ +from functools import partial + + +def rulegraph_spec(dag): + # get toposorting, and keep only one job of each rule per level + representatives = dict() + + toposorted = [ + get_representatives(level, representatives) for level in dag.toposorted() + ] + + jobs = [job for level in toposorted for job in level] + + nodes = [ + {"rule": job.rule.name, "fx": 10, "fy": i * 50} for i, job in enumerate(jobs) + ] + idx = {job: i for i, job in enumerate(jobs)} + + xmax = 100 + ymax = max(node["fy"] for node in nodes) + + _get_links = partial(get_links, jobs, dag, idx, nodes, representatives) + + return ( + { + "nodes": nodes, + "links": list(_get_links(direct=False)), + "links_direct": list(_get_links(direct=True)), + }, + xmax, + ymax, + ) + + +def get_representatives(level: list, representatives: dict): + unique = dict() + for job in level: + if job.rule.name in unique: + representatives[job] = unique[job.rule.name] + else: + representatives[job] = job + unique[job.rule.name] = job + return sorted(unique.values(), key=lambda job: job.rule.name) + + +def get_links(jobs, dag, idx, nodes, representatives, direct: bool): + for u in jobs: + for v in dag.dependencies[u]: + target = idx[u] + source = idx[representatives[v]] + if target - source == 1: + if not direct: + continue + else: + if direct: + continue + + yield { + "target": target, + "source": source, + "sourcerule": nodes[source]["rule"], + "targetrule": nodes[target]["rule"], + "value": 1, + } diff --git a/snakemake/report/template/components/app.js b/snakemake/report/template/components/app.js index b5bc0d8d4..f25f2d844 100644 --- a/snakemake/report/template/components/app.js +++ b/snakemake/report/template/components/app.js @@ -17,7 +17,6 @@ class App extends React.Component { } setView(view) { - event.preventDefault(); this.setState({ hideNavbar: view.hideNavbar || this.hideNavbar, navbarMode: view.navbarMode || this.state.navbarMode, diff --git a/snakemake/report/template/components/icon.js b/snakemake/report/template/components/icon.js index 240a029b1..f8fd391bf 100644 --- a/snakemake/report/template/components/icon.js +++ b/snakemake/report/template/components/icon.js @@ -43,7 +43,6 @@ class Icon extends React.Component { } render() { - let _this = this; return e( "svg", { xmlns: "http://www.w3.org/2000/svg", className: `h-4 w-4 ${this.props.className}`, viewBox: "0 0 20 20", fill: "currentColor", }, diff --git a/snakemake/report/template/components/navbar.js b/snakemake/report/template/components/navbar.js index 476da7e96..741e8605a 100644 --- a/snakemake/report/template/components/navbar.js +++ b/snakemake/report/template/components/navbar.js @@ -174,7 +174,6 @@ class Navbar extends React.Component { subcategory = this.props.app.state.subcategory; mode = "subcategory"; } - let _this = this; let name = this.props.app.state.category; if (isSingleDefaultCategory()) { diff --git a/snakemake/report/template/components/search_results.js b/snakemake/report/template/components/search_results.js index d488355a8..0447ba31d 100644 --- a/snakemake/report/template/components/search_results.js +++ b/snakemake/report/template/components/search_results.js @@ -22,7 +22,7 @@ class SearchResults extends AbstractResults { return [path, result]; } const columns = result.columns || []; - for (columnValue in columns) { + for (const columnValue in columns) { if (searchFunc(columnValue)) { return [path, result]; } From 663a8b882f72df7e4cdd9ac7e152d74ba3cc1970 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Johannes=20K=C3=B6ster?= Date: Fri, 11 Mar 2022 17:42:44 +0100 Subject: [PATCH 43/45] overflow fixes and link support (draft) --- docs/snakefiles/reporting.rst | 47 ++++++++++- snakemake/report/__init__.py | 4 +- .../template/components/abstract_results.js | 77 +++---------------- snakemake/report/template/components/app.js | 20 +++++ .../report/template/components/breadcrumbs.js | 2 +- .../report/template/components/button.js | 15 ++++ snakemake/report/template/components/menu.js | 21 ++--- .../report/template/components/navbar.js | 12 +-- .../report/template/components/result_info.js | 13 +++- .../template/components/result_view_button.js | 69 +++++++++++++++++ snakemake/report/template/index.html.jinja2 | 5 +- 11 files changed, 186 insertions(+), 99 deletions(-) create mode 100644 snakemake/report/template/components/button.js create mode 100644 snakemake/report/template/components/result_view_button.js diff --git a/docs/snakefiles/reporting.rst b/docs/snakefiles/reporting.rst index c011b5fbd..16e7de925 100644 --- a/docs/snakefiles/reporting.rst +++ b/docs/snakefiles/reporting.rst @@ -52,7 +52,11 @@ Consider the following example: rule d: output: - report(directory("testdir"), patterns=["{name}.txt"], caption="report/somedata.rst", category="Step 3") + report( + directory("testdir"), + patterns=["{name}.txt"], + caption="report/somedata.rst", + category="Step 3") shell: "mkdir {output}; for i in 1 2 3; do echo $i > {output}/$i.txt; done" @@ -89,8 +93,44 @@ This works as follows: echo \"alert('test')\" > test/js/test.js """ +Defining file labels +~~~~~~~~~~~~~~~~~~~~~ -Moreover, in every ``.rst`` document, you can link to +In addition to category, and subcategory, it is possible to define a dictionary of labels for each report item. +By that, the actual filename will be hidden in the report and instead a table with the label keys as columns and the values in the respective row for the file will be displayed. +This can lead to less technical reports that abstract away the fact that the results of the analysis are actually files. +Consider the following modification of rule ``b`` from above: + +.. code-block:: python + + rule b: + input: + expand("{model}.{i}.out", i=range(10)) + output: + report( + "fig2.png", + caption="report/fig2.rst", + category="Step 2", + subcategory="{model}", + labels={ + "model": "{model}", + "figure": "some plot" + } + ) + shell: + "sleep `shuf -i 1-3 -n 1`; cp data/fig2.png {output}" + + +Determining category, subcategory, and labels dynamically via functions +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Similar to e.g. with input file and parameter definition (see :ref:`snakefiles-input_functions`), ``category`` and a ``subcategory`` and ``labels`` can be specified by pointing to a function which is expected to return a string. + + +Linking between items +~~~~~~~~~~~~~~~~~~~~~ + +In every ``.rst`` document, you can link to * the **Workflow** panel (with ``Rules_``), * the **Statistics** panel (with ``Statistics_``), @@ -99,6 +139,9 @@ Moreover, in every ``.rst`` document, you can link to For details about the hyperlink mechanism of restructured text see `here `_. +Rendering reports +~~~~~~~~~~~~~~~~~ + To create the report simply run .. code-block:: bash diff --git a/snakemake/report/__init__.py b/snakemake/report/__init__.py index d016c2852..601384b8d 100644 --- a/snakemake/report/__init__.py +++ b/snakemake/report/__init__.py @@ -801,10 +801,10 @@ def get_datetime(rectime): .. _Workflow: javascript:show_panel('workflow') .. _Statistics: javascript:show_panel('statistics') {% for cat, catresults in categories|dictsort %} - .. _{{ cat.name }}: javascript:show_panel("{{ cat.id }}") + .. _{{ cat.name }}: javascript:app.showCategory("{{ cat.name }}") {% endfor %} {% for res in files %} - .. _{{ res.target }}: javascript:show_panel("{{ res.category.id }}") + .. _{{ res.target }}: javascript:showResultInfo("{{ res.path }}") {% endfor %} """ ) diff --git a/snakemake/report/template/components/abstract_results.js b/snakemake/report/template/components/abstract_results.js index 260a54f63..a456b7bca 100644 --- a/snakemake/report/template/components/abstract_results.js +++ b/snakemake/report/template/components/abstract_results.js @@ -84,6 +84,7 @@ class AbstractResults extends React.Component { renderEntries() { let _this = this; + let app = this.props.app; let labels = undefined; if (this.isLabelled()) { labels = this.getLabels(); @@ -95,12 +96,16 @@ class AbstractResults extends React.Component { e( "div", { className: "inline-flex gap-1", role: "group" }, - _this.getViewButton(path, entry), - _this.renderButton( - "information-circle", + e( + ResultViewButton, + { resultPath: path } + ), + e( + Button, { href: "#", - onClick: () => _this.showResultInfo(path) + onClick: () => app.showResultInfo(path), + iconName: "information-circle" } ) ) @@ -137,70 +142,6 @@ class AbstractResults extends React.Component { }) } - getViewButton(resultPath, entry) { - const mimeType = this.getResultMimeType(resultPath); - let setView = this.props.setView; - - let props = undefined; - - switch (mimeType) { - case "image/svg+xml": - case "image/png": - case "image/jpeg": - props = { - href: "#", - onClick: function () { - setView({ - content: "img", - contentPath: entry.data_uri - }) - } - }; - break; - case "text/html": - props = { - href: "#", - onClick: function () { - setView({ - content: "html", - contentPath: entry.data_uri - }) - } - }; - break; - case "application/pdf": - props = { - href: "#", - onClick: function () { - setView({ - content: "pdf", - contentPath: entry.data_uri - }) - } - }; - break; - default: - props = { - href: entry.data_uri, - download: entry.name, - target: "_blank" - }; - } - return this.renderButton("eye", props); - } - - renderButton(iconName, props) { - return e( - "a", - { type: "button", className: `transition-all inline-block p-1 text-emerald-500 rounded hover:bg-slate-800`, ...props }, - e(Icon, { iconName: iconName }) - ) - } - - showResultInfo(resultPath) { - this.props.setView({ navbarMode: "resultinfo", resultPath: resultPath, category: this.getCategory(), subcategory: this.getSubcategory(), searchTerm: this.getSearchTerm() }); - } - getResultMimeType(resultPath) { return results[resultPath].mime_type } diff --git a/snakemake/report/template/components/app.js b/snakemake/report/template/components/app.js index f25f2d844..2732e76dc 100644 --- a/snakemake/report/template/components/app.js +++ b/snakemake/report/template/components/app.js @@ -1,12 +1,18 @@ 'use strict'; +var app = undefined; + class App extends React.Component { constructor(props) { super(props); this.state = { hideNavbar: false, navbarMode: "menu", content: "rulegraph", ruleinfo: undefined, category: undefined, subcategory: undefined, searchTerm: undefined, resultPath: undefined, contentPath: undefined }; this.setView = this.setView.bind(this); + this.showCategory = this.showCategory.bind(this); + this.showResultInfo = this.showResultInfo.bind(this); + // store in global variable + app = this; } render() { @@ -29,6 +35,20 @@ class App extends React.Component { contentPath: view.contentPath || this.state.contentPath, }) } + + showCategory(category) { + let subcategory = undefined; + let mode = "category"; + if (isSingleSubcategory(category)) { + subcategory = Object.keys(categories[category])[0]; + mode = "subcategory"; + } + this.setView({ navbarMode: mode, category: category, subcategory: subcategory }) + } + + showResultInfo(resultPath) { + this.setView({ navbarMode: "resultinfo", resultPath: resultPath }); + } } ReactDOM.render(e(App), document.querySelector('#app')); \ No newline at end of file diff --git a/snakemake/report/template/components/breadcrumbs.js b/snakemake/report/template/components/breadcrumbs.js index abaf9f2ae..8796f0fe8 100644 --- a/snakemake/report/template/components/breadcrumbs.js +++ b/snakemake/report/template/components/breadcrumbs.js @@ -9,7 +9,7 @@ class Breadcrumbs extends React.Component { render() { return e( "nav", - { className: "text-white align-middle text-xs m-2 p-2 rounded bg-slate-800" }, + { className: "text-white whitespace-nowrap align-middle text-xs m-2 p-2 rounded bg-slate-800 min-w-fit" }, e( "ol", { className: "list-reset flex items-center gap-1" }, diff --git a/snakemake/report/template/components/button.js b/snakemake/report/template/components/button.js new file mode 100644 index 000000000..016f9aed5 --- /dev/null +++ b/snakemake/report/template/components/button.js @@ -0,0 +1,15 @@ +'use strict'; + +class Button extends React.Component { + render() { + return this.renderButton(this.props.iconName, this.props); + } + + renderButton(iconName, props) { + return e( + "a", + { type: "button", className: `transition-all inline-block p-1 text-emerald-500 rounded hover:bg-slate-800`, ...props }, + e(Icon, { iconName: iconName }) + ); + } +} \ No newline at end of file diff --git a/snakemake/report/template/components/menu.js b/snakemake/report/template/components/menu.js index 54572770b..7b1f3a967 100644 --- a/snakemake/report/template/components/menu.js +++ b/snakemake/report/template/components/menu.js @@ -3,8 +3,8 @@ class Menu extends AbstractMenu { constructor(props) { super(props); - this.showWorkflow = this.showWorkflow.bind(this) - this.showStatistics = this.showStatistics.bind(this) + this.showWorkflow = this.showWorkflow.bind(this); + this.showStatistics = this.showStatistics.bind(this); } render() { @@ -37,20 +37,12 @@ class Menu extends AbstractMenu { } } - showCategory(category) { - let subcategory = undefined; - let mode = "category"; - if (isSingleSubcategory(category)) { - subcategory = Object.keys(categories[category])[0]; - mode = "subcategory"; - } - this.props.setView({ navbarMode: mode, category: category, subcategory: subcategory }) - } - getCategoryMenumitems() { + let _this = this; + let app = this.props.app; if (isSingleCategory()) { let category = Object.keys(categories)[0]; - return this.getMenuItem("Results", "folder", () => this.showCategory(category)); + return this.getMenuItem("Results", "folder", () => app.showCategory(category)); } else if (isNoResults()) { return []; } else { @@ -60,9 +52,8 @@ class Menu extends AbstractMenu { "Results" )]; - let _this = this items.push(...Object.keys(categories).map(function (category) { - return _this.getMenuItem(category, "folder", () => _this.showCategory(category)); + return _this.getMenuItem(category, "folder", () => app.showCategory(category)); })); return items; diff --git a/snakemake/report/template/components/navbar.js b/snakemake/report/template/components/navbar.js index 741e8605a..cd45a4ba4 100644 --- a/snakemake/report/template/components/navbar.js +++ b/snakemake/report/template/components/navbar.js @@ -21,10 +21,10 @@ class Navbar extends React.Component { ), e( "nav", - { className: `fixed z-50 transition-all ${translateNavbar} ${this.getWidth()} text-white text-sm bg-slate-900/70 backdrop-blur-sm h-screen` }, + { className: `fixed z-50 transition-all ${translateNavbar} ${this.getWidth()} text-white text-sm bg-slate-900/70 backdrop-blur-sm h-screen overflow-auto` }, e( "h1", - { className: "sticky bg-blur bg-white opacity-80 text-slate-700 text-l tracking-wide px-3 py-1 mb-1 flex items-center" }, + { className: "sticky relative top-0 left-0 bg-white/80 backdrop-blur-sm text-slate-700 text-l tracking-wide px-3 py-1 mb-1 flex items-center" }, e( "img", { src: logo_uri, className: "h-4" } @@ -43,7 +43,7 @@ class Navbar extends React.Component { ), e( "div", - { className: "overflow-auto" }, + {}, this.renderBreadcrumbs(), e( "div", @@ -93,13 +93,13 @@ class Navbar extends React.Component { let setView = this.props.app.setView; switch (this.props.app.state.navbarMode) { case "menu": - return e(Menu, { setView: setView, app: this.props.app }); + return e(Menu, { app: this.props.app }); case "category": return e(Category, { setView: setView, category: this.props.app.state.category }); case "subcategory": - return e(Subcategory, { setView: setView, category: this.props.app.state.category, subcategory: this.props.app.state.subcategory }); + return e(Subcategory, { app: this.props.app, setView: setView, category: this.props.app.state.category, subcategory: this.props.app.state.subcategory }); case "searchresults": - return e(SearchResults, { setView: setView, searchTerm: this.props.app.state.searchTerm }); + return e(SearchResults, { app: this.props.app, setView: setView, searchTerm: this.props.app.state.searchTerm }); case "resultinfo": return e(ResultInfo, { resultPath: this.props.app.state.resultPath, setView: setView }); case "ruleinfo": diff --git a/snakemake/report/template/components/result_info.js b/snakemake/report/template/components/result_info.js index 6573d0491..ab38c49de 100644 --- a/snakemake/report/template/components/result_info.js +++ b/snakemake/report/template/components/result_info.js @@ -41,7 +41,8 @@ class ResultInfo extends React.Component { { className: "text-left uppercase pr-2" }, label ); - }) + }), + e("th", {}) ) ), e( @@ -57,7 +58,11 @@ class ResultInfo extends React.Component { { className: "pr-2" }, value ); - }) + }), + e( + ResultViewButton, + { resultPath: this.props.resultPath } + ) ) ) ) @@ -73,6 +78,10 @@ class ResultInfo extends React.Component { ListItem, { key: "path" }, this.props.resultPath + ), + e( + ResultViewButton, + { resultPath: this.props.resultPath } ) ]; } diff --git a/snakemake/report/template/components/result_view_button.js b/snakemake/report/template/components/result_view_button.js new file mode 100644 index 000000000..32c6b7e30 --- /dev/null +++ b/snakemake/report/template/components/result_view_button.js @@ -0,0 +1,69 @@ +'use strict'; + +class ResultViewButton extends React.Component { + + constructor(props) { + super(props); + } + + render() { + let result = results[this.props.resultPath]; + + return this.getViewButton(this.props.resultPath, result); + } + + getViewButton(resultPath, entry) { + const mimeType = this.getResultMimeType(resultPath); + let setView = this.props.setView; + + let props = undefined; + + switch (mimeType) { + case "image/svg+xml": + case "image/png": + case "image/jpeg": + props = { + href: "#", + onClick: function () { + setView({ + content: "img", + contentPath: entry.data_uri + }) + } + }; + break; + case "text/html": + props = { + href: "#", + onClick: function () { + setView({ + content: "html", + contentPath: entry.data_uri + }) + } + }; + break; + case "application/pdf": + props = { + href: "#", + onClick: function () { + setView({ + content: "pdf", + contentPath: entry.data_uri + }) + } + }; + break; + default: + props = { + href: entry.data_uri, + download: entry.name, + target: "_blank" + }; + } + return e( + Button, + { iconName: "eye", ...props } + ); + } +} \ No newline at end of file diff --git a/snakemake/report/template/index.html.jinja2 b/snakemake/report/template/index.html.jinja2 index 2fa905292..1decc2efa 100644 --- a/snakemake/report/template/index.html.jinja2 +++ b/snakemake/report/template/index.html.jinja2 @@ -69,13 +69,12 @@ var logo_uri = "{{logo}}"; - - - + + From a96af499790992865752535aa35d204041d416aa Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Johannes=20K=C3=B6ster?= Date: Sat, 12 Mar 2022 22:26:21 +0100 Subject: [PATCH 44/45] fixes, links, brand --- snakemake/report/__init__.py | 5 +- .../template/components/abstract_results.js | 6 +- .../report/template/components/common.js | 1 + .../report/template/components/content.js | 16 +- .../report/template/components/navbar.js | 2 +- .../report/template/components/result_info.js | 45 +- .../template/components/result_view_button.js | 6 +- tests/test_report/custom-stylesheet.css | 15 +- .../test_report/expected-results/report.html | 107973 ++++++++++++++- tests/test_report/report/workflow.rst | 2 +- 10 files changed, 106481 insertions(+), 1590 deletions(-) diff --git a/snakemake/report/__init__.py b/snakemake/report/__init__.py index 601384b8d..965bc0a5d 100644 --- a/snakemake/report/__init__.py +++ b/snakemake/report/__init__.py @@ -801,10 +801,10 @@ def get_datetime(rectime): .. _Workflow: javascript:show_panel('workflow') .. _Statistics: javascript:show_panel('statistics') {% for cat, catresults in categories|dictsort %} - .. _{{ cat.name }}: javascript:app.showCategory("{{ cat.name }}") + .. _{{ cat.name }}: javascript:app.showCategory('{{ cat.name|urlencode }}') {% endfor %} {% for res in files %} - .. _{{ res.target }}: javascript:showResultInfo("{{ res.path }}") + .. _{{ res.target }}: javascript:app.showResultInfo('{{ res.path|urlencode }}') {% endfor %} """ ) @@ -822,6 +822,7 @@ class Snakemake: config = dag.workflow.config text = f.read() + rst_links + try: text = publish_parts( env.from_string(text).render( diff --git a/snakemake/report/template/components/abstract_results.js b/snakemake/report/template/components/abstract_results.js index a456b7bca..2c4854a6a 100644 --- a/snakemake/report/template/components/abstract_results.js +++ b/snakemake/report/template/components/abstract_results.js @@ -98,7 +98,7 @@ class AbstractResults extends React.Component { { className: "inline-flex gap-1", role: "group" }, e( ResultViewButton, - { resultPath: path } + { resultPath: path, app: app } ), e( Button, @@ -141,8 +141,4 @@ class AbstractResults extends React.Component { ]; }) } - - getResultMimeType(resultPath) { - return results[resultPath].mime_type - } } \ No newline at end of file diff --git a/snakemake/report/template/components/common.js b/snakemake/report/template/components/common.js index a1181d4c0..20690e20a 100644 --- a/snakemake/report/template/components/common.js +++ b/snakemake/report/template/components/common.js @@ -13,5 +13,6 @@ function isSingleDefaultCategory() { } function isSingleSubcategory(category) { + console.log(categories, category); return Object.keys(categories[category]).length == 1; } \ No newline at end of file diff --git a/snakemake/report/template/components/content.js b/snakemake/report/template/components/content.js index 3045d1140..aa3b089b8 100644 --- a/snakemake/report/template/components/content.js +++ b/snakemake/report/template/components/content.js @@ -25,10 +25,18 @@ class ContentDisplay extends React.Component { e(RuleGraph, { setView: setView }), e( "div", - { - className: "prose prose-sm max-w-lg", - dangerouslySetInnerHTML: { __html: workflow_desc } - } + {}, + e( + "div", + { + className: "prose prose-sm max-w-lg", + dangerouslySetInnerHTML: { __html: workflow_desc } + } + ), + e( + "div", + { id: "brand" } + ) ) ); case "stats": diff --git a/snakemake/report/template/components/navbar.js b/snakemake/report/template/components/navbar.js index cd45a4ba4..f1276df00 100644 --- a/snakemake/report/template/components/navbar.js +++ b/snakemake/report/template/components/navbar.js @@ -101,7 +101,7 @@ class Navbar extends React.Component { case "searchresults": return e(SearchResults, { app: this.props.app, setView: setView, searchTerm: this.props.app.state.searchTerm }); case "resultinfo": - return e(ResultInfo, { resultPath: this.props.app.state.resultPath, setView: setView }); + return e(ResultInfo, { resultPath: this.props.app.state.resultPath, app: this.props.app }); case "ruleinfo": return e(RuleInfo, { rule: this.props.app.state.ruleinfo }); } diff --git a/snakemake/report/template/components/result_info.js b/snakemake/report/template/components/result_info.js index ab38c49de..5062a1886 100644 --- a/snakemake/report/template/components/result_info.js +++ b/snakemake/report/template/components/result_info.js @@ -19,6 +19,8 @@ class ResultInfo extends React.Component { getDescriptor() { let result = this.getResult(); + let resultPath = this.props.resultPath; + let app = this.props.app; if (result.labels) { const labels = Object.keys(result.labels).sort(); @@ -28,7 +30,7 @@ class ResultInfo extends React.Component { {}, e( "table", - { className: "table-auto text-white text-sm" }, + { className: "table-auto text-white text-sm items-center" }, e( "thead", {}, @@ -51,18 +53,27 @@ class ResultInfo extends React.Component { e( "tr", {}, - labels.map(function (label) { + labels.map(function (label, index) { const value = result.labels[label]; + let item = value; + if (index == labels.length - 1) { + item = e( + "span", + { className: "flex items-center gap-2" }, + e("span", {}, value), + e( + ResultViewButton, + { resultPath: resultPath, app: app } + ) + ); + } + return e( "td", { className: "pr-2" }, - value + item ); }), - e( - ResultViewButton, - { resultPath: this.props.resultPath } - ) ) ) ) @@ -77,12 +88,20 @@ class ResultInfo extends React.Component { e( ListItem, { key: "path" }, - this.props.resultPath + e( + "span", + { className: "flex items-center gap-2" }, + e( + "span", + {}, + this.props.resultPath + ), + e( + ResultViewButton, + { resultPath: this.props.resultPath, app: app } + ) + ) ), - e( - ResultViewButton, - { resultPath: this.props.resultPath } - ) ]; } } @@ -110,7 +129,7 @@ class ResultInfo extends React.Component { } getRule() { - const setView = this.props.setView; + const setView = this.props.app.setView; const rule = this.getResult().job_properties.rule; return [ e( diff --git a/snakemake/report/template/components/result_view_button.js b/snakemake/report/template/components/result_view_button.js index 32c6b7e30..db9da54a4 100644 --- a/snakemake/report/template/components/result_view_button.js +++ b/snakemake/report/template/components/result_view_button.js @@ -14,7 +14,7 @@ class ResultViewButton extends React.Component { getViewButton(resultPath, entry) { const mimeType = this.getResultMimeType(resultPath); - let setView = this.props.setView; + let setView = this.props.app.setView; let props = undefined; @@ -66,4 +66,8 @@ class ResultViewButton extends React.Component { { iconName: "eye", ...props } ); } + + getResultMimeType(resultPath) { + return results[resultPath].mime_type + } } \ No newline at end of file diff --git a/tests/test_report/custom-stylesheet.css b/tests/test_report/custom-stylesheet.css index e278b6329..6703f7fe3 100644 --- a/tests/test_report/custom-stylesheet.css +++ b/tests/test_report/custom-stylesheet.css @@ -1,8 +1,9 @@ #brand { - margin: auto; - height: 30px; - width: 311px; - background-repeat: no-repeat; - background-size: 311px 30px; - background-image: url("data:image/svg+xml,%3C%3Fxml version='1.0' encoding='UTF-8' standalone='no'%3F%3E%3C!-- Creator: CorelDRAW --%3E%3Csvg xmlns:dc='http://purl.org/dc/elements/1.1/' xmlns:cc='http://creativecommons.org/ns%23' xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns%23' xmlns:svg='http://www.w3.org/2000/svg' xmlns='http://www.w3.org/2000/svg' xmlns:sodipodi='http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd' xmlns:inkscape='http://www.inkscape.org/namespaces/inkscape' xml:space='preserve' width='1568.9631' height='150.92992' viewBox='0 0 1483.7169 142.72835' version='1.1' id='svg12' sodipodi:docname='uk-uni-white.svg' style='clip-rule:evenodd;fill-rule:evenodd;image-rendering:optimizeQuality;shape-rendering:geometricPrecision;text-rendering:geometricPrecision' inkscape:version='0.92.4 (5da689c313, 2019-01-14)'%3E%3Cmetadata id='metadata18'%3E%3Crdf:RDF%3E%3Ccc:Work rdf:about=''%3E%3Cdc:format%3Eimage/svg+xml%3C/dc:format%3E%3Cdc:type rdf:resource='http://purl.org/dc/dcmitype/StillImage' /%3E%3Cdc:title%3E%3C/dc:title%3E%3C/cc:Work%3E%3C/rdf:RDF%3E%3C/metadata%3E%3Cdefs id='defs16'%3E%3C/defs%3E%3Csodipodi:namedview pagecolor='%23ffffff' bordercolor='%23666666' borderopacity='1' objecttolerance='10' gridtolerance='10' guidetolerance='10' inkscape:pageopacity='0' inkscape:pageshadow='2' inkscape:window-width='1850' inkscape:window-height='1025' id='namedview14' showgrid='false' inkscape:pagecheckerboard='true' fit-margin-top='0' fit-margin-left='0' fit-margin-right='0' fit-margin-bottom='0' inkscape:zoom='1.2128168' inkscape:cx='136.25611' inkscape:cy='10.038152' inkscape:window-x='70' inkscape:window-y='27' inkscape:window-maximized='1' inkscape:current-layer='svg12' showguides='true' inkscape:guide-bbox='true'%3E%3Csodipodi:guide position='989.81019,142.98824' orientation='0,1' id='guide840' inkscape:locked='false' /%3E%3C/sodipodi:namedview%3E%3Cg id='g845' transform='matrix(0.77078623,0,0,0.77078623,1422.0842,-34.102505)' style='stroke-width:1.29737616'%3E%3Cpath d='m -427.2909,73.871082 c 0,2.94841 0.13153,6.70348 3.30574,9.69765 2.01076,1.875846 5.54175,2.732196 8.98239,2.732196 2.99413,0 5.80821,-0.66893 8.08768,-2.509216 3.35373,-2.72769 3.39663,-7.46386 3.39663,-9.4312 v -21.71651 h -7.28323 v 21.6736 c 0,5.98828 -3.21768,5.98828 -4.6041,5.98828 -4.42403,0 -4.42403,-4.06669 -4.42403,-6.03397 v -21.62786 h -7.46108 v 21.22708 z m 32.19369,11.573456 h 6.61433 V 70.070802 c 0,-0.84902 -0.18008,-5.00434 -0.22298,-5.94255 h 0.22298 c 1.69859,3.97807 1.7415,4.11242 2.45672,5.40737 l 8.71595,15.908866 h 5.89964 V 52.643952 h -6.61433 v 12.1995 c 0,1.24981 0,1.51852 0.13435,3.75452 l 0.17726,3.30574 h -0.22298 c -0.13435,-0.22298 -0.58088,-1.42989 -0.71523,-1.69859 -0.31161,-0.66951 -0.76038,-1.56424 -1.11772,-2.23318 l -8.445,-15.328 h -6.883 v 32.800526 z m 39.5255,0.007 V 52.643682 h -7.24032 v 32.807856 z m 23.25703,-0.007 9.78625,-32.800536 h -7.14945 l -4.87281,17.3382 c -0.53515,1.9673 -1.07256,3.93234 -1.56198,5.89963 h -0.17951 c -0.26871,-1.02965 -0.80386,-2.90551 -1.56424,-5.58805 l -5.09352,-17.64983 h -7.19519 l 10.00923,32.800536 h 7.82123 z m 14.67543,0 h 23.06058 v -6.122616 h -15.81965 v -7.72976 h 10.143 v -5.98828 h -10.23448 v -6.9722 h 14.88203 v -5.98773 h -22.03148 v 32.800536 z m 36.70918,-27.707576 c 4.02096,0 4.91571,0 6.03119,0.40306 1.42989,0.53515 2.14512,1.65286 2.14512,3.93233 0,1.78722 -0.17782,3.57445 -2.45673,4.3783 -1.02909,0.35733 -1.65287,0.35733 -5.71956,0.35733 v -9.07104 z m 0,14.30117 h 2.411 l 6.21405,13.406406 h 7.8184 l -7.14945,-14.569846 c 4.6041,-1.38416 6.25695,-4.55612 6.25695,-8.71367 0,-8.80233 -6.74866,-9.51697 -12.06516,-9.51697 h -10.59181 v 32.800536 h 7.10599 V 72.038182 Z m 43.14115,-14.16683 c -2.6797,-3.93234 -6.07688,-5.89908 -10.90399,-5.89908 -6.74639,0 -10.67874,3.88887 -10.67874,9.29625 0,6.47994 4.28967,8.66799 9.24885,10.58954 4.91571,1.92213 6.25695,2.45954 6.25695,4.91627 0,2.99413 -2.81462,3.70879 -4.37886,3.70879 -2.81631,0 -5.00659,-1.69859 -6.21349,-4.46692 l -5.58522,3.7088 c 2.94841,5.273586 6.3456,6.664556 12.1109,6.664556 1.65287,0 4.3783,-0.49168 6.29986,-1.659636 4.64983,-2.81688 4.64983,-7.19519 4.64983,-8.67082 0,-3.08276 -1.42989,-5.2279 -1.83295,-5.7653 -1.29553,-1.78722 -3.62017,-3.12792 -5.58522,-3.84314 l -4.15758,-1.51852 c -2.01076,-0.71523 -4.15531,-1.65287 -4.15531,-3.97807 0,-0.35733 0.0886,-3.17139 3.84315,-3.17139 2.54817,0 4.647,1.6986 5.67382,3.66364 l 5.40797,-3.57501 z m 14.45472,27.580556 V 52.644002 h -7.24093 v 32.807856 z m 5.96175,-32.807856 v 5.98773 h 8.35635 v 26.812856 h 7.50904 V 58.631732 h 8.17856 v -5.98773 z m 33.26626,-3.21767 h 5.67609 v -5.18439 h -5.67609 z m 8.71595,0 h 5.67382 v -5.18439 h -5.67382 z m 2.09939,23.90734 h -7.37243 l 3.57445,-14.8363 h 0.17782 l 3.62017,14.8363 z m -8.08768,-20.68969 -9.25112,32.800536 h 7.01511 l 1.6986,-6.525676 h 10.05496 l 1.65287,6.525676 h 7.01734 l -9.47411,-32.800536 h -8.71367 z m 20.88669,0 v 5.98773 h 8.35636 v 26.812856 h 7.50904 V 58.631712 h 8.17855 v -5.98773 z' id='path5' inkscape:connector-curvature='0' style='fill:%23ffffff;fill-rule:nonzero;stroke-width:1.29737616' /%3E%3Cpath d='m -425.94284,170.75254 c 8.35636,0 15.60855,0 17.05765,-0.13661 4.07629,-0.34548 7.18331,-0.69096 10.84415,-2.55495 5.59256,-2.83325 6.90504,-8.91073 6.97448,-14.64212 l 0.0694,-8.63412 c 0.0694,-11.39621 -0.82756,-14.91817 -3.03986,-18.16408 -2.90042,-4.2129 -7.24992,-6.55899 -19.61256,-6.55899 h -12.2932 v 50.69104 z m 11.32621,-41.71349 c 5.93805,0 8.35636,0 10.49639,3.10703 1.72739,2.48777 1.86625,6.70065 1.86625,12.77758 0,1.72739 -0.13887,4.48894 -0.13887,6.21632 0,9.73773 -4.55838,10.56583 -9.04734,10.56583 h -3.17647 v -32.66675 z m 59.49367,23.82546 c 0,4.55838 0.20604,10.35978 5.10989,14.98761 3.10703,2.90043 8.56523,4.22476 13.88118,4.22476 4.62837,0 8.98012,-1.03643 12.50208,-3.87928 5.17989,-4.21289 5.24706,-11.53282 5.24706,-14.57212 v -33.56374 h -11.25677 v 33.49375 c 0,9.25617 -4.97103,9.25617 -7.11331,9.25617 -6.83787,0 -6.83787,-6.28576 -6.83787,-9.32562 v -33.4243 h -11.53226 v 32.80281 z m 85.11614,17.89991 v -50.70267 h -11.18738 v 50.70267 z m 68.33672,-42.62236 c -4.14572,-6.07971 -9.39279,-9.11674 -16.85159,-9.11674 -10.42867,0 -16.5061,6.00744 -16.5061,14.36324 0,10.01655 6.62898,13.39907 14.2944,16.36949 7.59769,2.96986 9.6705,3.79742 9.6705,7.59769 0,4.62555 -4.35176,5.73199 -6.76786,5.73199 -4.35177,0 -7.73709,-2.62495 -9.60112,-6.90726 l -8.6324,5.73144 c 4.55837,8.14974 9.80772,10.30448 18.71557,10.30448 2.55551,0 6.76842,-0.76095 9.73828,-2.56737 7.18276,-4.35176 7.18276,-11.1196 7.18276,-13.39907 0,-4.76442 -2.20947,-8.0803 -2.831,-8.91013 -2.00286,-2.76156 -5.59421,-4.83442 -8.63412,-5.93804 l -6.42237,-2.34891 c -3.10704,-1.10586 -6.42238,-2.55495 -6.42238,-6.14632 0,-0.55152 0.13661,-4.90385 5.93972,-4.90385 3.93459,0 7.18108,2.62494 8.76901,5.66421 l 8.35863,-5.52482 z m 34.90954,42.61053 h 16.3667 c 6.42293,0 10.77472,-0.27604 14.43551,-4.00403 3.38308,-3.38534 3.9346,-7.18276 3.9346,-10.91355 0,-7.45881 -4.69499,-11.11738 -8.07975,-11.60226 v -0.34548 c 3.93686,-0.897 6.97615,-4.83442 6.97615,-10.98077 0,-4.21289 -1.72739,-8.49524 -5.45538,-10.77471 -2.90043,-1.79456 -7.11332,-2.07004 -11.46566,-2.07004 h -16.71215 v 50.69104 z m 10.84188,-22.23754 c 3.93685,0 7.87369,0 9.46223,0.62152 2.62438,1.10361 3.2459,3.93686 3.2459,6.35294 0,5.17988 -2.76381,7.25275 -7.18331,7.25275 h -5.52483 v -14.22723 z m 0,-20.65127 h 5.04272 c 2.27947,0 6.76787,0 6.76787,6.1486 0,6.42237 -2.90043,6.69842 -11.81059,6.69842 z m 58.943778,25.00078 c 0,4.55838 0.20661,10.35978 5.11045,14.98761 3.10646,2.90043 8.56468,4.22476 13.88118,4.22476 4.62781,0 8.97957,-1.03643 12.50153,-3.87928 5.17988,-4.21289 5.24705,-11.53282 5.24705,-14.57211 v -33.56375 h -11.25677 v 33.49375 c 0,9.25617 -4.97103,9.25617 -7.11331,9.25617 -6.83726,0 -6.83726,-6.28576 -6.83726,-9.32562 v -33.4243 h -11.53282 v 32.80281 z m 84.01234,-24.93134 c 6.2163199,0 7.5959699,0 9.3233399,0.62152 2.20947,0.82983 3.31534003,2.55495 3.31534003,6.07916 0,2.76156 -0.27604,5.52538 -3.79799003,6.76787 -1.59021,0.55208 -2.5572,0.55208 -8.8407299,0.55208 v -14.02062 z m 0,22.10093 h 3.7285499 l 9.60112003,20.71844 H 12.451478 L 1.4035379,148.23956 c 7.11331,-2.14286 9.6682801,-7.0467 9.6682801,-13.46908 0,-13.60512 -10.42866007,-14.70873 -18.6478501,-14.70873 H -23.943292 v 50.69104 h 10.98077 v -20.71844 z m 57.90821,2.48495 c 0,6.28576 0.69094,10.49866 3.45196,14.02062 3.31591,4.14347 8.01091,5.60665 13.12363,5.60665 7.80203,0 10.08095,-2.63624 11.53227,-4.36362 h 0.48266 l 1.45132,3.5338 h 4.97327 v -27.0838 h -16.99047 v 8.4258 h 5.94026 v 3.45251 c 0,1.86625 0,6.63126 -5.80143,6.63126 -5.45761,0 -6.70065,-4.07629 -6.70065,-10.70528 V 136.083 c 0,-2.96986 0.41494,-7.94091 6.21632,-7.94091 3.79746,0 6.07688,2.07004 6.28576,6.55898 h 11.05016 c 0,-9.80545 -6.83726,-15.67572 -16.43893,-15.67572 -4.90383,0 -9.4594,0.48209 -13.32963,4.00403 -5.2465,4.83442 -5.2465,11.25904 -5.2465,15.74799 v 13.74174 z' id='path7' inkscape:connector-curvature='0' style='fill:%23ffffff;fill-rule:nonzero;stroke-width:1.29737616' /%3E%3Cpath d='m -397.02371,227.62821 h 35.63661 v -9.46223 h -24.44701 v -11.94776 h 15.67572 v -9.25334 h -15.81516 v -10.77416 h 22.99847 v -9.25335 h -34.04868 v 50.69104 z m 99.01173,-42.61054 c -4.14572,-6.07971 -9.39223,-9.11673 -16.85159,-9.11673 -10.42866,0 -16.50555,6.00744 -16.50555,14.36324 0,10.01655 6.62843,13.39907 14.29385,16.36948 7.59825,2.96986 9.67111,3.79743 9.67111,7.59769 0,4.62556 -4.35233,5.73144 -6.76842,5.73144 -4.35177,0 -7.73708,-2.62438 -9.60112,-6.9067 l -8.63185,5.73143 c 4.55838,8.14975 9.80773,10.30449 18.71558,10.30449 2.55495,0 6.76787,-0.76095 9.73772,-2.56737 7.18331,-4.35177 7.18331,-11.1196 7.18331,-13.39907 0,-4.76442 -2.21003,-8.08031 -2.83099,-8.91013 -2.00342,-2.76156 -5.59482,-4.83442 -8.63468,-5.93804 l -6.42237,-2.34891 c -3.10704,-1.10587 -6.42238,-2.55495 -6.42238,-6.14632 0,-0.55209 0.13661,-4.90386 5.94027,-4.90386 3.9346,0 7.18048,2.62439 8.76846,5.66422 l 8.35863,-5.52483 z m 63.51163,0 c -4.14516,-6.07971 -9.39223,-9.11673 -16.85104,-9.11673 -10.42922,0 -16.5061,6.00744 -16.5061,14.36324 0,10.01655 6.62899,13.39907 14.29385,16.36948 7.59824,2.96986 9.67111,3.79743 9.67111,7.59769 0,4.62556 -4.35233,5.73144 -6.76787,5.73144 -4.35233,0 -7.73708,-2.62438 -9.60167,-6.9067 l -8.63185,5.73143 c 4.55838,8.14975 9.80772,10.30449 18.71557,10.30449 2.55495,0 6.76787,-0.76095 9.73829,-2.56737 7.18275,-4.35177 7.18275,-11.1196 7.18275,-13.39907 0,-4.76442 -2.20947,-8.08031 -2.83099,-8.91013 -2.00343,-2.76156 -5.59483,-4.83442 -8.63468,-5.93804 l -6.42238,-2.34891 c -3.10703,-1.10587 -6.42237,-2.55495 -6.42237,-6.14632 0,-0.55209 0.13661,-4.90386 5.94027,-4.90386 3.9346,0 7.18048,2.62439 8.76902,5.66422 l 8.35807,-5.52483 z m 31.87984,42.61054 h 35.63661 v -9.46223 h -24.44701 v -11.94776 h 15.67572 v -9.25334 h -15.81516 v -10.77416 h 22.99791 v -9.25335 h -34.04812 v 50.69104 z m 67.93341,0 h 10.22033 v -23.7583 c 0,-1.31021 -0.27604,-7.73486 -0.34548,-9.1839 h 0.34548 c 2.62438,6.14632 2.69382,6.35293 3.79743,8.3558 l 13.46907,24.58645 h 9.116738 v -50.69104 h -10.222608 v 18.85219 c 0,1.93343 0,2.3489 0.2083,5.80365 l 0.27604,5.10989 h -0.34547 c -0.20887,-0.34548 -0.897,-2.20947 -1.10587,-2.62494 -0.48209,-1.03644 -1.17304,-2.41778 -1.72738,-3.45421 l -13.05136,-23.68663 h -10.63527 v 50.69104 z' id='path9' inkscape:connector-curvature='0' style='fill:%23ffffff;fill-rule:nonzero;stroke-width:1.29737616' /%3E%3C/g%3E%3Cpath inkscape:connector-curvature='0' style='fill:%23ffffff;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:0.94566709' id='path44' d='m 57.849497,14.92373 v 118.42303 l 8.333397,-0.0127 V 14.923159 h -8.333397 z' /%3E%3Cpath inkscape:connector-curvature='0' style='fill:none;stroke:%23000000;stroke-width:0.53388023;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:3.86400008;stroke-dasharray:none;stroke-opacity:1' id='path48' d='m 57.849497,14.92373 v 118.42303 l 8.333397,-0.0127 V 14.923159 h -8.333397 z' /%3E%3Cpath inkscape:connector-curvature='0' style='fill:%23ffffff;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:0.94566709' id='path52' d='M 13.340586,37.253319 0.2644434,50.29467 V 68.102403 H 26.614851 V 50.29467 Z M 0.2644434,80.614155 V 98.421888 L 13.340586,111.39704 26.614851,98.355688 V 80.614155 Z' /%3E%3Cpath inkscape:connector-curvature='0' style='fill:%23fffcfd;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:0.94566709' id='path68' d='M 109.56251,37.253319 96.420323,50.22847 V 68.102403 H 122.77073 V 50.36087 Z M 96.420323,80.614155 V 98.421888 L 109.56251,111.39704 122.77073,98.355688 V 80.614155 Z' /%3E%3Cpath inkscape:connector-curvature='0' style='fill:%23fefefe;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:0.94566709' id='path84' d='m 35.002074,106.82926 -13.010102,13.17375 13.010102,13.23995 h 17.699027 v -26.4137 z m 36.190541,0 v 26.4137 H 89.023718 L 101.96778,120.06921 88.957676,106.82926 Z' /%3E%3Cpath inkscape:connector-curvature='0' style='fill:%23fffffa;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:0.94566709' id='path100' d='m 35.002074,15.076403 -13.010102,13.10755 13.010102,13.30615 h 17.699027 v -26.4137 z m 36.190541,0 v 26.3475 H 89.023718 L 101.96778,28.316353 88.957676,15.076403 Z' /%3E%3Cpath inkscape:connector-curvature='0' style='fill:none;stroke:%23000000;stroke-width:0.53388023;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:3.86400008;stroke-dasharray:none;stroke-opacity:1' id='path112' d='M 52.720437,15.060303 V 41.474342 H 35.011957 L 21.997076,28.215729 35.011957,15.060303 Z M 71.221652,41.436105 V 15.064561 H 88.930119 L 101.945,28.323195 88.99673,41.442185 71.221652,41.43583 Z m 0,91.817145 v -26.4201 h 17.708467 l 13.014881,13.2647 -12.94827,13.14932 -17.775078,0.006 z M 96.442915,80.605851 H 122.78153 V 98.344715 L 109.53047,111.39085 96.442915,98.423647 Z m 0,-12.51798 H 122.78153 V 50.330789 L 109.53047,37.28465 96.442915,50.257937 Z M 52.720437,106.83364 V 133.2416 H 35.011957 L 21.997076,119.98299 35.011957,106.83364 Z M 0.26662011,80.605851 26.599193,80.593141 V 98.344143 L 13.372344,111.3903 0.26662011,98.423075 V 80.605279 Z m 0,-12.51798 26.33257289,-0.0064 V 50.294077 L 13.372344,37.284375 0.26662011,50.294077 v 17.793518 z' /%3E%3Cpath inkscape:connector-curvature='0' style='fill:%23000000;fill-opacity:1;fill-rule:evenodd;stroke:none;stroke-width:0.94566709' id='path124' d='m 75.903661,9.8260743 2.095458,1.2627307 c 0.635918,0.51602 1.25364,1.43269 1.25364,1.43269 L 78.89544,11.076646 80.37922,10.955262 C 79.979507,10.840021 79.761498,10.754862 79.386004,10.578866 78.750107,10.281402 78.374613,10.099283 77.865896,9.607541 77.405615,9.1582936 77.28448,9.1643734 76.927161,8.25982 l -0.224075,1.1109695 -0.799425,0.455306 z' /%3E%3Cpath inkscape:connector-curvature='0' style='fill:%23ffffff;fill-opacity:1;stroke:%23000000;stroke-width:0.37669724;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:3.86400008;stroke-dasharray:none;stroke-opacity:1' id='path132' d='M 70.796368,0.44625824 C 69.212036,0.47866964 67.440211,1.1445014 65.975366,1.042056 57.981115,0.46532377 50.760844,4.2672443 47.417804,11.965015 c -3.851776,8.845155 1.564706,17.819807 8.057024,23.368511 0.635896,0.540296 1.350218,1.048499 2.113316,1.588794 l 0.198017,-9.069365 c -2.440668,-2.537601 -4.088505,-5.485852 -4.094549,-9.267965 -0.01268,-2.489026 0.802553,-5.521716 3.103932,-7.94397 2.19842,-2.306908 6.300408,-3.5814385 7.396606,-3.508587 2.561783,0.1578202 1.997358,1.3572326 2.905809,2.383191 0.399713,0.455306 1.855767,0.649287 3.169974,0.728197 2.870665,0.163964 7.220968,-0.125832 7.396606,-0.198493 C 77.834027,9.9785986 75.315905,3.2672573 73.371866,1.3731607 72.633748,0.65833046 71.746853,0.42691732 70.796262,0.44636416 Z M 65.909325,34.208131 V 42.4169 c 3.851772,2.798629 5.955535,5.97181 5.28329,9.929962 C 69.406017,62.897916 46.995319,65.771367 46.55927,79.885958 46.371523,86.151018 49.078518,90.97216 57.654185,97.82609 L 57.852202,87.631329 C 54.484929,85.008739 52.437084,82.061632 54.484105,78.230964 57.796876,72.026618 79.297118,63.240778 78.655156,50.625669 78.243334,42.502949 72.365167,38.585173 65.909219,34.208131 Z m 0.198018,60.043173 0.198017,9.996166 c 2.101503,1.54805 3.28589,2.42998 3.764344,5.36218 0.932649,5.75512 -5.558655,8.54262 -9.113675,10.98915 -3.936579,2.71364 -13.737191,7.79037 -9.509921,16.48374 2.416429,4.972 6.598617,5.61658 6.538071,5.42838 -0.399713,-1.26879 -3.687927,-3.35646 -3.50018,-8.40737 0.254359,-6.82357 15.76185,-10.61816 19.680255,-18.00633 1.071958,-2.02158 6.55671,-11.6834 -8.057017,-21.845916 z' /%3E%3Cpath inkscape:connector-curvature='0' style='fill:%23ffffff;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:0.94566709' id='path272' d='m 1018.8932,97.637109 v -22.26769 c 0,-3.569617 -0.9811,-5.74296 -4.2636,-5.74296 -4.5422,0 -8.1093,5.111595 -8.1093,11.206675 v 16.803975 h -8.87242 V 69.69323 c -1.6715,-0.279246 -4.05163,-0.558514 -6.06834,-0.698137 v -5.597279 c 4.39684,-0.564572 9.77476,-0.777068 14.46226,-0.637424 0,1.687681 -0.1392,4.413458 -0.4966,6.301475 h 0.073 c 2.1016,-4.06136 6.1471,-6.93284 11.8037,-6.93284 7.8246,0 10.338,4.978051 10.338,11.067051 v 24.441033 h -8.8664 z M 971.25174,68.646024 c -3.70641,0 -6.28639,2.731858 -6.77694,7.072464 h 12.7787 c 0.14539,-4.48023 -2.22871,-7.072464 -6.00176,-7.072464 m 14.59556,13.094714 h -21.51178 c -0.0727,6.441098 3.14924,9.591845 9.56886,9.591845 3.28248,0 6.77694,-0.698137 10.05338,-2.100491 l 0.98111,6.793217 c -3.76699,1.541978 -8.30918,2.312966 -12.57278,2.312966 -10.96181,0 -17.10889,-5.536565 -17.10889,-17.787417 0,-10.642124 5.86848,-18.485576 16.27312,-18.485576 10.12606,0 14.60162,6.926782 14.60162,15.541223 0,1.195959 -0.0786,2.592234 -0.28464,4.134233 M 933.11129,98.33586 c -2.72531,0 -5.51723,-0.279267 -7.752,-0.910633 l 0.62379,-7.491354 c 2.10152,0.910612 4.82079,1.396274 7.40679,1.396274 3.35517,0 5.58993,-1.469126 5.58993,-3.70924 0,-6.234725 -14.11107,-2.592234 -14.11107,-14.424216 0,-6.161873 4.67543,-11.127765 14.66218,-11.127765 2.03492,0 4.40291,0.273166 6.36512,0.692057 l -0.41786,7.005713 c -1.89563,-0.558514 -4.12431,-0.910633 -6.29247,-0.910633 -3.49445,0 -5.09934,1.402354 -5.09934,3.569639 0,5.882605 14.31697,2.944332 14.31697,14.351364 0,6.932841 -6.07443,11.558794 -15.29204,11.558794 m -30.87717,0 c -2.73137,0 -5.51723,-0.279267 -7.75804,-0.910633 l 0.62983,-7.491354 c 2.10152,0.910612 4.82683,1.396274 7.40679,1.396274 3.35516,0 5.58387,-1.469126 5.58387,-3.70924 0,-6.234725 -14.10501,-2.592234 -14.10501,-14.424216 0,-6.161873 4.67543,-11.127765 14.66825,-11.127765 2.02884,0 4.39683,0.273166 6.35905,0.692057 l -0.43,7.005713 c -1.87743,-0.558514 -4.11217,-0.910633 -6.28033,-0.910633 -3.48839,0 -5.09935,1.402354 -5.09935,3.569639 0,5.882605 14.32302,2.944332 14.32302,14.351364 0,6.932841 -6.07441,11.558794 -15.29808,11.558794 M 860.24976,97.637109 V 50.369894 h 25.63611 v 7.630978 h -16.55172 v 11.625587 h 15.71594 v 7.424582 h -15.71594 v 12.809366 h 16.55172 v 7.776702 z m -37.37371,0 V 75.648687 c 0,-3.715342 -0.83576,-6.022228 -4.11824,-6.022228 -3.9063,0 -7.95793,4.553081 -7.95793,11.346319 v 16.664331 h -8.81185 V 75.575836 c 0,-3.429995 -0.69646,-5.949377 -4.11217,-5.949377 -4.13037,0 -7.96397,4.832348 -7.96397,11.346319 v 16.664331 h -8.87846 V 69.69323 c -1.67153,-0.279246 -4.05165,-0.558514 -6.07443,-0.698137 v -5.597279 c 4.4029,-0.564572 9.84746,-0.777068 14.45626,-0.637424 0,1.687681 -0.13314,4.273835 -0.41182,6.301475 l 0.0727,0.07287 c 2.08941,-4.267777 6.28033,-7.005692 11.45237,-7.005692 6.14102,0 8.72705,3.575697 9.56886,6.93284 1.60492,-3.357143 5.45063,-6.93284 11.31309,-6.93284 6.71033,0 10.41068,3.71532 10.41068,11.558794 v 23.94929 h -8.94507 z m -65.80236,0.06737 c 0,-1.608771 0.0788,-4.267776 0.41788,-6.301496 h -0.13926 c -2.02279,4.061381 -6.08048,6.932861 -11.73096,6.932861 -7.89733,0 -10.41068,-4.971993 -10.41068,-11.067073 V 69.693824 c -1.67153,-0.279268 -3.97895,-0.558515 -6.01386,-0.698138 v -5.597279 c 4.62091,-0.564593 10.13817,-0.777068 14.95287,-0.637445 v 22.340541 c 0,3.569618 0.98113,5.742961 4.26362,5.742961 4.54219,0 8.10325,-5.111596 8.10325,-11.200617 V 62.833814 h 8.8724 v 27.937819 c 1.67153,0.279247 4.05165,0.558493 6.07443,0.704196 v 5.597279 c -4.4029,0.564594 -9.78085,0.770989 -14.38965,0.631366 m -41.56288,-0.06737 -10.75589,-17.228925 v 17.228925 h -8.9451 V 53.380998 c -1.67757,-0.279247 -4.04556,-0.558514 -6.07441,-0.704217 v -5.597258 c 4.47556,-0.558514 9.84746,-0.77101 15.01951,-0.631366 V 77.330288 L 714.881,62.833242 h 10.8952 l -12.22152,15.893341 13.12995,18.910526 z M 678.55684,57.652417 c -3.00391,0 -5.5233,-2.385817 -5.5233,-5.396942 0,-3.005045 2.51939,-5.451576 5.5233,-5.451576 3.08263,0 5.58991,2.373679 5.58991,5.451576 0,2.944332 -2.50728,5.396942 -5.58991,5.396942 m -4.40291,39.982256 V 69.696874 c -1.66546,-0.279268 -4.05163,-0.564594 -6.07441,-0.704217 v -5.597279 c 4.40895,-0.564573 9.78085,-0.770989 14.94683,-0.631365 v 34.87066 z m -22.63038,0.0021 v -22.26765 c 0,-3.569639 -0.97506,-5.742982 -4.25755,-5.742982 -4.54823,0 -8.10325,5.111616 -8.10325,11.206696 v 16.803954 h -8.87847 V 69.692913 c -1.67152,-0.279247 -4.05162,-0.558514 -6.07441,-0.698138 v -5.597279 c 4.40289,-0.564572 9.7869,-0.777047 14.46231,-0.637424 0,1.687681 -0.14539,4.413458 -0.49054,6.301475 h 0.0727 c 2.09546,-4.06136 6.14102,-6.93284 11.80363,-6.93284 7.81861,0 10.33196,4.978051 10.33196,11.067073 v 24.441011 h -8.86636 z M 612.12703,57.652417 c -3.00391,0 -5.51723,-2.385817 -5.51723,-5.396942 0,-3.005045 2.51332,-5.451576 5.51723,-5.451576 3.07052,0 5.58991,2.373679 5.58991,5.451576 0,2.944332 -2.51939,5.396942 -5.58991,5.396942 m -4.4029,39.982256 V 69.696874 c -1.67757,-0.279268 -4.05163,-0.564594 -6.07441,-0.704217 v -5.597279 c 4.39684,-0.564573 9.77478,-0.770989 14.94683,-0.631365 v 34.87066 z m -22.62795,0.0021 V 53.38068 c -1.68364,-0.279247 -4.05163,-0.558493 -6.08047,-0.704196 v -5.597279 c 4.46951,-0.558514 9.84746,-0.770989 15.0195,-0.631365 v 51.188951 z m -18.87066,0 -10.74985,-17.228925 v 17.228925 h -8.94508 V 53.38068 c -1.67152,-0.279247 -4.05162,-0.558493 -6.07443,-0.704196 v -5.597279 c 4.46952,-0.558514 9.84749,-0.770989 15.01951,-0.631365 v 30.882151 l 10.12606,-14.497067 h 10.89518 l -12.2215,15.893342 13.13599,18.910525 z m -44.63275,0.698752 c -2.72531,0 -5.51723,-0.279247 -7.752,-0.910612 l 0.62985,-7.491376 c 2.09546,0.910633 4.81473,1.396296 7.40073,1.396296 3.35516,0 5.58993,-1.469147 5.58993,-3.709262 0,-6.234703 -14.10501,-2.592234 -14.10501,-14.424216 0,-6.161852 4.67541,-11.127765 14.66823,-11.127765 2.0228,0 4.39684,0.273188 6.35301,0.692079 l -0.41787,7.005691 c -1.88349,-0.558514 -4.1243,-0.910633 -6.2864,-0.910633 -3.49445,0 -5.09936,1.402355 -5.09936,3.569639 0,5.882605 14.31697,2.944332 14.31697,14.351364 0,6.932841 -6.07441,11.558795 -15.29808,11.558795 m -22.55893,0 c -7.69143,0 -10.05942,-2.798629 -10.05942,-10.92137 V 69.766378 h -6.0078 v -6.932861 h 6.0078 V 52.124643 l 8.87239,-2.385818 v 13.094692 h 8.44847 v 6.932861 h -8.44847 v 15.261977 c 0,4.48633 1.04774,5.742982 4.11826,5.742982 1.47167,0 2.79799,-0.139602 3.985,-0.491743 l 0.62381,7.078544 c -2.23477,0.558514 -5.09331,0.977405 -7.54004,0.977405 M 467.6661,57.092378 c -2.65263,0 -4.82076,-2.173343 -4.82076,-4.832349 0,-2.731857 2.16813,-4.83237 4.82076,-4.83237 2.65264,0 4.82077,2.100513 4.82077,4.83237 0,2.659006 -2.16813,4.832349 -4.82077,4.832349 m -2.51334,24.926695 c -9.07832,0 -11.52503,2.45259 -11.52503,5.463714 0,2.306908 1.53221,3.988509 4.11824,3.988509 4.39684,0 7.40679,-4.200983 7.40679,-8.401988 z M 453.55505,57.092378 c -2.65265,0 -4.82079,-2.173343 -4.82079,-4.832349 0,-2.731857 2.16814,-4.83237 4.82079,-4.83237 2.65263,0 4.82077,2.100513 4.82077,4.83237 0,2.659006 -2.16814,4.832349 -4.82077,4.832349 m 12.29417,40.613621 c 0,-2.03372 0.0727,-4.134212 0.35128,-5.955457 l -0.0727,-0.06673 c -1.67153,3.921737 -5.93512,6.653594 -11.10716,6.653594 -6.2864,0 -9.91408,-3.854944 -9.91408,-9.458303 0,-8.329115 8.24255,-12.669742 20.04618,-12.669742 V 74.52776 c 0,-3.64249 -1.75025,-5.536566 -6.77694,-5.536566 -3.1432,0 -7.33412,1.056315 -10.12606,2.525441 l -1.05378,-7.351731 c 3.56713,-1.189879 8.17593,-2.100491 12.43954,-2.100491 11.31914,0 14.45627,4.480229 14.45627,12.117308 V 90.7732 c 1.67757,0.279268 4.05163,0.558514 6.08047,0.698137 v 5.603359 c -4.4029,0.564572 -9.78085,0.770989 -14.32304,0.631365 m -34.8549,0.629523 c -7.68539,0 -10.05942,-2.798629 -10.05942,-10.92137 V 69.766421 h -6.0078 v -6.932862 h 6.0078 V 52.124685 l 8.8724,-2.385818 v 13.094692 h 8.45453 v 6.932862 h -8.45453 v 15.261976 c 0,4.486331 1.04774,5.742982 4.1243,5.742982 1.45956,0 2.78588,-0.139602 3.97895,-0.491742 l 0.62985,7.078543 c -2.23474,0.558514 -5.10541,0.977405 -7.54608,0.977405 M 403.46925,57.652142 c -3.00391,0 -5.5233,-2.385818 -5.5233,-5.396943 0,-3.005045 2.51939,-5.451575 5.5233,-5.451575 3.07657,0 5.58991,2.373679 5.58991,5.451575 0,2.944332 -2.51334,5.396943 -5.58991,5.396943 m -4.39684,39.982276 V 69.696599 c -1.67757,-0.279247 -4.05162,-0.564573 -6.08047,-0.704217 v -5.597258 c 4.4029,-0.564594 9.78085,-0.770989 14.94683,-0.631366 v 34.87066 z m -26.90003,0.701167 c -2.72532,0 -5.51724,-0.279246 -7.75201,-0.910612 l 0.62986,-7.491376 c 2.09545,0.910634 4.82077,1.396296 7.40679,1.396296 3.3491,0 5.58386,-1.469147 5.58386,-3.709262 0,-6.234703 -14.11107,-2.592234 -14.11107,-14.424216 0,-6.161851 4.68148,-11.127765 14.67429,-11.127765 2.02281,0 4.39684,0.273188 6.35301,0.692079 l -0.41786,7.005692 c -1.8835,-0.558514 -4.12431,-0.910633 -6.2864,-0.910633 -3.49445,0 -5.09937,1.402354 -5.09937,3.569638 0,5.882606 14.31698,2.944332 14.31698,14.351365 0,6.93284 -6.07441,11.558794 -15.29808,11.558794 M 357.92685,70.958122 c -6.63765,-1.402354 -9.85352,2.798629 -9.85352,12.463348 v 14.217799 h -8.8724 V 69.695391 c -1.67153,-0.279267 -4.05163,-0.558514 -6.07441,-0.698137 v -5.603359 c 4.40288,-0.558514 9.78083,-0.770989 14.46231,-0.631365 0,1.821245 -0.21197,4.625953 -0.62986,7.072484 h 0.13927 c 1.67153,-4.407399 5.02667,-8.262343 11.24646,-7.703829 l -0.41789,8.826937 z m -45.12874,-2.312373 c -3.70037,0 -6.2864,2.731857 -6.77694,7.072485 h 12.78474 c 0.13927,-4.480251 -2.23475,-7.072485 -6.0078,-7.072485 m 14.59555,13.094713 h -21.51178 c -0.0727,6.441119 3.14924,9.591846 9.57493,9.591846 3.27642,0 6.77087,-0.698137 10.05943,-2.100491 l 0.97506,6.793217 c -3.77305,1.541998 -8.31524,2.312987 -12.57884,2.312987 -10.96181,0 -17.1089,-5.536566 -17.1089,-17.787438 0,-10.642103 5.86245,-18.485576 16.27313,-18.485576 10.12606,0 14.60162,6.926781 14.60162,15.541244 0,1.195938 -0.0727,2.592234 -0.28465,4.134211 m -47.21693,15.896371 h -9.08438 L 258.241,62.832966 h 9.78085 l 5.51723,15.686926 c 0.84182,2.452611 1.6776,5.25124 2.30743,7.70385 h 0.13926 c 0.55718,-2.379759 1.25364,-5.044823 2.09546,-7.424582 l 5.58387,-15.966194 h 9.50225 L 280.17669,97.636833 Z M 246.99575,57.652417 c -3.00391,0 -5.5233,-2.385817 -5.5233,-5.396942 0,-3.005045 2.51939,-5.451576 5.5233,-5.451576 3.07052,0 5.58387,2.373679 5.58387,5.451576 0,2.944332 -2.51335,5.396942 -5.58387,5.396942 m -4.4029,39.982256 V 69.696874 c -1.67151,-0.279268 -4.05163,-0.564594 -6.07441,-0.704217 v -5.597279 c 4.4029,-0.564573 9.78085,-0.770989 14.94683,-0.631365 v 34.87066 z m -22.6322,0.0021 v -22.26765 c 0,-3.569639 -0.97506,-5.742982 -4.26359,-5.742982 -4.53613,0 -8.09722,5.111616 -8.09722,11.206696 v 16.803954 h -8.87241 V 69.692913 c -1.67758,-0.279247 -4.05768,-0.558514 -6.08048,-0.698138 v -5.597279 c 4.4029,-0.564572 9.78085,-0.777047 14.46233,-0.637424 0,1.687681 -0.13927,4.413458 -0.49056,6.301475 h 0.0727 c 2.08942,-4.06136 6.14105,-6.93284 11.80366,-6.93284 7.82465,0 10.338,4.978051 10.338,11.067073 v 24.441011 h -8.8724 z m -54.55772,0.769273 c -14.88022,0 -18.22932,-8.12272 -18.22932,-17.156073 V 50.36786 h 9.08437 v 30.323617 c 0,5.949377 1.95012,10.150381 9.77478,10.150381 6.98892,0 9.92014,-2.944332 9.92014,-10.994221 V 50.36786 h 9.0117 v 28.921262 c 0,12.882239 -7.12821,19.116942 -19.56167,19.116942' /%3E%3C/svg%3E"); -} + margin: auto; + height: 60px; + width: 100%; + background-repeat: no-repeat; + background-size: 50%; + background-position: center; + background-image: url("data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 1653.11 425.2"><defs><style>.cls-1{fill:none;}.cls-2{clip-path:url(#clip-path);}.cls-3{clip-path:url(#clip-path-2);}.cls-4{clip-path:url(#clip-path-3);}.cls-5{fill:#575756;}</style><clipPath id="clip-path"><path class="cls-1" d="M189.1,289.71v48.48a127.58,127.58,0,0,1-45.43-232.74c2,16.08,8.92,30.5,20.68,43A80.42,80.42,0,0,0,189.1,289.71ZM236.29,87.44v48.5a80.42,80.42,0,0,1,20.28,144.18c5.46,8,9,17.1,9.06,27.69a47.67,47.67,0,0,1-5.83,23.52A127.59,127.59,0,0,0,236.29,87.44Z"/></clipPath><clipPath id="clip-path-2"><circle class="cls-1" cx="212.6" cy="212.8" r="127.56"/></clipPath><clipPath id="clip-path-3"><rect class="cls-1" x="80.04" y="80.24" width="265.12" height="265.12"/></clipPath></defs><g id="Text_RGB_Passer" data-name="Text RGB Passer"><path d="M480.27,129v42a24.19,24.19,0,0,1-3.22,12.61,20.91,20.91,0,0,1-9.31,8.31,33.24,33.24,0,0,1-14.4,2.89q-12.52,0-19.46-6.42T427,170.85V129h13.73v39.77q0,7.52,3,11t10,3.51q6.75,0,9.8-3.53t3-11.09V129Z"/><path d="M538.52,194H525v-29c0-3.59-.64-6.27-1.91-8.07s-3.31-2.68-6.09-2.68q-5.69,0-8.22,3.79t-2.54,12.6V194H492.66V144.28H503l1.82,6.35h.75a14.28,14.28,0,0,1,6.25-5.44,21.23,21.23,0,0,1,9-1.85q8.65,0,13.15,4.69t4.49,13.53Z"/><path d="M549.35,131.44q0-6.63,7.38-6.63t7.38,6.63a6.44,6.44,0,0,1-1.85,4.9c-1.23,1.18-3.07,1.76-5.53,1.76Q549.35,138.1,549.35,131.44ZM563.48,194H549.93V144.28h13.55Z"/><path d="M588.35,194l-18.93-49.67h14.17l9.6,28.3a50.6,50.6,0,0,1,2,10.18h.27a44.05,44.05,0,0,1,2-10.18l9.55-28.3h14.17L602.26,194Z"/><path d="M647.87,194.84q-12,0-18.75-6.62t-6.75-18.75q0-12.48,6.24-19.31t17.27-6.82q10.53,0,16.39,6t5.87,16.58v6.57h-32q.23,5.77,3.42,9t9,3.25a37.29,37.29,0,0,0,8.48-.94,42.57,42.57,0,0,0,8.36-3v10.48a31.82,31.82,0,0,1-7.6,2.65A48.59,48.59,0,0,1,647.87,194.84ZM646,153a8.6,8.6,0,0,0-6.75,2.73c-1.63,1.82-2.56,4.41-2.8,7.75h19c-.06-3.34-.93-5.93-2.62-7.75A8.89,8.89,0,0,0,646,153Z"/><path d="M705.33,143.34a22.25,22.25,0,0,1,4.57.4l-1,12.71a15.85,15.85,0,0,0-4-.44q-6.48,0-10.11,3.33t-3.62,9.33V194H677.6V144.28h10.26l2,8.35h.67a18.68,18.68,0,0,1,6.24-6.73A15.44,15.44,0,0,1,705.33,143.34Z"/><path d="M752.56,179.2q0,7.65-5.31,11.64t-15.88,4a49.69,49.69,0,0,1-9.24-.73A34.89,34.89,0,0,1,715,192V180.76a47.85,47.85,0,0,0,8.51,3,34.4,34.4,0,0,0,8.33,1.2q7.38,0,7.38-4.26a3.55,3.55,0,0,0-1-2.6,14.22,14.22,0,0,0-3.38-2.27c-1.6-.84-3.73-1.83-6.4-3A40.06,40.06,0,0,1,720,168.4a12.56,12.56,0,0,1-3.91-4.68,15.6,15.6,0,0,1-1.22-6.51A11.82,11.82,0,0,1,720,147q5.15-3.61,14.56-3.62A41.42,41.42,0,0,1,752,147.25L747.94,157a73.24,73.24,0,0,0-7-2.62,22,22,0,0,0-6.62-1c-4,0-6,1.09-6,3.25a3.82,3.82,0,0,0,1.94,3.15,52.66,52.66,0,0,0,8.46,4,39.27,39.27,0,0,1,8.53,4.4,13,13,0,0,1,4,4.71A14.45,14.45,0,0,1,752.56,179.2Z"/><path d="M760.82,131.44q0-6.63,7.38-6.63t7.37,6.63a6.43,6.43,0,0,1-1.84,4.9c-1.23,1.18-3.07,1.76-5.53,1.76Q760.82,138.1,760.82,131.44ZM775,194H761.4V144.28H775Z"/><path d="M807.82,184a29.19,29.19,0,0,0,8.53-1.55v10.09a30.4,30.4,0,0,1-12.44,2.26q-8.13,0-11.84-4.11t-3.71-12.33v-24h-6.49v-5.73l7.47-4.53,3.91-10.49h8.66v10.58h13.91v10.17H801.91v24a5.3,5.3,0,0,0,1.62,4.27A6.4,6.4,0,0,0,807.82,184Z"/><path d="M820.08,144.28h14.84l9.37,27.94a39,39,0,0,1,1.65,8.63h.27a37.7,37.7,0,0,1,1.91-8.63l9.19-27.94h14.53l-21,56q-2.9,7.77-8.25,11.64a20.78,20.78,0,0,1-12.5,3.86,31.69,31.69,0,0,1-6.89-.75V204.31a23.42,23.42,0,0,0,5.33.57,9.61,9.61,0,0,0,6.29-2.2A14.27,14.27,0,0,0,839,196l.8-2.44Z"/><path d="M931.16,194l-15.64-51h-.4q.84,15.56.85,20.75V194H903.66V129h18.75l15.37,49.68h.27L954.36,129h18.75v65H960.27V163.21c0-1.46,0-3.13.06-5s.25-6.93.6-15.1h-.4L943.78,194Z"/><path d="M1009,194.84q-12,0-18.75-6.62t-6.75-18.75q0-12.48,6.24-19.31t17.27-6.82q10.53,0,16.39,6t5.87,16.58v6.57h-32q.22,5.77,3.42,9t9,3.25a37.29,37.29,0,0,0,8.48-.94,42.57,42.57,0,0,0,8.36-3v10.48a31.82,31.82,0,0,1-7.6,2.65A48.59,48.59,0,0,1,1009,194.84ZM1007.06,153a8.6,8.6,0,0,0-6.75,2.73c-1.63,1.82-2.56,4.41-2.8,7.75h19c-.06-3.34-.94-5.93-2.62-7.75A8.89,8.89,0,0,0,1007.06,153Z"/><path d="M1055,194.84a16.12,16.12,0,0,1-13.75-6.8q-5-6.79-5-18.84,0-12.21,5.09-19a16.55,16.55,0,0,1,14-6.82q9.38,0,14.31,7.29h.44a55.43,55.43,0,0,1-1-9.91V124.81h13.6V194h-10.4l-2.62-6.44h-.58Q1064.44,194.85,1055,194.84Zm4.76-10.8c3.46,0,6-1,7.62-3s2.49-5.43,2.64-10.26v-1.47q0-8-2.46-11.46t-8-3.47a8,8,0,0,0-7,3.85q-2.51,3.84-2.51,11.17t2.54,11A8.26,8.26,0,0,0,1059.73,184Z"/><path d="M1093.88,131.44q0-6.63,7.37-6.63t7.38,6.63a6.43,6.43,0,0,1-1.84,4.9c-1.23,1.18-3.08,1.76-5.54,1.76Q1093.88,138.1,1093.88,131.44ZM1108,194h-13.55V144.28H1108Z"/><path d="M1140.35,194.84q-23.19,0-23.19-25.46,0-12.66,6.31-19.35t18.08-6.69a34.47,34.47,0,0,1,15.46,3.38l-4,10.49c-2.13-.86-4.11-1.57-6-2.11a19.13,19.13,0,0,0-5.51-.83q-10.58,0-10.57,15,0,14.58,10.57,14.58a24,24,0,0,0,7.24-1.05,25.83,25.83,0,0,0,6.67-3.26v11.59a21.61,21.61,0,0,1-6.64,2.89A37,37,0,0,1,1140.35,194.84Z"/><path d="M1164.2,131.44q0-6.63,7.37-6.63t7.38,6.63a6.43,6.43,0,0,1-1.84,4.9c-1.23,1.18-3.08,1.76-5.54,1.76Q1164.21,138.1,1164.2,131.44ZM1178.33,194h-13.55V144.28h13.55Z"/><path d="M1236,194h-13.56v-29c0-3.59-.63-6.27-1.91-8.07s-3.3-2.68-6.08-2.68c-3.8,0-6.53,1.26-8.22,3.79s-2.54,6.74-2.54,12.6V194h-13.55V144.28h10.36l1.82,6.35h.75a14.31,14.31,0,0,1,6.24-5.44,21.3,21.3,0,0,1,9.05-1.85q8.65,0,13.15,4.69t4.49,13.53Z"/><path d="M1270.43,194.84q-12,0-18.75-6.62t-6.75-18.75q0-12.48,6.24-19.31t17.26-6.82q10.53,0,16.4,6t5.87,16.58v6.57h-32q.22,5.77,3.42,9t9,3.25a37.29,37.29,0,0,0,8.48-.94,42.57,42.57,0,0,0,8.36-3v10.48a31.82,31.82,0,0,1-7.6,2.65A48.59,48.59,0,0,1,1270.43,194.84ZM1268.52,153a8.6,8.6,0,0,0-6.75,2.73c-1.63,1.82-2.56,4.41-2.8,7.75h19c-.06-3.34-.94-5.93-2.62-7.75A8.89,8.89,0,0,0,1268.52,153Z"/><path d="M1363.83,194h-37.41V129h37.41v11.29h-23.64v14.26h22v11.29h-22v16.75h23.64Z"/><path d="M1410,179.2q0,7.65-5.31,11.64t-15.89,4a49.84,49.84,0,0,1-9.24-.73,34.8,34.8,0,0,1-7.15-2.16V180.76a47.57,47.57,0,0,0,8.51,3,34.4,34.4,0,0,0,8.33,1.2c4.92,0,7.37-1.42,7.37-4.26a3.55,3.55,0,0,0-1-2.6,14.22,14.22,0,0,0-3.38-2.27c-1.6-.84-3.73-1.83-6.4-3a39.81,39.81,0,0,1-8.42-4.45,12.56,12.56,0,0,1-3.91-4.68,15.6,15.6,0,0,1-1.22-6.51,11.82,11.82,0,0,1,5.13-10.25q5.13-3.61,14.55-3.62a41.43,41.43,0,0,1,17.47,3.91l-4.09,9.78a74.26,74.26,0,0,0-7-2.62,22,22,0,0,0-6.62-1c-4,0-6,1.09-6,3.25a3.82,3.82,0,0,0,1.94,3.15,52.22,52.22,0,0,0,8.46,4,39.51,39.51,0,0,1,8.53,4.4,13,13,0,0,1,4,4.71A14.45,14.45,0,0,1,1410,179.2Z"/><path d="M1454.09,179.2q0,7.65-5.31,11.64t-15.89,4a49.84,49.84,0,0,1-9.24-.73,34.8,34.8,0,0,1-7.15-2.16V180.76a47.57,47.57,0,0,0,8.51,3,34.4,34.4,0,0,0,8.33,1.2q7.37,0,7.37-4.26a3.55,3.55,0,0,0-1-2.6,14.22,14.22,0,0,0-3.38-2.27c-1.6-.84-3.73-1.83-6.4-3a39.81,39.81,0,0,1-8.42-4.45,12.56,12.56,0,0,1-3.91-4.68,15.6,15.6,0,0,1-1.22-6.51,11.82,11.82,0,0,1,5.13-10.25q5.13-3.61,14.55-3.62a41.43,41.43,0,0,1,17.47,3.91l-4.09,9.78a74.26,74.26,0,0,0-7-2.62,22,22,0,0,0-6.62-1c-4,0-6,1.09-6,3.25a3.82,3.82,0,0,0,1.94,3.15,52.22,52.22,0,0,0,8.46,4,39.51,39.51,0,0,1,8.53,4.4,13,13,0,0,1,4,4.71A14.45,14.45,0,0,1,1454.09,179.2Z"/><path d="M1485.49,194.84q-12,0-18.75-6.62T1460,169.47q0-12.48,6.24-19.31t17.26-6.82q10.53,0,16.4,6t5.86,16.58v6.57h-32q.21,5.77,3.42,9t9,3.25a37.44,37.44,0,0,0,8.49-.94,42.27,42.27,0,0,0,8.35-3v10.48a31.74,31.74,0,0,1-7.59,2.65A48.59,48.59,0,0,1,1485.49,194.84ZM1483.58,153a8.6,8.6,0,0,0-6.75,2.73,12.6,12.6,0,0,0-2.8,7.75h19c0-3.34-.93-5.93-2.62-7.75A8.88,8.88,0,0,0,1483.58,153Z"/><path d="M1561.07,194h-13.55v-29c0-3.59-.64-6.27-1.91-8.07s-3.3-2.68-6.09-2.68q-5.68,0-8.22,3.79t-2.53,12.6V194h-13.55V144.28h10.35l1.82,6.35h.76a14.31,14.31,0,0,1,6.24-5.44,21.23,21.23,0,0,1,9-1.85q8.67,0,13.15,4.69t4.49,13.53Z"/><path d="M465.73,242.85v33.72q0,8.91-5.38,14t-14.79,5.09q-9.4,0-14.56-5.13t-5.15-14.11V242.85h6.06v34q0,6.52,3.56,10T446,290.36q6.6,0,10.16-3.51t3.56-10.07V242.85Z"/><path d="M506.83,295V269.69c0-3.19-.72-5.56-2.17-7.13s-3.72-2.35-6.81-2.35q-6.14,0-9,3.31T486,274.46V295H480.1V255.89h4.81l1,5.35h.29a12.13,12.13,0,0,1,5.09-4.47,16.57,16.57,0,0,1,7.31-1.59q7.06,0,10.62,3.41t3.57,10.88V295Z"/><path d="M525.86,245.31a4,4,0,0,1,1-3,3.71,3.71,0,0,1,5,0,3.89,3.89,0,0,1,1,3,3.93,3.93,0,0,1-1,3,3.63,3.63,0,0,1-5,0A4,4,0,0,1,525.86,245.31ZM532.28,295h-5.92V255.89h5.92Z"/><path d="M554.84,295,540,255.89h6.35l8.41,23.17a109.83,109.83,0,0,1,3.35,10.55h.29a79.71,79.71,0,0,1,2.47-7.82q2.08-5.94,9.36-25.9h6.34L561.76,295Z"/><path d="M600.82,295.67q-8.66,0-13.67-5.27t-5-14.65q0-9.45,4.65-15a15.49,15.49,0,0,1,12.5-5.56q7.34,0,11.62,4.83t4.28,12.74v3.75H588.27c.12,4.58,1.28,8.07,3.48,10.44s5.29,3.57,9.29,3.57a31.43,31.43,0,0,0,12.47-2.64v5.27a31.49,31.49,0,0,1-5.93,1.95A33.63,33.63,0,0,1,600.82,295.67Zm-1.6-35.53a9.69,9.69,0,0,0-7.51,3.06,14.16,14.16,0,0,0-3.29,8.49h20.42q0-5.6-2.49-8.58A8.8,8.8,0,0,0,599.22,260.14Z"/><path d="M644.56,255.18a22.68,22.68,0,0,1,4.66.43l-.81,5.49a20.06,20.06,0,0,0-4.28-.54,10.43,10.43,0,0,0-8.11,3.85,14,14,0,0,0-3.37,9.59v21h-5.92V255.89h4.89l.67,7.24h.29a17.15,17.15,0,0,1,5.24-5.88A11.78,11.78,0,0,1,644.56,255.18Z"/><path d="M683.19,284.3a9.77,9.77,0,0,1-4.06,8.41q-4.07,3-11.41,3-7.77,0-12.12-2.46v-5.49a28.91,28.91,0,0,0,6,2.25,25,25,0,0,0,6.22.82,14,14,0,0,0,7.12-1.48,5.09,5.09,0,0,0,.52-8.41q-2-1.62-7.72-3.83a42.23,42.23,0,0,1-7.75-3.55,10.66,10.66,0,0,1-3.42-3.44,8.93,8.93,0,0,1-1.12-4.6,8.78,8.78,0,0,1,3.88-7.54q3.89-2.76,10.66-2.76a31.15,31.15,0,0,1,12.33,2.57l-2.1,4.81a28.2,28.2,0,0,0-10.66-2.42,12.23,12.23,0,0,0-6.34,1.32,4.06,4.06,0,0,0-2.14,3.63,4.42,4.42,0,0,0,.8,2.67,8.07,8.07,0,0,0,2.58,2.11,57.32,57.32,0,0,0,6.85,2.88q6.95,2.53,9.39,5.1A9,9,0,0,1,683.19,284.3Z"/><path d="M693.78,245.31a3.91,3.91,0,0,1,1-3,3.46,3.46,0,0,1,2.49-.94,3.49,3.49,0,0,1,2.46,1,3.86,3.86,0,0,1,1,3,3.9,3.9,0,0,1-1,3,3.43,3.43,0,0,1-2.46,1,3.37,3.37,0,0,1-2.49-1A4,4,0,0,1,693.78,245.31ZM700.19,295h-5.91V255.89h5.91Z"/><path d="M726.82,290.79a20,20,0,0,0,3-.23,23.35,23.35,0,0,0,2.32-.48v4.52a10.8,10.8,0,0,1-2.84.77,21.41,21.41,0,0,1-3.37.3q-11.33,0-11.33-11.94V260.49H709v-2.85l5.6-2.46,2.49-8.34h3.43v9h11.33v4.6H720.55v23a7.89,7.89,0,0,0,1.67,5.42A5.84,5.84,0,0,0,726.82,290.79Z"/><path d="M735.23,255.89h6.34l8.56,22.28a84,84,0,0,1,3.49,11h.29c.31-1.22,1-3.29,1.94-6.22s4.21-12,9.68-27.08h6.34l-16.79,44.49q-2.49,6.58-5.82,9.36a12.42,12.42,0,0,1-8.18,2.76,23.48,23.48,0,0,1-5.35-.61v-4.74a20.32,20.32,0,0,0,4.38.43q6.1,0,8.7-6.84l2.17-5.57Z"/><path d="M840.56,295H834.5V270.44H807.05V295H801V242.85h6.06V265H834.5V242.85h6.06Z"/><path d="M889.14,275.39q0,9.56-4.81,14.92T871,295.67a17.61,17.61,0,0,1-9.3-2.46,16.29,16.29,0,0,1-6.28-7,24.69,24.69,0,0,1-2.2-10.77q0-9.56,4.77-14.88t13.26-5.33q8.21,0,13,5.45T889.14,275.39Zm-29.76,0q0,7.49,3,11.41t8.8,3.92q5.82,0,8.83-3.9c2-2.61,3-6.41,3-11.43s-1-8.74-3-11.31-5-3.87-8.9-3.87-6.79,1.27-8.77,3.81S859.38,270.35,859.38,275.39Z"/><path d="M926.17,284.3a9.77,9.77,0,0,1-4.06,8.41q-4.07,3-11.41,3-7.77,0-12.12-2.46v-5.49a28.91,28.91,0,0,0,6,2.25,25,25,0,0,0,6.21.82,14.06,14.06,0,0,0,7.13-1.48,5.09,5.09,0,0,0,.52-8.41q-2-1.62-7.72-3.83a42.23,42.23,0,0,1-7.75-3.55,10.66,10.66,0,0,1-3.42-3.44,8.93,8.93,0,0,1-1.12-4.6,8.78,8.78,0,0,1,3.88-7.54q3.89-2.76,10.66-2.76a31.15,31.15,0,0,1,12.33,2.57l-2.1,4.81a28.2,28.2,0,0,0-10.66-2.42,12.23,12.23,0,0,0-6.34,1.32,4.06,4.06,0,0,0-2.14,3.63,4.42,4.42,0,0,0,.8,2.67,8,8,0,0,0,2.59,2.11,56.22,56.22,0,0,0,6.84,2.88q6.95,2.53,9.39,5.1A9,9,0,0,1,926.17,284.3Z"/><path d="M955.43,295.67a17,17,0,0,1-7-1.4,13.18,13.18,0,0,1-5.3-4.33h-.42a53.27,53.27,0,0,1,.42,6.48V312.5h-5.91V255.89h4.81l.82,5.35h.28a13.71,13.71,0,0,1,5.31-4.63,16.16,16.16,0,0,1,6.95-1.43q7.77,0,12,5.31t4.22,14.9q0,9.63-4.29,14.95T955.43,295.67Zm-.85-35.46q-6,0-8.66,3.31t-2.75,10.55v1.32q0,8.24,2.75,11.78t8.8,3.55a9.15,9.15,0,0,0,7.93-4.1q2.88-4.1,2.87-11.3t-2.87-11.21A9.43,9.43,0,0,0,954.58,260.21Z"/><path d="M983,245.31a3.91,3.91,0,0,1,1-3,3.7,3.7,0,0,1,4.95,0,3.86,3.86,0,0,1,1,3,3.9,3.9,0,0,1-1,3,3.43,3.43,0,0,1-2.46,1,3.38,3.38,0,0,1-2.49-1A4,4,0,0,1,983,245.31ZM989.37,295h-5.92V255.89h5.92Z"/><path d="M1016,290.79a19.8,19.8,0,0,0,3-.23,22.18,22.18,0,0,0,2.32-.48v4.52a10.69,10.69,0,0,1-2.84.77,21.39,21.39,0,0,1-3.36.3q-11.34,0-11.34-11.94V260.49h-5.59v-2.85l5.59-2.46,2.5-8.34h3.42v9h11.33v4.6h-11.33v23a7.94,7.94,0,0,0,1.67,5.42A5.84,5.84,0,0,0,1016,290.79Z"/><path d="M1054.63,295l-1.18-5.56h-.28a16.32,16.32,0,0,1-5.83,5,17.74,17.74,0,0,1-7.25,1.3q-5.82,0-9.11-3t-3.3-8.52q0-11.84,18.93-12.4l6.63-.22v-2.42q0-4.61-2-6.79t-6.33-2.19a25.73,25.73,0,0,0-11,3l-1.81-4.53a28.26,28.26,0,0,1,6.32-2.46,27.62,27.62,0,0,1,6.9-.89q7,0,10.35,3.1t3.37,9.95V295Zm-13.37-4.17q5.54,0,8.68-3c2.1-2,3.16-4.85,3.16-8.48v-3.53l-5.92.25q-7.07.25-10.18,2.19a6.61,6.61,0,0,0-3.12,6,6.1,6.1,0,0,0,1.95,4.89A8.07,8.07,0,0,0,1041.26,290.79Z"/><path d="M1078.58,295h-5.92V239.5h5.92Z"/></g><g id="Sig_Grau" data-name="Sig Grau"><g class="cls-2"><g class="cls-3"><g class="cls-4"><g class="cls-4"><image width="553" height="553" transform="translate(79.75 80.04) scale(0.48)" xlink:href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAikAAAIpCAYAAABnk6geAAAACXBIWXMAABcRAAAXEQHKJvM/AAAgAElEQVR4Xuy9S7Nlx1E2nMeybMmWZFu2ZMuWzYyAeL8I4MMQgcAMie8lgiAYEMEv4A8weP8HIxgzYAhEAC8GY+Or7hfrYiQb2ZbUUrfU6pu6delWq/MbrFVVmVl5q7XXPn1On5WKc+rJJ5/Myqq99lrV+5xWHyAiwmabbbaZYpnbg9RI/2Mf+1iqTjFEhNtuuy2SbbbZZifADrZDymabnRxb8nYfzbH0I7x38Pn4xz9ucpttttmtZdshZbPNTojt8lYfyR05jFh89OlMxH3sYx+D2267rfq33XYbfOxjH+v0m2222dG27ZCy2WYnyJa+3UfyRg4jFr/kkJLRFO4Tn/gEICAAAnziE5/oNJttttnRsO2QstlmJ8yWvuWzeSOHEYvPcJGf4QpGmMZPfuKTDG+22WY317ZDymabnTBb+pbP5o0cRiw+OoBkcjSOHVDmT1JUPIF2YPnkdGD5+G0f337/ZbPNDtG2d9tmmx2SWQ/pg4MDld+XHRwcpA8c1Jbm3Sxbs9cPPvigOQhw28dvg9s/fjt8/OPboWWzzfZp27trs81WtvojBMTUASSrW9OO24FjL+Ytn3yKotn169fh+vXrTYcAd955JwC0cbPNNtvdth/3bLbZDkYPJJqNHD5GtGvY0rd+lOfFMz+S0bhRP6Opr13wox6J1RxSutS9/fbpk5bbb78dbr/9dthss83GbfskZbPNBoweSgpe63Bx2J+onORPU9x1B1vifcJCYx9++CFcu3at8p/+1KcBAOBTn/qUmrvZZpv1tn2Sstlmgd24cSN8mFuHiyWHjiU5u1i0NmmR/jh8ksKw8alI5hOWMKdgZe5Pf/rTcPvtt29/BXqzzRzbPknZbDNh5VOSGzduMP6wDg9rf0Jz3Cw6gESHJM12+eSkGtWNYsWuvHulasph5a677vKTNtvshNn2Scpmm8H0aUn5xGTJpyJLcjK2a37WRm4Do5+URPHoEDLqRxo3Nn/6sfMnJxlsfbKDCHfffTd84hOf2D5l2ezE2/ZJymYn1j766KP6qclRNe/QtKat9fspa9U5LNMOKIRYji3LaADg8uXLtbdyYCn/r5bNNjtJth1SNjtRVg4m5Uc5h3EA2NUO66Byq9pNOTRZn6JAgJVe5YHlk5/85HZg2ezE2HZI2eyWt48++qj+OEc+7Pd9AFir/lp1PFvjU5Bd82+qDbaeOXSsbe+8807F99xzz3Zg2eyWt+2QstktaTdu3IDr168vemgexoFgiZW17LO3NQ4qN9u8/r3fTeFCHbOctbZJqZPp89KlSxXfc889cMcdd2wHls1uOdt+cXazW8bKpyXXr1+vnPZAl1xGY3G7xpbaPmpmbwXZQ0AmPupnNJ6fwuJ3U0Zzol++7XBxM/ME+JOf/CTccccd8JnPfAY22+xWsO2Qstmxt+vXr9cf6Sw5gGQ0a/Nr2Fq1R28BkX7kELO2L7ldDyxWLPW3dzKHFTJVpp86fxQHhM9+5rNwxx13wB133AGbbXZcbftxz2bH0m7cuAEfffQR+9REM8T4RzcZzVI76rWjA8dxs5EDUsbYAQDy+SNaAK6PDiCWsTkR4OLFi4CAcMcn74A77rwDPvfZz9nJm212RG37JGWzY2UffvghfPjhh9XPfAoS+btyHh/F1rAl9Xd520e5Vjz61GPfvvfAz+i6AwuSg8EIri7BmTkVXEelrtbDHXfcAZ/73Ofgzju2fwRxs+Nh2ycpmx15++ijj+DDDz/s/g+wN8NwhU8v1rbyoMr0FR0wMnZwcDx+uTbbo3sQsTAt7UyjHlaA1xj9FEVdV26p8P7778P7778PiAj33nsv3Pu5e6OUzTa7qbZ9krLZkbVyOPnoo48qt9anIpFvcRZ/Mz9JoebNteZbPaqlxTPcmr73YM/oot81sbB66KA8Nm1XI9PXjFXO64dg2te9994L9967HVY2O5q2HVI2O3J27dq1+q/HLj1MRHmR7/EjWo/fl8n59vEWj2ouOZBkNCN+Bmd1O/14h+LqEpw8gJhapa57MKG55LBy5513wuc//3m4887tR0GbHR3bDimbHRm7du0aXL16NTxARL7GZ3J24Zbw+7SDg/3+SMarnTl8WPwufja2S076MGLV0rTFTfSoHkyWHlaMXu781HRY+dSdn4LNNrvZth1SNrup9tFHH8HVq1fZj3QA/ENF9uAQHUwi3+IsfkR7K1j24JHl1vSzMRMrD3wL1we9rJE5mFAcHUxGDisTqNit5/T3+c9/Hr7whS/AZpvdLNsOKZvdFLt+/Tpcu3at/hXi6MAw6mc0kW9xFj+i3aeV+fb91j4uh5SdDy/WoWLG0aHAOwSoh4zosKLljPY12NMXvvCF7bCy2U2x7ZCy2aHa9evX4erVq3D9+vXwkLCrL7lIP3LIGNF6/NpG59n3W/soHVLog7WLJXBW5x0A1MMAxZq2ugRHh5SlBxOlBsOJXu67777tsLLZodp2SNnsUOz69evwwQcfdIcT76AQHSIiP6OJfIuz+BHt2ibn2Pdbe5dDyhJN9pCy5MCS0bmfqNAcbJyKtRrZgwSNz/nDh5UV+rvvvvvgvvvug80227dth5TN9mrXr1+H999/P/3XiKNDw0iuxo36Fmfx3mFknwcVrfa+39qZg8YuXPZQIv1dDyzWvNEc3icXNF6xVis6mDi9uAcnpUa6J6e/+++/fzusbLZX2w4pm+3FyuHE+sf+sgeT6BAR+ZKL9GscSEb5Xc2qu++3duagsQu3+JAyePhIY+tgMBE2J+JdreTBhHF0rqgno4bbX2Y/CL7vvvvg/vvvh802W9u2Q8pmq9qHH37IDifZA0JWt29/9IAxcniJYkssqrevt7dVN3P4yHLpQ4mMJR6qax1YukNAwElMddG82iEidTDROBHvagnOzBX4/vvv3w4rm61q2yFls1WsHE7Kv6uTOYCMHBaysX34Frcmv8Qytfb19t73IeUoH1i8T08yB5ORQ0B4WKHzJ+aM4l395AFK+vfffz988YtfhM0229W2Q8pmO9mHH34I7733Xnc4OUoHkxGt5nv8iDYTy1q2xj7e3l7N6PBhcSP+Pg8pJrYe4vThL8dJYOJuDueQoh4crLkop9Ri2FiHqU/i4n/xi1/cDiub7WQfiwSbbWbZe++9BxcvXmT/KnGx7I2M2kjM00qLciPfsxFtsSU51LIHlJNu7EENu+25ZtqD3RF32OrPfR9YE1m0VktQWv9WP6Pv5TNvnoGXX34Zrly5Ymo328yz7V9B3mzY3n33XXjvvffUGGL8rwRTjafP1ComtSO5+7B9zb+PmkfdvAPGksPHosOLcsjoJZjSTaFYWx70TEsPOKisRXA1ZhxWtPwS6+SJQwnFpd6VK1fg8pXLcNen74IvfelLcNddd1llNtuss+2TlM3Sdu3aNbh48SK8++67qT9RZTRLdRnfi0WfZmjxKEfaSD8ZOwoHlCV9j9rSQ0n6wGFYJp9pDLn5CQk9BFh675pJ9Mcs0V/R0d4y/VjvWaYX9a5cuQI/+5+fwZkzZ2CzzbK2/U7KZqFdu3YN3n33Xbh27drOv2uSwWvFdtGOaJbwUYxaVqfZ2m/vqF72cOcdGuXDXH2AKr6F1RoRNvqTnxJo3Gh9DascrT8RNhfUsupMbt+neRChGquGghEQHnjgAXjgSw/AZpt5th1SNnPt/Pnz6cOJ9UDPaEZi0cFhqXaJH/G7xDLxyNZ+e0f1MgcSyS09lEg/ejBKDADmwzfC6cPKRKTm9Q4mGucdVkYOJqk9HNkbq4acb8751V/9Vbj7rrths8002w4pm6l25coV9stu2Qf/LnipbkQ7UmdEs4SPYtSyOs3Weotn6kQHEo1bekixsFojwACgPnApzhxWMnNFD//sg988ZER1tRyjtlXLxVa9iVDxXXfdBV9+4Mtw993bYWUzbtvvpGzG7Nq1a3Du3Dm4fPly6obkmaXL1vJ0np/tT7NMbkZDLbtGz7K64270T9kjsV3Nqp3ed01GOQsXSpmH9VSf66jPRfU0DXuuBfkcXm0Aey+sGl09bb7ZLl++DC/99CV44403YLPNqG2fpGxW7fLly3D58mUAiD/RyH5akcFr6NaKaf5STTaWiVMb0QIMPGgdy9ZQH7YjB0zxYOseei3AHsoWVmuM4Lk37RDs6TK11bxonhmzcQpU7NVSc4zalDPrEay+VkGPDM/xu+++G77y5a9sn6psBgDbIWUzALh69Sq8/fbbAJA7LGgHlewhIIPX0O0Sy3KRL22XQ4xm2Zw13uLZGqOHlNShxHvwSd/BtYaGoweww2UPNSNxTTt0WNE4Wt/I6eYZ6dfqbyL8fiieh7vvvht+7dd+DTY72bYdUk64nT17Fq5evRoeCqL4EryGzotldRl/qSYby8Qti/J2fYuP5nuHEulnDynmoQRE/cSDsWI6Dy2ROZhosbmO+cCnOHlw8Q4mHUdrBBytk9mX6JCy5IBCsTyg0Hq/9uu/BvfcfQ9sdjJtO6ScULt69Sq89dZb4YHE4veB19B5sazO4pZqsvEoNzIrf9e3+Ei+pl1yKJE+PZRIf81DivZgTh8onNiuce+wkjp40LpGjla7mzvq3cpz+goxAtxzzz3w67/+67DZybPtkHLC7OrVq3Dp0iW4evVq5dY8nCw5FOyaszQWHTCWHkp2OYhE8ci0/F3f4qP5Un+YhxQViweliwcPH64+WTeDRw4r0WEkOqB0ONm7W2sCKrb61eo8+JUH4cEHH4TNTo5th5QTZJcuXYJLly5VPzpYRDiKZ/HN0i05cGQ0FrdrbMRonV3e4qO5mv6mHFKMB2LFxkOw4oWHlexhI+JYXOlLHlA6biJcLqpD56M4tX/WHBPR42QNgOlTlQcffBDuuWf7EdBJsO2vIJ8Qe/PNN+HixYvxQ2QAR/EslpbVUcvqqMmcTI2MZhdbqz4irlZrxOQhix0uhK0ei5a7IJ69Tr1Y9J7TjMWxDD3XXOQc6pybI3R0Pq2fThvgolcPK4m8YpcuXYIXXngBTp16DTa79W07pNzi9sEHH8Avf/lLeP/997tY5gAxcrONtJ6l9fRemc0hFuVkDi4ZjWej+l1sl7l2yS12AOt8MmRZ2GO0BCXuveaZ68GySBfWxjJgG0VK96kFKNjIkdrKZd7jND/ARW8dVgpXoTHnq6++Bi+88AJsdmvb9uOeW9hOnz4NH3zwwc4/qoniS7UuhgOgz7d0bBBn/Iwmk5ONZeIjdnBwED4gNVuSAyAeKuLhpD4QFV8+LK0/1avYegAWTOcrWKmzBjeqNzml1zrOMW1ti9c+Eg/w8GthYXE9Nh/hf/2v/wc+85nPwGa3nm2fpNyC9sEHH8DPf/5z+OCDDwCgf3NLznoYeTdQibPxzojEuil3OkjUFTbc16CN1hzVHxfr1iWXuaZvYc2iuGPRdS45+vDs9fn3Dw+UAdlIY6Yh16sHRRBzl7j1vqH5AS760QNK0VYeGqb7iQjw/PPPw/PPPweb3Xq2HVJuMbtw4UL9X0tHN0H1T0jBgcXSZOpqc2QPI1IXzSexZ1IXrc/SSMtoLNsl96iad7hcGpsFTWNh8K+1Sjn77l8XcgRoco1rFr3W2uGgLbGPlXVm1pvdg70cVox4hcE8k6YJLl26BM899xz7ywGbHX/bftxzi9j7778PFy5cgPfffz/1Y441fzwzEjfzyI9wuh/nGDGGkz/OyWDNz2gyOWvHM3aYP+7xDnPdA0Y+zCbQ+eyhhgo/gpWHnXWoHuF6Dc4P0DJy3Ov0+hTXUeldO5gwbiLCPcj2kMGZg0sKW/MQDUDbbwCAr33ta/C1r/0KbHb8bTuk3AJ2/vx5OH/+fOoBHB0iIjwSN/Pmw8WSg0kXG+jdw2v4Wc2a8Ywd1iFF0696SBnB2sOO4uQDeLeDSYlTjuPDPKyY9bQ6yb3I4NTrEfTYYaIHsndzBAARPvOZz8Kv/MqvbL+rcsxt+3HPMbdTp07B+fPnASD55iY4io9oKRfx5YFi3aSiGDODz6xJ63PEMvmRJopvFhjdPmzX1uSKvVW2OrrGJee9XlrIf3mj1z64Vun7Q3CRjtUr8eReWPHuEOFY6oBivJbxAWXyLl26CD/+8TNw6dJF2Oz42vZJyjG1999/H06dOlX9zKcF0ScfEY7iI9rUj3Aa8HUDfUk8Esv4Wc2a8chuuU9SxMMtiksM0PrSHrIe12vKQ7I9LL2Yz0V1cj1GXBRfkmNqrddjhRrcL71R3ISf+cxn4Td+4zdgs+Nn2ycpx9Dee+89eO2118I3d8ZGaqyplTcbDSP0dVUqsd6o30xMs4w+ozmKNnI4iq6BnU2U6q6NgamyvcqHctO0sVAtXcb4hd1PYx9WKqpzDPbNavQ4ek8sjTNt6Z283zN5Wg2Kcf6v+WWfENr3Frt48QL8+MfPwGbHz7ZPUo6Zvfbaa/Dee++FnxJEcUtr8VHeCNY+EbE+QUl/mrLDJysjsYyf1awZ9+wwPkmJHmKRb/8JuWFshBp3cfIhnYkByE9D+IEkE+t1Wk7UR46LDgL7jjNt5vXJvJ4qLnMAANr4N3/zt+Czn/0sbHY8bPsk5ZjYe++9B6+++iq89957AGDfDDQuwlq+pZXxXW9UNSZvOhNgmIi5TuKBXjKx42xLDygA+YPRkvoIdk73uiqvvWbuQwx6XDmn/xZr40T1B4pJr2toTOI5U6nXX5PR+zf7WozcM3aNMy1fcmfxQUTBLB9IDMpGM9XTzzwNv/zlL2Gz42HbIeUYGD2gRDeCKL5LnsdJPsLlRlNvOEUiSxdNdYVAbyVlS2/oka9ZRnMr2c7rjdKxDKhrrfyS51zXLdZGrHldmtBEjQPTFdzn0jntXi0uinvcqnHjvevdE4bwBJpH97HWheoX/Itf/Byefvpp2Ozo23ZIOeJ29uxZeOWVV8IbELURLbUoDxGVG/k4lvfxcuugN53uMDLzEkc3Pg8v1WVsbX0Uv2WNvs7Ka65pOYUqTxV5QzF6xrXTy+dxQLg2Nq3/3ouu4+i9Tc167y+K09esrs3XdrhS2GM+VNSlI8me8YWLF+Dpp5+CCxcvSPVmR8i2Q8oRtldeeQXOnj1b/ZGbz65aavQGKfkRLO8c3QME+c0nxCRPxYZ5N+loL6xYdOPPao6bRdfFWrbGP1So9ypjbZyo9olGnyc1OMfKyLWUmyMs3mKyB5KReK9KHL834z98aNxQvOwF6HH1AFIwnQZJXNYsazBwMeqdv3ABnnpqO6gcZdt+cfYI2rvvvgu//OUvd/4FVQvvGt8Fs1+UnYiOY78LYWhprQ4n+snqvJxRrcVl41GuZgcHy38nBUB/EEXxDCcfPtqftLtPT0TcwpGWP5yjmHUQ8WL6qMdoPseZ/Dje17PiI9r8/DE2X+cA08PMBGem1hV49kkW6+ezn/0s/Pb/+9uw2dGy7ZOUI2blgEItepN7WLMoL4pnMTN6gyEjjasxrRy7y5Qh7sfbl2xOtobm72pr19vVVu1HeR2119ky1kuyrZaCYqSx3qaYLvDzMNCg0hOJKonR9V0oHtPWqc/N60fxfH/m61X6nW4IDUOPeY44fGgY7QMKIsKFCxfgyaeehM2Olm2HlCNk7777LvziF78gN7P4Db7GTWKNPA0j6jcaeQfBJuo54HH3htUvw7XsQ9bTZWsUG9UfN4uupUZSaFwbgcV7aVyTXYyP9EKcuDZS02N8nr421dB8Hm95su94j721arV5D1rc1vbxfH8dVl589b0vMMvEBAa7h/Pnz8MTTz4Bmx0d237cc0Ts5z//Obz77rs7//glii/VZrAZpz/OOVA4qg8478c/LGcBXkO3xJfmxaNcaQcH+/lxzwgfcRGO4vTB6eX7udboa2itNnoxTcNr9vNGaxhdq40j7UjdsNfptLETZkcPHD+UUCz9r//21+Fzn/scbHZzbfsk5QhYOaAAGG/mxBts39oMNuPz7YLeZGaixeqdTalHdPLGpNVUMaWdm5Rlns670WkWxT3bJfc4WbxO+hr6cTumHQx6bdEUn47e3O06BmVEhvs6+sO+RoP3H1HWsYVtnIvTuXY/oMxEx3cYekzIxqJ9QAGjL+kjIjz+xONw4cL2C7U327ZDyk22n//853DlypX4TR3Ed9EuybOs0yLB0G482qFDvRkrunoHqi5yLHPB73vJWr0bnLRoz24V232dUf6SOHZjabNvVx5aeK6ex6/dfpw0dj1aTOutvx7z73ntEBZhvR+JK1Lidi+kNoVlDYB8+iothTPYOaBAK++9fyl+/InH4fyF87DZzbPtxz03ya5cuQIvv/xy6scImR9BHCWthTN/syf9457qHpgcqwG9n8GHEdPMi0e51A4ODu/HPUs4/+HKcRRv2Bq1GvrBxI/poxfLz8VxZg6d8/ZlwpPe1kZxrV+tdxcDlqlU3A4fCQz2PF4so7v33nvhd77+O7DZ4dv2ScpNsHJAAZjeBNGbJ4pLbTZvVOvFPRzeeDQOdI7Wodbd4AovbkDUUr0LWyvmaSPbJXcN0+bfvSe6/42juDfKUa1lWEdPO8Wato/pJt8rRVvq8bo8RhiSl9vnxnl72O+lxtN+vLj1Gmmvl/k+k+9ZBc8Ew9Z9gb04Yp+y73Urdv78eXjs8cdgs8O37ZByyHblyhX4n//5H0CMDycUR3GJo/iSOWjPkZblKTcg7dBBbz5l7G5IdImCYzjRn7Rdc0ZiJ8Gi9bd45oBRjAv7PPkg7UdPyyohHVuvE1dGUH2q1evyNWvraDE+p81VVEerrrcXmTjnbOy+j4qGvm89LEweUFDDYPcg+4li20Hl5th2SDlEO3PmDPzsZz+LZACgv2Eyb7Yl2qV5UXxyytBuOIU3OWgj5WgdjWN5IPowzNNYsSU5UUzaiPYwbde+4nwtzrm+RFST25SvH4x4rAjma1LtXXJFC8qoHxoaJw9NE+4ylD4ap9eg65m0tE9tf3lc40iGMlevoVbvIYA1ZL6PG8kwEZgzmfclYdnY+fPn4f/+2/+F8+e331M5LNsOKYdkP/vZz+D06TcAwH7jyDfK4oNBEF8jL4p7NyH30IE+1+UIDsDoY8ebVea12TU2Yrvkrm3RdbHM+AN9wrSmVl8/XPQjNT9HW4a8ptoIZNQOC7WCEkORLzk+1xTTOBCmHTCAYOywztEcimncPqzQdbBrg6cXdfWHMACrnX2fj7xHi//oY49uB5VDsu2Qcgj205/+FC5fvgyI7SK33gjeG0bjNOzFPU0Ul1ovPjllQI41Dlus3nMol61TtEt7FrZENxI7SWbvf0Uzpvvl7WuLt3rcLzQf9YOJ1PKYX5dqddMOIVqs3xf9+m25ZbT3kfYcYT8+GT8M+XHt4DRH6Hrk3iHhMhhEPTFpdI8KdUrskUcf2Q4qh2DbIWXPVg4o3bsB7DcEIqqxzEM20lKLNEvjtQd6A6Hrr/cY5NuCTdfdiLQchVvas6XxzNMdZo2badEex5bVztcFNlwjbgl0R54rY3zkptcp/ekjz+M5NEbn9PZXOwBoB4gWaxwNyPXqWm0tufjsEYdhwNqOdk/IWPp9JGTWIafTGZv6yCMPw/nz52Cz/dl2SNmjvfTSS3D58jsAMF3X0QEi80bL5Fpaynv1MnVHtI0sA3a4O9AYXMUGBxD3EcWlea/R6OsX6UZsrTqHYbxXuheNY5cKNh1fplaHv4ZtBHfkuVqMm1+/P3T0NTVNvxcep8VaXe8AQXtuWL/+dW3BRUNTtDg18/0n38MWnkDFiMgwNfO9RvIX6RAAkERm8PAjj8C57aCyN9sOKXuyl156ES5ffofdCAAalpzFU4s01jwZjbQoR2q93uoY3IQoNxN2jlYz2cdoXFo25umoZXVHzaLrxuL85WrB8vooIdfQHXk9GZM985xp5AeBOWKMdL54jyyORBfGqGlzWnG6fm290MX19Yo5lRA7IDSSYZkDAOz9X3yqsw4osp55kKERLMxkjzz8MJw7tx1U9mHbIWUP9uKLL8I771yevfKG7S98601lPWylRnJLsOSsuaM+JS+txqa7QMNVQDjkMSuH1VTM68PCUVwzL2bZkpzDNuvaOwomXy/v2rPNqgHVn776HBDX3KRBkitHei31XIvZ16FWo83J+ywc1XKurz97LMePc6zNyfuSPVo9ALB7QBKzXDaRyPFihk7mEGVd7MOPbAeVfdh2SFnZXnzxv+cf8UxvyMyNIcLWwyLKy+Bd41GeGgOdY3FsI+XMmugfrqJ+qUVxj5eWqXWrWLSXM6NiKrNw4+J9tK7DTC7vkbCojf3BpOVn9sPvzb9+9blLX43XDxCItD7HTdvPa9cvuooMbK0H2Pt8JiBzQFHx0hidX/plvdVHQiM8/PCPtoPKyrYdUla0//7v/4Z33nkHpgcmQLm6+zc9xZDCU0357onzMtiKezkelpw5J/a5NT7dNepIOSuH2prr9Dgt5ukss3KiWrvGD9toOw1rPXJu0koO9bHEwTYzt45AxlTFOvLcvrbGRderjE24ojr2++vtI10r1fE9mLAVp/c661AyfkDZ+bCi+dScGtNgxbAMUBZV/dl+tB1UVrXt3+5Zwd555x14/fVT8M47l6H9syrl35+xcPzvxkQ4iu+Cs9yINs0p//aO9e/xpGsuyBmJL8FRLOKz8aUmbw2jvq/RHmLzTR81jsc4NzjOhbpRxPUak4KP8Zyjsaxe60Hrr+f4eng+MN/S6PEJ9/PyHBmzDigaDg8oVG/42TzzgALSRyKb8Oc//wV46KGHYLPdbPskZUd755134Cc/eQHeeaf9iGey+aJFC1fhYhzFl+CIy869EzfdHULOzE9y1EZqjlo0961q2bVS2YR5Xokj/Y7UkxmB1YJiFPH22lPaOaAo7+1i3nWUuW7p2HTeAYUaP5hUlnD8NZDvc68/WYPOIRvh+ahIEbFh0HHRjxw0DuOAAgKeO/c2/OhHP4TNdrPtkLKjnVG20gQAACAASURBVDr1GgCAcZPAOcZx9ODMYCu+a22Ly2qpLeKwDD43MrfWr6eLtJkcLT+yJTnHyfj+VKRwBZMDARGwbSqOeG2KxBqltTKijtYHuRIpog8sBP29WKyfh+6DHpMa2XPrk2J+GChc0UiOa/ueKO7zvHr9fXGKk32ifN1PG89Eh6sGSU3N1/JA0+UOKNj5CG+//Ta89NJLsNly2w4pO9gLL7wAly5dYjcLemOw3rjUohuBhdmbG3ld78aXwVE80i7huhsM1Smcha14VpetGc3j2WhuRnO8jK5fcvJAwMPYfTfGUtgYZc40L39tVSWfpI5yGu96Va//BZoeV9T20OBa/YnrsTUH7ceqAQJrfSjWl2Y4c3DpsJbv5aGW13CNcpLvAQDbpxdffBHefvtt2GyZbYeUhfbCC8/DpUuXZk+/GQCAg+kFvjtGRMZn8ywcxaXWu7lmOARkuN4gKCdyJfbiWV1Gm+WimpplddSW5Ozbcj1hHVU5zjEzVC8SRUGr83FyWi57nejYXdNTRB+pjo8WZ8UyGhsrByal1xZHAxdNNB9A27WCrUOJnL+tKZonOpTg/B/jJ6DmqFpqSl5Vtm+AAHzvoBLQIMIPf/iD7aCy0LZDygJ7/vlyQInejPOFK3D+hjOOo3iURy2Tp95QnPVFXI2BrsvW8fYk6j/SZrmsjeqPokVr4PvDR6JqMU5DvSKEoOhKjGv0iWoOIsNaTn195+98pPPrCoTcNZu5XqNrdcIV1XHiaH16rwIW73HR9P1Jvn/trPsjWRPwuuoeAdaiGjYPJFaO1Gq5Alel3AZCIpZvcwhbEwgAP/jBdlBZYtshZdCef/45uHTpovHm63G7wUxcjZIbz9hNyMdR3MvbtQbFXi3thjcytxcf4aI598V5/K1u8qE0cXyE+nAQaqRDcYz91UbENtYAOXCgMcrcmWQPSWVsyRBel5mY1Ni4rY+WwdJ4Y6C3Ps5r0PcN5Zu+bBDpjFct+WSfEFpdqpmDHeYHCJtXDx2R39WRB5S5f9Rx84l6/vaDH3x/O6gM2nZIGbDnnnsOLl70fsTTYwBgb+qRB+JSHMUzOIp7WHJe/SVzZ+fdR87auZplddQQcVHeYRjrCznXHgbYYlSKVdVGnEauk4eINkqrtWqBgskIZJS1WL+sCwZFlQknro/RWI8lR+9JJY4MI9I8Op/UFg12NVi9SgnMipQBGc6s0crlL0Mu5mvnvRO+tuaqoLFKNO33v78dVEZsO6Qk7dlnn4WLFy+CvEgzGACUNxvn6UNGYpqXvVmNaC28tEbEjeq9XIvLxkdyJKfFIrNyltTSrLxma9Vb0+q+gbKnFIkwcgEJiMODYUVTtQWXB1BTQe0O+7GpkI+lZRRrxDZOJZR1O9eSjFnXKo33Wr7GgudtMONFU1fMMJ1b15QNQYlLHt1BhA4DxOudk+ZB5ArfiyF6PQCx/nph65d+I4h2in//+9/bDipJ2w4pCXv22WfrL8nab9wM1i5YybN3ReWiB6h+gwLGZW92Fo7ilnYktiu3a1zjon2NYhJ7nBXztJYh7u/Aku1d1WEZcMZIOCXWGCplNsXEwaITEb5i+r4oMX1U58DWq3zwsgdw4tqhr1X2+tLirXGyJmgP2KZFNd5wqS3xrELsNCgwaBgRuv0R2LqG1H0guZX3anVraForBnVPqpLvC//Wfae5MPvf+952UMnYdkgJ7NlnfwwXL14UFzoAvdjGsH5jiW5CkqdcRjMS9zRRXU27JLZUF+VQi7go7sV26WsfVvZqH/NZ6wnXiSVWXKwckzC6JYUrKRqcHjBIOQA2F84TmaOsN+eXamwsdem6CqVcA9Iy175liO1hyvMq6nJknE5R1t9jWbsuFtp+Gbgg7HGrMcPM9WTpRV0Z6+q5WuoBkG+Gr8WmXNr69773XTh79ixsZtt2SHHslVdegQsXLlbfemOO4slHNo5i+cCxNFHcuml6NaK6mjaKZXUyFsW12nKtVq4Vl9xIbtTrYVjZk5H5RrSe1bUCH5lmfrjQR1oZkI4AAGgcIFpWe3TU/PLQmcaKwRlrfVq39NX6K8ayqwzZqHHePmevf/naclwRw73ReNujhidvqk15/hDXMNsTgen1Ea3XxaSujM0CM8Z9Uad+kz4Sn2IZa5nTGqdPVDazbTukGHbx4kX4xS9+AQDemwIYbjeJGNNakvNuZqM4iktttkamZy9Hxiyd5DJryMQjvcZl16FxUZ1sP2tbee3kXN7c0bokVk2Ey0OlPVyw6rCOJanEOqYZ3c+qQyZE8p1BMiIdgfRQ1if7U8ZJXmZr82Wup+i6iPZZ1/IDSo+tOLR4cxTexzWH7o+DM2vv9oH1zGNeHvfF2klf2vronjRMY1ruZN/97ndhM922Q4piFy9ehGeeeYZx6TfHoHk3KskvxYjIcDaP4qiupo1i3tqX5I7EtTHiqC3JjdapcVH+mlb2be15vNcZjKmQf+tjjCB7RMcy74yLhwjzA0c+lPuRVcU2tpoIUOv141ytjbUEslHjllwbUXzCFanYj7e1T16p3T+0PdztT4ABcmtbM0bDsi91fWRPGBYAmT/Ndfbs2e2gYth2SBF28eJFePrppwff9Mj0I5jWys5FsVXfy83Wy+ZRk1pN59WO1rSkr2i+JXkWJ2Nr5By2yX9VOVpLFktOPrzlQ2mKQYuRXEUKUGPY4gJjK1ixOZYcb2zKbqxYrM3dk2TMv6ZQxYjyvtPyKW550GGs3wpGgmdtgNleGLgVnWGwdsvfNYZl/2iPE6BeIch6SftViywOwOc9e/Ys/Nd//Rdsxm07pAh7+umnK87eHKLYCKY3Ek87WkfWtOaRGo3zalHLzplZb6TL9qrlZOpTy6zVw9kcj9uHHRwcdAeUtUxdg7EstAOqBpWxHQ5mBqWOz6HVqDlypLqyLqVA66ElRtdmsew12cf1wwVdL52bG9U0jtWYN6LsRx0QBa9j61Aisble0PlOh06NZIz2VP0JUA+KrFuv6c+c0v/Zs2fhJz/5CWzWbDukECufoFg3gQhTfYT7m4uOLW0m18LRPJE2iq/NafFdcjXz6kvNEp2Vswu3plmHk2gtWexxoC0JoT4kyi2+PSTsfUHEGm/5tWDjcFagEtNGMn/3WiCaOdS6ddAaBHvXYnRNNIgqlvm0Rq/RasxjwVPCrCi48MAwW3cCqzFlHdJfI0bnYr5YU33ti6/Emt9q0TYmvxHPP//89jd+iG2HlNmeeuopuHDhQvWjG8OumPryZuHlUm1GL3EUt+Ycje/KRfEoVrCVk6mhaTTL7pOl1XQet6Zpn54sWU8WV26+Y7OHkrdUTSbq1r6JqDxcWk4L4ozLCHIEMgpX66dbE9L5kQqnYfDa868jfq3XNdX1FZ/n+7iiihk3DVCHbv+R4RKkD/wOEw3dM0SBoWHvWlsSY3MB9v4EgAyk50bQGMs2agO0Pr7zne9sB5XZtkMKAPziF7+ACxcuhBdx9sYRYe+No+nXxJm+RvI0brTOkp7p6HHUNB0dM5ol+xBpl6x5DdvXj3YsY30jH8stXT7U6W2f5dESiK0O0nytFs502UtRi45IR9IfHZ3XRGpNLvG6xtdIRUCN8nWtiWvUr00f1AWX3ZX8hChu1RSMHAPkeoz8kRgXUojQFmn0DFD3gubTPai5YlrZx7e//W1466234KTbiT+kXLhwAV5++eXqI2LqAs68cWgtr65+0xmrmc31akhNlrPiu9aO4pSTMUsnuSWa7BwSr8GtYd7vnkR97IIlx2/snYxZ93AXelQKdAwSDkVN7MemFnMWV7kuuuuB5PT1+xpWXSvGMUKjC0aGuTbCcp6iaN8apqLG09errlvjDZy9rjx/jRh7zeb/ZqfhKal52NTN57WqwujjhRdegJNuJ/qQcuHCBXjyyScBYLoovDeEf3PoNZk3l4ajuBezesjUzPaSydH2ReZnuCgexTSdlTuqoVqZY+ERLppXmz9jh/3pSTG1XywDtlFbFooRSI7cPyx1KC66Hrexn4eFaS0lp/aBAns5M6APuZFrkmOERhc8jQU307QSO3OX2tMAWPE0kqw6sDVqvIari2ovBUc+tUysm0/0MoNuXWX9DVO/7FOrNdG9T+d+66234Nvf/jacZDuxh5QLFy7AE088sewiJm8E702xFI+8IbNY9jySp3G71MrOE8WjmKfT9KOabO/UsmvTLNOrZaN/cyfbexZ7HAiq3LjLLR57ARsRseGa2ydQDlGMYi7WQzTWoiQfUdVY9UuOZf61gtDogjk36S2thvt5OAdz2dJ8RQCI8/oLTzUDGIDtD4C1fj0W+VaMzUfmpz0yH6Ctd3JoiW59Jbdbm/ABpron/aByYg8p8kc81EYu7n1hOu8+epD1I+0ucU27pM5oPU9HNZHWs6w225/GRbU9GzmceHticaNYcuXmrd2g50AdpbbLwTLMcSyj4GgdpR6rq/AsD8g8JUnmGnWoNvP62/tbEcGcm3g0tB5W5gaK2TegSwPEfv1LcC2nr38kNqItrytA3xfzaQ26/rmGvC6666Rwwqd133rrLXj++efhJNqJPKQ8/vjjcP78+fTFKn1E483rYKrPYKvOvnA0fybfi2vatfqwYlY8yhsZJUfntXQSe9wulj2cZGyN3tI1PJkR6x5os6899KY2sNUiY3lYlIcE9WU9OnbzYMCRHDp611kzUqPGEZoU6xrrWoHW0bQ27nqga8aKxJr5K9L2HolG2SMF0/xSg2LvfeX52Vhdp+yL+tD7rL5cBwuh6wNMtZ577rkT+Yu0J+6Q8vLLL8P58+ern71oPd97EGUeUtqNKKPdJ85yMm5hTWvFoni2nmcjeZZW9iHXvsYasyO1kU9Pilk9ehatS2LVkI/1YTbfqLNjV4/4tYeiB4BGiX302iW9qvNL3tKWnpR8AFD3rHHYele4hik3rXfSa1qvRivCrmnS9ywVa26mXqud3sZsLufaGvGzMb5OumDRJ2LzRY3KKfns9S8a4dNa//mf/wknzU7UIeX8+fPws5/9DACcixIx9Klpb0AvJ8LsRjCQtwa21kZxtlYmL9o7b0+iepZertHLj+pIjaWjo8QeN2pLDieerdmnukeg1HLKq/oW5A8B5HrE9kBg81Nf8gMjq0/qWlo6Tzc36ZmOAAgo9JRrWOemPMlnatD5Zlz6IGuYibYGbGvlxagmh6dB9EDM8633qKWtmKzN7IX2WXylvpffUtH353WctIPKiTqkPPbYYwDQLqLoQjYvXiMW5SzB1rwSezWyeqrztFHcy7M4WnNJTla/Vn6WA2j7KddItX3e8nFt8/Ymi1UOOVdu3OXmLMeSo8ZpTNRP+4S3esj25tWa6Max9Zd4t+cIKGKUa1jnpryCMcS8RltQh8saSO9zGqCJcQhPA3JcymHfn9dv5DMs51P8rhfiF645Zejryf2T66V13nzzTXjuuefgpNiJOaQ8+uij6gXpXajSz8bWxlGPUmNhqddyaUyOFrZqZbQWZ8U1neQyMa3P3WKWHtSYtU+72pJa1v6vZdnXr96klVHexCXvPThYivO6Mr0yd2qsaTxGjXF1usZp10WDOtdvZ+FKrQxGkgcM0+u1aUnf81q91wMRVd7DbA6JjddW85dq1V5m37vOAAU36716xbfWW0shwrPPPgtvvvkmnAQ7EYeURx99tP4einkxkjeh9ob0YpHOw1adLI768fSZ3GyvVq1IW3CmfhSz9CM1lsUQEC39FIN6p9FrenNpNqpf06LXSmKXE3fg4qPYJxbHPk+IuIvI9OWaiPa+zs1fOtXow4b1iCQu6rA1FM7dt3ItkQTBlWuNXnM5TDlao2mqR3uUa0Edy5xIz+pamFh3nTjXYlZb55Pzy56VevK11Xxzrcp6i0/n+ta3vnUiDiq3/CHl3LlzcO7cue6m1N2IZste3BJrN5eMeTUPE2v7IblIF+VH2Kov9ZpOcla9qMZ4DGFyC5YjdKNXW1pGsw8bnZfGLaxyKLgSkmmSV0b6IKCvU+UAO958LcAZsR/nYOfTnK6+5Jy+Jtxi/LqiWKyZcOWa1HnKtbptroKVHttCVay9Dp5e3TcHd/WVHjM+w2QO6as9F1+p32mEPw3KHhnzFx9x+kTlVrdb+pBy7tw5eOSRR+wLkdwIIk0mFmmWYNpjRj+Krf1Ywo1oPZM5S2trdcq4TgxhcqeR4j7WRqt2sYxmROeZtXcZi/RRbfXGTLTdKPVyvWR/q6Y9BVjcfZ3nB0J6xJ7XarF5SltKD9rr2O9Bub4oLnkNc25mEAnf5xRsvX7a+ur6occkkb9Wjr7WTWIAYHtXfC/mrY/VlXNOoGHNB16z02Dz6R5OIT6f18+bb74J//Ef/wG3st3Sh5Sf/vSnFXsXr4W1G0dWtxYuPh2zuRms1R3lIn6Uk/EsF80T1YtiPQcAgICoc3S0asZz2L3dDIvmHoqj4GhIqyP1hqHysND2lmKtr/pQiUboecrRmrQ3uQ6rr4prvXJdUTxVptedvCbNuiyu1Rd9KeurGMkasfGI2PMKNusWM3BmL62YtT4ApZcJNKz4smbltHUK39pTWkf6Z86cuaV/7HPLHlIefvjh+mOeYvJGFeHiW9irnclfgkf6y2BrD6x4tq40i9PmlDmZ3jI1o3pRTNcDAFAOKyfHPt+/ZkZ683q2TJuTYq+GlauZFs/2neVZHKHe8DNr8Pa3PhCUsTxE6IOle8CQWiqHfY/amnguYWkqVmWjsAacvSjxhgvPtlW+5tpay54g8v1pJZsvsFWr4Oh6HY1J67SylwmIJL6+rj4Kbtar65Y+S7OvEwCAf//3f79lDyq35CHl3Llz8Pbbb6tvdukvwZ6v8ZlaHrZyR7FW38qJ6mR0Hudpo/pLa0qd5MZiSEZg2Br72qDOJTk6RrF9mteLjFv7qNXJjrIO5WrMeQCU3KiXqI86f2mjuCVOHjAuJ9YluZKHOOVWXPmKGkaA+VvlZN02F8dNS2pBwX3+HGnrgtbnTHCMaMasWhID0J55XzQmceRr+87mnwCP0TWQeHXpekHXz69e7zOZKKxwCAg//vGPO92tYAcoX51jbufOnYMf/ehHjKP/g6td8NLYccZL4lFOlJfVZXBmnoyGcwAAB2LUuDbq+f1cXo9R/55GM/PBIx6Y9GEQPVg9Tot7c2m5Vn2ZjzBz2LgbN24M9ZLRlAeK9LN1slz8AJ8fWzVv4mgNVo/Fe9xSGqZ1qC8fsi5WYrVGgAFo/6IXQ6f5I1rpd71NoPO7Q4So2WmUPZkg71XjqP+lL30J/uiP/ghuJbvlPkl56aWX/IssiembIaPTYkcZa+vT9FG9LJfBIz1lsMeNaDhXbtp81Dg68polhmT0+9A4GrM0lll16Vek8+Kazurf6lnLlTptDnrTluuRNay5NQ7L60hHJDXEvLJOZs9UPa1bcVsnlusMp86wxmkNWbdg6HBrhWPC9r1hmZFgjS+vD9Hp6+MYQPbfNIg8R43TGpYWA1/2NoHOr7jkYe+zfLFH08D3pXIoOOGfPn0azpw5A7eS3VKHlJdeegnefvttANAvOAtrF382J9JpOVm9hUfrUH2UY3FRPMrJYm0ub/6oB4vzatsxhMntRy+GKGtLTdyr1aPFyZjG7VJXxjN1tHh2LNjyWQx7La3ljRaH8wNDHaH5NNebK8shtnkKrrOSPijXcOltwkjrVkzna9cjxdMeNFzXCQLPhenedHwrz2JqPYLVvSKalG/k0vqWtlv3BDqfrrG7BhE6X+ZrfuWEr/YIAN/85jfhVrJb5pDy9ttvw4svvuhfbAJrvsZHORrW8qmfmcPCsk6EqV7TSU0mPpqjabzcKObxGY6OVqznAABQHf0YraNp4l41bmS93h5YX5ZeG73a3jyZ2lQra1nzTA5MN2+xx9Goxsr0yojkASL71EYrZvZE65frhs2LZSC45DZcOeQYKQ9T8ZbS9zypeE8gesIWjH2rnsSyF6Lp90jxofla/Ro3tNWfQOcjEdIaxafxopf5Wv1ubbIn5D4AwL/927/BrWK3zCHlxRdfrJjdqISvxTSLcsw3L8mJ9NEc+8CZXjPxTM7StVk1JKflZPJpLJpjGpGM0I1ajNf28/25c+vQuMyXV9OLZ3ooRrEVi8aCo7k7jAB4o/FZi+ahY32AJNZlcW6sTjOvhzyoZiTwNDJc6tLv6OPWg76vc0TtD1o55tPevRodpvsHAhu1uhp0bk1LXmO3Fl0HNJ/Woda9zlSP0OWz+nJt0HwAZS6Y1nDmzBl45pln4FawW+IXZ3/wgx/UH/PIXxT0/GxszZy1cFY3gnfhlmArttbca9RuIwCYvxCrx1o5+xdqtb6yXFYjsfUA1R6kS3LWikU59KESYcktGTMaT7sLVx5Y3UN2AgTPCIlC5eo3wACTttQeZ5Xbn+lnagdzVjwB27fmFT6APU/1J8D9mVNflxJGrp2GZD2pidYACP/7//vf8KUvfQmOsx37T1LefvttOHv2bPXpzSjytVgGZ3VrYa9fGrPys1irl+GWYlpT1tfyKEe/Iq2Xn9EDIEwuH/sY1rF99Xl9TtyD3le8Li2eqVNsNEeOS/O0OjQnWmfFZI93tWyPVmwph/MDCMlTqGLK44yQKAyuYCwYZxrK3FD5MpHWY62KbazcBJim6Ki2q6e8lp1GzjXXlr6cq5tX6cOah/nKOsv1xrTE2HVCezP8wklfrkf2CDDPhQBPP/00HHc79p+k/MM//EPF9E+Lo34GR/HoT+e76NdeS/Sn7SXxkTwvNlIjqx2dp40AEP5VYp4L7icnctR7OThYHqOjxMUyD0fJa5p9xqRGi0vsxbw5dh2z3OKYeDCxBxjNpTzOCGuWjptT0gjPMe2R+lp/FU+gi6m+shfSZ9ip580d9RFp1NqaD/1apjI45E+DP2flxHS/+Zu/Cb/1W78Fx9WO9Scp3//+97uLd6mfwTQvi7U5l+gza8lgWs/ilsQ136oR9RrlLe3T4uwYwuS20Y6VHkCJWeNIL/1a5ZemsfRePclp9by56Gjpozwt38v19NRf07w1alykN/PIg6dgJA+oWoPxM0IEBB03dZlvpsn1STHrH8j+k560XjsfDN/YE/O1FXN1c0/A7kupUzkUtYU/A98vdYghYhenfulX+uocyH1tXYgITz/99LH+a8nH9pBy9uzZ+mMe76Ie9bM3u6OAtZj2RrdyNE007+ieZPZT6ztaVyY/y9kxAADsRo2b8nW9PtI1trUW8/q0Rvll8Rmd5KivzZ/lrL6zsYjXsOTWGEfXTS2jZ3lYBoTy0Cp8wygwGQ2MKPD0WIM2dcNdr6Kn2dF54U9ziLixX+brK+qVuecVMH8W8ZhSBwD619bS07lB9721aD7r1/G7vRQ9FZ76//qv/wrH1Y7tIeV73/ueeQHv6kvsxTSdxJlcijO5kS95TxPleXFLY+kzuZE201+Wa7X6uQEQJpeOGgcqZ4+0H1mbf1HtkjFTk/KU03yvRobTxkzM6pPGNW0095LR63uEG4rNDx1sT6fGYWUbJpyKsVbVMSKUdrR11AxNQ/m5FvVbMySu1KBrZxjaXsi5ZtD5Wkz2Jfdf67XzJ9B6IT61rrbisxxZw1iDZrJPgKn+cf39lGP5Oynf/e5369/mAeh/5r6Wn9VlsPc7AlGuh7O6ERzFd8GZdSypsYTT+H4EgNTf2NE4fZxqW7/nsny01iitxK0HL41FfvQglrWlZiSm9athq84aY2a9EZeJdQ9fhP4hqHFG/dmZFFir6rimlHolva9fs9HHqm/06dabgI4jX+Aqketx1lf9Cfg+JGoLP1yPzHH6qhzx//iP/xgeeOABOE527D5JKT/mkRe4+cbcwR+pG2Fay6s7irUYnSfDS5zVRmvTcGYfor6XclYPbZRxhClMxyxnjxy3eeX8dp/6mPmytJLP+pS3+vE0UUyLR1irs8bo1Y9yMnpmWAasuPCFQ/JQKlirXzASbcEgcU2ZcPFbLd4rYuul4DmbSWms+hoGvUbFZK0dRmy+Fie41GR64L0UDS/Z+qj+BHg9FLWkD7pv9l98UXMa+LyVU/b8qaeeguNmx+6Q8t3vfrdi68ZhxSKfmqWN5twH1ubOrifDS5zVWvoMjub3+s5yVpz6PAcA6rsaq99GnbP1Xh36BWwE6Ndh7ZE1al8ypuVSjeZ7+VFfS2Ja3SyW3C6j16eXuwuH01OKYTZOgYrVfUDOk4JQM+caLUXikq/ztE/VF6+J+3qprRK9sm6Gi49Y+6hY1kTuq3166yI1uvlpb3T+IhF7oM1t1iQ+WxfleLla//Tp08fuoHKsDik/+clPzBeUYu9NMJpr1cri+kZO6rXcXXR0/mwvWa2lH8Wy/micfln5lobrEBBLrK89Seko59M00ziZzmu9tvr2Wvf1JeeivhUrJjkrPxsr5vXh1fDqjIxevpeT0Vu6+vyZMQIZARjWak0SosXZm/MoZnrsMdRrVu+tqmgMsOtL24cuJvJmUl131z+iGSs+X5dcp9Jb6YeuC7g/g3h+Zd3UZLxyyjoKZusqXJX29Z588kk4ffo0HBc7NoeUs2fPwvPPP1/9zIvtaUf9UazFluZa+SM1JI7iUqvhTG4GW/WzcU8rOcnD/CaevrQYiJHysgepbTneF6/Le2ljvyZr1OfQY1au5xezYtboxUb6sfRaXavOiC1Zl8VpsVTd6UnEHkSVQ8JZWOaJGgxDj1tLpDeBWd8kH0BfU8FWXq2p9QkCa3WJTubJ+swnRuNFU+pVfwIc0/mh9wsX+dpeaetoosZ1rwFZ35NPPgnHxY7NIeWFF14AAP+FtF5Uz6fmxbM40ln91gvQWYvHZ2ISe71YeZnc0TqWZh9xySNKLZIR6lhyOZZr5jkAUiNj/dj3x+eQXyOa6KuY51t1qdYavVgmX2qoeTU0XaYfT0Mtsw6LS+npwwanr8IheWClsagh52AYOUaD5xrFF7jmKAse1AAAIABJREFUEWN5Xm8TaLjkKrjoZB7bU4DO7+oIDatBexF9AerrVNc+4AOIdU0E55z1nT59+th8mnIs/nbPCy+8UA8p1Ky/qZHxIy3lsnm74Gwsm7NEt3S9Ub1d8JrxKK+NADD0t3e0urm/6QP1b/dkNPH/aVaaxZeY9eAc8a2YVntJTBst7MUt3xpHes1yo3rGzQ8a7QGuPiQ1LPJcrPQAgEBoQ7NiTPY2gYal3qkl96PRyH1ZQ8ZFDbXHOe76EPRrcUodba5p8Nf7l3/5l3DU7cgfUt566y34zne+U33tppt5kK7h7xtn4tZDaTRnBGfninIzPVKc5UbikXYa4sOIxsmYxUN3+PBi9mi9PtSsGOXTN/kB33vwLtFoYwZncotlauzCDcfow0/jZuw+yIXWxUoPFqacpx+JdVqv5wk0LHJljPlKnerzdvr+jD5cf+bMXpOcFu/WOXPTwPupHPEfeOAB+JM/+RM4ynbkf9zz/PPPdy+UdmF7b6pd/Qymb94MlrmZ2tSiHE3r9WDhTH8ezuxHNjeqF8Uj7TQCAKAx0j6tei1mfdG4NZdWW84ZfWV1Xs6o7/H9euzXxZrHyrGwVUOaVjvSSX3EeTUAAFBeU8j1s6hq6wNKcCbv4WAfKZb7Y+lHY53W6nkCHCPHMkZ9Waf6pL2uH0C9p7kP1Z/ra/1I0/bG27uJJOuYfa2fKcT7B5hqvvHGG/DGG2/AUbYjfUh566234K233gKA+EWUGu1Fjt4wVjyDs7qCy3xWj1Ys6tOrL3Os+aw5MnqvN4qX1Im0I3V7DskIYmxxxKieFWs1uU9fpxa3+vLm5rV0XotpPuUy8eJreR4na2t6LSfiNPPmpb6n10aJJZeqWR4qBQt9l4NKzsylMJJcYx2Zvfb2wKtl7jmQmOyzrLesHRzs+FQ/DW0OAGUdMk58tVbxM/0oe+jtI83R5qJ7NIUIR2sS4qj/Eu2R/nHP3//93wNA/5G19hF25scHS/xd8FJd5I9iyUU51txRXhZTP7POLJfBOgcA5o9XphgftXr97670sZHfc7H60UdqGufx1NwbZOBbMWvMaKIcTRfFrXFJX7twdSQPEYadGlq+9fA06xuY1Q7mlni1mLEWNYZEI3WOT/MlrnGjJ9OfQOez/qBfu8ZF/kTqa5+gv97KIcLXv/51+PrXvw5H0Y7sJynPPfdcxYj6DYSa9oLSN5rMz/oeH+FsftbPYFlf00a1ZG60zlFs1aS81Hh5WWzFEfu52ggAgGRsejrSWMPc5zyN9aPdj74efV25L5pTbIlP+ahvL+aNUZ0o7o1ZvafNcnUkDw1EgUtc1LDy2zNp5lDUt7CY1+ufYqq1/MUxYy3Fl3gW8xj0edRX5yE9sJ6Aa03fmJ8U6q6jaB+7HGxfsvY08H46jlip+8QTT8BRtSN9SPFezILdFxfAjXtvHOpHb7AMtvxMT5p2lxoWZ+VqeivXwplcb64lNShvcVqcjwiTW3oAwWkxmU/7tvL52PL9ka5ZcpmY1Fk52nyaH/FaH5bGy6WchZfWj8zLyXB1JA8NyqXjqMQpBwkc7Junoeb52Vg3r9YzKhgapr6M1zrCp3vGNMXX9tSpV306Pxh+Yh+1GtZaZX9TWOfkXP/0T/8ER9GO5I97vvWtb9XfRSnm/Vggo9lFn8FLdSPaDI587ccEu+jXwhldlhuJa9ppyP0NnFYm9yOcaASw+9A0EkvzYlpcux1kbqSSj7A1FpzJkVo6WnhkzGg8rZs3PzjqAwQcLHIoZ8YD7S7YikcxL+7WyexRA9yfORmX+aove4r0Vg90fs0vtLMHmm+ttcF+zQB+3T/90z+FL3/5y3CU7Mh9kvLmm2/Cm2++CYj9jcrzLU2kt3yqz2AtX6uVycvEoj68vEy+xJm5d8F0LguP9hXFNe00lnjhJqyPFqZc/ovngDrS/u064OqsuMZnfcpH2BqtObx5LF6LWxatwxuzXB3pww3LgB1GQDXHnIPGHa3MG8VaPS9W8rV6lpbFtH2R+zWB3kc9zl4D4PNUn1int3ylh4otX6wZQMyPvV/qyLVOkKyPcsreynkff/xxOGp25A4pzz77bHjRRhs9os/4u+CsPxrL6rQ8K8fDskaER2tm9PQr0mbiUttGjqcQH1svlJM6PTca9Z76dWX2RvuK4pqumOd7OZ6WjlqOl6vNk9FEdT19lO/q54cHAuocwfQBUzHJ8ebN4Ciexbvo0lq5L3Jv5pgXt3yvJyhxqofmF06Nl36bkPmIyOOFk/0oNSQ3Df36Cy+m6fa6cK+//vqR+yvJR+qQUj5FATBerB19aiP+ErzUj/qguiXzZ+ppOIpLrM0l8ZK6+4oD0HVSDrpRi1GO1uE6PU+Osic5amvzuJF4pJN8poe2Hlsb5dB4JkdimUNzNa2l1+JSY/Y/PyzKqHJOXNahteV8VButdwTTGpZvYSvmaWv/yr5o+1T3SolTv84p/ebNfTCmzlF8WgMb6H0kPujr9/YEcNYA50pdOfcEeX+MIybnPmqfphyp30n5u7/7OwDof04+6keaKN/yo99pyPhRr9m6+6yZyT1KePc4AAR/BVnj+Eh1PG7nxOOUm1uHZ5Hm4OCgu3lJix4sFmdpvPzsGGkysaiGNnocezgWzczJByfl1IeckaPVptw+sBWP/GxeF7PWRfhOJ/Yw0lfO6QMAgVPzLKj73UGCcijiEO9ll+PMw3hnjZpP+d/93d+F3/md31Hjh21H5pOUH//4xxUj9jeQEb9wlq/lW1qLpzUKln5Ga8WzddaoKbGX6+WtkZvB2rq9OaM+EEHNgXpz0jk6ch2Pa5xeox/bvP16s19RLp3D0t64caOLaVrKWXo5Znuzcj1NFPPilt6KVYzcx+kpU0eNQ/Jgwfk/K6fiYgqn9rUD9uKRn83rYmUvaEzsQdGxWMkj+6jp2VxFwV5rnOOEgtmnNYH7UHzSR+Hk68bmkz7M/ckcUZP3goyrNZy91/jHHnusi98sO1KHlGgzl/qF0+JRroctPxOL4tk6ozXpOiyNh0f2ZUluBmfrWzU0ncyZRgAABESd47EeR5wc29zIRqvvzJenLZbJoZyGo7ilj8ZMrqfJzOGN1KyYO095aEwO49g4xzus5CAKrMWBYwDe2yiWNTQc+Rr2YmWdms/2VfgVly9D3/cLpj9nEA75PJY/wake8SepmF/6rCGRI9bG5ya8s9eU0/ijclA5Ej/u+eY3vwlnzpzpPpLep79UG33MvnQO6WfrZGNLdBEerTmqt7BVZyTPi7cRAIIf9fS6HnucNU5av2/Nt7glmujWkHkIRTg7ZjSWNtJH+V5M5csDQ+HUcRL0OBHXatN5i3lrG8Ve7cjPxlwdWWcYE36nF/MAIHBK+oZmGqjX+zPn+X0/es408HlauF8zgL+nFv9nf/Zn8JWvfEXVHZbd9E9Szpw5A2fOnAEAUN/0kU9N8638kVrZGp521M/2mo0VTH0rx8qXmtGaUa8WlvWteaNeaJ6Vz3Uy1rgWszDANPRxXofP1c+p962tuZilpzpPk9XK+Uew5KJxJEdqI720bG3JVy0CIBAOGkcfOGVkMcROR+OyDp2vysm8bp8Aw1jul9REfjZGrYuRsBWje1PjYM9ZfETLR4C6n42bas7h2a9y6SPxZ476sp/CaTl8nsYh8DXXGs7ee/xR+DTl45Fg3/bMM88AIrI/2Y34ZVMt39Joeq/W0thSP5pn1368eqP6jGYXbNX35h2pR+PFZOzgAADxAAB67uAA55p6vHEABwdIuBaf5oRZM43SrDVlLcrx4l4ejY1gyVm8N2Y1UTyqEY2Mmx8U9IHBOJqHfczEQW1aV+NqjcRrMYIjPxsbqSl9hsnaI63mAyBwqvcBoNe0UPMr5/ig9IBCgWVA5ldOLgG0demcx586dQpef/31m/ppyk39JCX6FIWaFs/43htiyZvFm3e0p9Fau+i0PCvHwrvkWtiqqa0vi6N4pKVc+wKhadw02nGbk/PxUetN+/JiIxpPRy3KLxqq1bCs5eVZo5cv62hxWceqEY0V1wdGGRtXR6yB+tApI3s40ThiV0fWZrVKXFkn9aVZcQ9HfjZm6aJ4h8neRGvmftE3f+KED8A4LBokfpU7Psw+7QHn9YHgaBZdH7T1Nrm+f9brbWkL/+ijj3Z5h2k39ZOUp59+um4E/RNu8enmafGMXzhP782dnWckt3Br9JTZNyvPqh3NSS2bG9WM+vbWunRdI/k8D0B+apKJA3g58fqzMc3k60ZN7msxK0fjPY7GNByNGc2Ilpq15tERgD/MCi4PETZOgYpH90mtI+azauyCrb2KYiPatepMhB3rtOz1y/n1OwY+4TyfHUyqhvDSJ1zlZYlunTZvaW/2pyk37ZMU+ikKwLRBIxdgxpf1vDfhkljkWz0UzusxG8usM8rz1q7VoX42V+Z52MqXc0Z1ovVmdZSfvmQN2Z9dO8tZX148ypXaYqP1Mrk0n+o07I1ZzYg20oyOwB5gBc9rRKgPD6xPGWxc0F8XZ3UIhjZPxfNYaxDMaiaw5Dw99bV4JqbNMVInqwUo12vzAWIfACYOofnkGwvh9Hq3ErrPDAGYqg7EJxwiVr+WEOsunLYfkfZmfppy0z5J0T5FAQDGyfiob2m8/JFYiUd9WH2NzBXFojllnsRWrexavVwrL1pHJj+jt9ab1ck4HwH475X4tZdyEmv+iNG1RubNQWNSp+UVTuZpdSytO05395Q2o4lGgPIA4w+ygls/lahue+D0/TBDCmkdgQmHWCaiPUCLEfP2xcMjMU+b1WXivk9fo2U+ALDXuX7HwCeJ1O/Ld8cVYK911RGOhZD5lQ/2MeJPnToFp06dggcffFDJ2K/dlEPK6dOn4fTp09Uvm0JvmpST8awvOU+vYandV5+av+9YFsu1evtZLKqp4Ux9r78Ia3lZnRZvtp8Dirf2jE+t1JJm6aV5OhmLfMkhtgOK5L3xMDV2bv6AUnXTQB4w7fHj9abGWR06H0CjUcWszop4xM/qLM7Tx7W8A0npz/dVDf/G/CYlscoxReWmAZlfOSkP9svjMvyjjz56cg4pmU9RKKfdsDN+Jt/Cxby41bvMj/qktaW/71iEvbVY64j21auTqS/nkpapmdFZHEA/f5QzwlnrKmato/QmzaslLZpbxpb4dI5odDX0ARxoPK2bH/bnH1RYfEqsz5ZaA/sYfWhpfbKHGlkffdBZB5R9HVwOI6ZxI7WAvTaTP+l29Pm3tqUY+dM3pSXOSo6FkPkA+p6N8pK7WZ+mHPrvpGifomgXmbzQ1vYtHGk9X+qlP1p7aaz42VgGFz+D6ZdVJ5pvFBc/0lNtpMtwWpzOka1DOfml1dX6uHHjhlkj+ioW1aAm59d61Hypr6O80wL0GqrFaQw1yLUyx+wnGAEQJlhGwTEMAFjGCQPj2upLjwXXyhQXNfK90LiCa16dmmNtLu11k5oopmmX5EX6TC1KFX/iEADG/alO/QYlApUr/pTYVC2n+dNXfc0oT5UshMwHgG7dhcvynvaRRx7p+H3boX+S8tRTT9UNoH/yy3CI9qcDlm/l0xh9Qby4FhvxtXpebqb/Ea01h5UT9RT1Si3T49L5RtajaUd03pzRmr06Wo70aZ+RVhrN08zKs3gZ03SS8/y6xvmm2z1MtVFoR3K0mJtnjADtwUe5NpQ4Fpc8bAqnxEg9tm9EU3lWs62x40S8ljRexwxeK7aLNvJlDOprYvsAQDjq07oizr81JUZ+GUgTDFYB58SyNA5AW7/OWTzlbsanKYf6v8U/ffo0/Mu//EvHazfQiJPxXfWeP6LN+JTb17zZOqM4q9s3tmKZXKnN1snMr+mjWpn6Vo7lW9xSi25eSzXaw6SO8003dQgxtJkcLabqOw05gNQ0DbdDSMPGCHoPJi5rNDgVV7dhlr8ArxUb9UdiPTdyOGl+44jPhcxv6SLehMIXHOOhe90A4j3z+BEtAMBXvvIV+PM//3M1tg871E9SnnzyybpwegNdwsn4rnrPH9F6vuSs2l4db49kbtSPnN/KGZlnFGtzRJj63n56a6OcpvO4XetT0ziNt3QyVnoAAFO/i9GaWn2Pi/SZA4V7+DA0mRx1TmWtjfMOKEU7c83pOD7WyKwtjTXe2n9XWwccw+L18l77bEzaLnUi34/1BxT6Ok453G+c9AVHAsi/AZdLzQREWwQi8GDPje1BnqP8YX+acmifpJw+fRr++Z//uePpTXUXTsb36Y9oNS5bO6pr+VldFmd12vy71IliI3NntRFnaSyc7Su7/lHtqB0c2IehYt6DROO8m153k539JYeQtEbUY5yytsb1BxM7VnJnrjkV62NVz/kKTmisvGlAHbPXiT/Evdf8ZsYiP9L2XNk/3584UZsIkX9Tub4kKhxhJSeWEq9tGa9xDz744KF9mnJon6SUT1HkTXSEA+A3YaqT8X34I1rqS46+6MXXcq26mbjGW3Nk15jF0RqitUb9Upyd29JG+ZSz6lpzaBbN4c2n+dS82BKzakl+1Jd899CcgPoAjQ4hIwcYs4fC1b7pA7s/qPSciE3FoA3GAaVFWp8Opvuq4qhGdRs2a+0Qi66HbJ1RP9ICe52kT+v4/sSReBMRn+dwFyl0OOheKwBtXTq3Jv/aa68d2qcph/a3e9544w0AmBatXTyS13SFj/zoQvXm8fwRLfUjjcdrsSg+0q/kZc9rYK9mNr/4NCfKjbQjOdn5rJ4zOd58GX/XL61+Zo6or6gOIPR4vhkjYPW7HMiPWk7tdeZKj3ScMO1/zqhhybVxrlwLTDUbx0cyZ1l/4aHlU1zjrFehRY5rvZrecJcvsDaPpe1189qNPD83px3NbVTvTzqYOepj53fzUp9/q3mNQwrnnJ4rPPUB+DqLr3Ga1tJn+YcffriL78MO5ZMU7XdR6AYUjvLan6KlpvCWxpsrmkfzR7TFtHytnlYrquv1kamT0Y3iqFZGI2tl8iWO4tS0HGlRPW+fvVqWSU30OlKfciPm9SRjmjajkXzB7oNz9q1Ramp9qRWcNr8WA2gPMI1ruI1cS+cBACT64rdgxV3PSczmhYZp7eopmIDwNdXW6OGZAUpF19LSHpb4vLeyn9xvXFSba5B/I5qm6MtqHIjXS99DysfrHudfffVVRbm+HcrvpPzt3/5tx2k30TW5ffoj2owmgzPxbB3Lz9Rb2t/IHJqOclEvI3iXvqL1RTiKj8akebElFt3oIl8aIpoPyu4mPPvqCGQuJHWLL3K6uZQbec+1h1fP2Xk03sVmQZMsO6BYD2kVi3k41tfL+d7Px3jN2M/Ps4tW58recr9x9lyqhn8DHtY5UaLa+FrW5Sn30EMPwe/93u91mjVt74eUJ554Ap544gkA8B88++LW9Ee0Ghfpsw+tKJ6tMxob1Ut/SV+edqSupx2dz8JR3NJntBn/4OCgPrgOgOvWMu9BsJRjeHr66ngClU+NIofWHT+80IcoP6AUrHFaraqfJW1ecWiw+qZ5ArP9dvR8rrY272Cx7GDAa2hc9OBdNm9cR+dkv2VfG9Z8n2s8l9DajVPKAL0WppzMWnTOi1l6i/+rv/orlV/L9n5I+Zu/+RuVj26+WW6J5ij7a2mXxLI5mVq7Yi+eyY/wWmse6S/SZHtRuQNY7WBS6mZvYN5DwdJJvz68zQdq8+UDv2rlqGkKR2sWrPUj5wLvoFLGntPi2BzBtV4zWFtjKdRaVXC3DmudfB0al8GypsZ518ioP6KdGdFf2V/uNw4bq+4Pz+EyWXviZIp8D1Q+XMs4P6Kl/EMPPQQPPfSQqlnD9vo7KW+88QZbIL2pFl7eED3N0rylfuGW6kfzLa1c29I6XszqW+tDq6XVXoqLD9DPlcmPepdzFYvqZXC0JjmvlmfV1vKqDwf0kbSTaa81jWmW1dEYOyB4eAIqrvPMnPQrFnOa85G+Jxw9wAsu/VAsa7U4NqdxWj8KjvYEkFwJQtPmNvAs7Nc3e8HrrK2519F1N87zo3kpF2m9XMJ0/Uw6gvk3YKibs1ME659fkQyXWo/OrcH/6Ec/Or6HlMcff5z5ZXHlBqhxGY2Xp3FLfcll9ZYf5cu5rLVl6ozGLJ2miXK02hlNVJtaVDcTp3WX6mVutKcyptlQ/ACmA4qjp1Z6iUzWo74Xk2bFCh89kCueQMO0hjFWPc0jXK0tObZWyWkP8DIvxXafRFxzWstKP9r6vbVJPPuV0XBJY6/X7oeV/vX3Hv563Pe1OexY5Kf6q3QTIhcJXmhJrZ6beG1Jce95bpSPtK+99hp89atfVTW72t5+3PPGG2/AP/7jP1bfujlKPvItTuMP25dcpPf8tbTZWAZHfibP03jxCGc5zR/JzdTJ5Gb2ZyKA/xjH8w+A3vdc0/Y+Mu3Ba/lRTH2IT0/WhiegY+EjYu9TjVaHzlWw6Etfs/bwLvP2HM31tCVk9qZgfZ/ILtW9bX5rgfZB63sHA/+QYF8j8cNf+t48kT+itTlv3WRfyV4y1M3JFSKt8cG698GN8pL76le/Cn/xF3/R6dawvX2S8thjjzG/LEreHCVv+Z6mWLbWqF+4KF64qF7Gz2iXxoo/grVYtl7RRbWz9eT6rHimH2vOYlHPI/Nm+mHzHwAc4EF7+Hj+AQC/4elWDjRynRmTOVoNry6NRQ/fiiegY2g1a20S7zgxhzmvrAnaw6poesw52mvP8xy9t46ndUu+xJOIlmi+lSN64ViuhVV241zL6zcN56wephgn1vb7OfuekX8jnLIvmlbW5+HqRGvflRvlLe2rr766t09T9vY/c3v99dfNRZYvjbd8T6PxmbysX7il8V38fcSKb+V5OZn6I9irZ9WO6kbxkTWM6LNzZfBEzFy5exEfAbmPxJe9I9QvLb7mV209iE3tY4wRu7Vq66hzknjds8IBMgxFIuctXF0HCDyNHNNeGtfyNL7lzzPMPZHeSk+056Iv+RpGrDIovc246VpPDAPFc93mdLh7DRRcarC1Asz7UXy6r1D9ZryPKX+5z/uja6lM70PdqvKNcKRW5cuCWi5bb91/Oofch77XXblRPqP94Q9/2MXXsL18kkI/RaELK39q9GKFs3wrT2q9vOxc+/BlP1k/igHo83g9WTFqnm4ktqQna11eXa9GhKNYpI9qZDCAeK0PoPv0BBDMX5QtHP2RkKbLmLY2gP460TRRrPAICKW9Dk9AxXK/NFz1Wo3ian0UTowcSw3lJky5nJZjNm/Us7JHUHUS129hLyRVxER/7jXh12w5voZPYfeyF5/sNWEIh+07DwgJ0SlATDtzPbk2Z/Ej2n39z932fkipN1toC6McjXlaK1fjKRfFD8uPtIWzfG0to/PIPchoR3RRDW9tsoaGqWm8t18RHtF5+tEamrE8ehjRDigaB8Bw1uj1AdBeD9q3t4aRGKtJHgDRg9eqU3nU8yoW82gPf7UuaAcJnZvyKKZ1c3ltOX3PdVWjGKBMwGITTeefcwi2Y3x93Oc6v6bGRf7EWX1V1uyv9+l+V0b601D9+h2FzySCpz13nNZH37cX07RW/pr8D3/4Q/j93/99Nb7UVv/F2ccee6z7fRSA/gbo8VlO4yM/o1nT33V+r9YasRHtGrGszosVHMWzOKsbwaNzSU0TlOEAtF+apTF5U0uZmFb7f62M3PC8mHXY6R7EE6i4q4eBTosLbhrIvHOuyikP3ejwMmnyuK9B5xBrUPrvakwFZq9h6ft9Tb6Oe3+Xw8qk59yIL6ae41Y/y/y2r8KvHDYIQBsMdA3w+oRNrM/j47X5sRH9//k//8dQLrPVP0k5deoUIGJ306ULoTGNL1yk07RS59Wy5lvDt/rJ5hffwp7OikV+to63Tisv8/pENWS9aI6spviZ/AyWe0zNytXFAAc49yTvUgcAgGD+2Cdtc43m9rW8Hq1YJsd64HaHjonkvaGio5qCrfpOvNXUDgzWQ7vg0lPPWTznOKZ7EK1H1utwIxQd1Rv5Sn80V+Lej+eoEcFl+pgZWSroSfTfNpVrRN1eR67OspdAjPbPuAn0nLGWZH+VlxtkcBafeR9L7tVXX4Wvfe1rSsYyW/2Q8vrrrwNAW0C58VOji6NxmZPVeZz1UNK4NX2t95H84kcPzpFY5OsYAMCO0evUm59afm5dZ+mp7aIZ6c/rLaOXuCWC+rsoCPM1QeVzbMSig4lm2h5GMY2nXPewpXHBF476RUtz6I08frCTGgrHsXZ40A4XpSeKaT0rj2O9B2fuaTBwWWMtAg1q/dZo5+vY7rfXxnNURHqSvr72ZvLBHfpdz72mnwsp5D4AbVLohDbqU2gsbeW1tSQ5j7dilDvSh5RHH320Nqs9pApHTYvLGpHO46x+tNqW5mb6WmxpXrFoXzgGAJC/XwIAYMXs3jTs5Xlr0DRZHM2V7V2rRS3qQ2KaN917Zv4AABDqwaLwB3AAeICg3aSkyR/jYCbJMW29Izz1y43WuzkjD+gxUkPjak0Nz/2wvljP7SHbeO2BrXNTnuRtbPXBMcmbBgd3SXOM9tZjPTb5dHvsfZPaeI7I12s1Tq5Zva4ifwKmRtchhdwnnEipQHJmH0LHYoKrse410blRXuN+8IMfwB/8wR90/FJb9XdS/vqv/7rj6MNol5imzXC7+pIb1e/qrxUbiXMdAICeR2Oers/LxZboIryPmtJfMsdEQP87IQdlOGB+Cx90HItxojfkPPuEZb41HBwon/QIzShvHRbU2AQ6v8MaJ+JdfeXh6h6oOo12yCiaPm7xMY7mVPCUNHs6niDFVaHgyefbY/XIce/3c+g5Mt58HkLhExZzvvaQdw8Kcu7KIbAydE8YL7S0DyFG7jDT9ADQ7aXHe8eAJfpvfOMbqx1UVvskpfwuCgC/+dLFyJuyprdiXm2PQ+z/1C7jmm9pZDzS7+rvGovi1ms1xQAQDwCAfnqif5LScNOVGi1vbL1LdBLL68B6/XbBmq/xUf50jyTG2BrEAAAgAElEQVQ1DoD/Tsr0UsyhA4CDmacp9PXs72aqlTkmSS8qfWrr07gohohd3+HDYwKd32GqMbgOK+vr+qGxitsDWuMappyl0eeQe+jP0+MpR8eTb/Fe/uTT1vT90eNRj73e6m/iRKixOODT/rmw51H4TEtY6Xs86vOGvVh8sB+VV16rNfhXXnnl6B1SHn300Yplw9bDSeolX2Lag3SE6x4GSs6I5mb4S2OWr68boD0J+cGDHlYKLjVbfa7jNXJ9jq5PYllraZ0s1vyIT+kOwPz/owCA+mOezHzq397R7l6OaXNkOcl7Dw/zoYAKphoNz3Nq8XQ/VFdxe+BqXMPz/B1v1SA9d/uo58bzav1LLHN0X8d2XU2b6U3GkX/jfTS65Tqvp/TdBzzh2ftF1qocU9VG5Y4wrVaL8Na8LBasv/Lda7Mu/8orr6z2uymrHVJee+21evOXhqgfNADA5GlM09MHRjFLJzWZnCV+4bL6EX9pzPJ5zwBADhQWf3AAMPrJylRn2WEhE5PY0ttrj3XZ/rX6Gu/1U7jp3oJQzhT1E5WDWUtS6qcq2rziUCJunTuZNp/GWTzlwocHxROoNSjXYasGyffiVJPD2gNc4zxM+hL7Zs1vzTvpGpZ5Nm45Vo9W/17PUlv8SUdwI5qqi9eI8KF/DduL2/naAx65M8QJFgCFP2uz9SyO/c0+MYHLd82A8hrFsYh/5ZVXjs4h5ZFHHgGAvulyE5exDE9jmt56EGs6K0fmRbUjX3KRXvZh+VGtkToyd/IBAPhh4+AAgR9IALRPUyQG0Of3+l4ao+btV2avRrG0aA1ZzOaYtrXdjGafmvzl2Z0PJcocnln7IXlN12nEDZT6HZ5A5TXOrTHPbcWLqTpjbY1HaJKCKWdptFr9fHac15xiOuZ5Eus5Wr99rt931KPqN5L40zcuRQo5Q/ulryXBrr45OW7mM1y3T8k5ZK+anmkFB6DMHfBeTPLf//734Rvf+IaqHbFVDimvvfaaytOmy008y9MYvZFLrdRoOk/jcUt9yWX1mfyoluZH2sKVm8PBfPA4mP/UjvOf4ie/HWJaTPsxEMza+DX11tD32PveHo3OQ2sWjb1fuT4zOcUqdwDm76MUU/8fKe0SShv7ZdkbfU+RaevQeHe9xRc3U/OQMYOaj42r2MormMzNsOxB0VmapuUP4wkXjeQlbubtIY9ZteicGqb1pGby9Voy5vXW+1GPqs+/MV+UgsoiwSSeecCvxoG2/kkb5hr1Sm53D5DrF1zllXYAjD4d3osh4ioHlZ0PKadOnYJTp051PH3gArSFWHwmR6uR4bQ5PG4tX3JRX1FPiCMHjvy8vB4APWwAyMMKPZAAaAcXqQXQDxOTLu6T+treFvPWreEoppnWS/Q6Zmp2a6E3H/pyzDEAmOIiljHr05aoz8i0fMnJ66BqxDpYnNxU6Y234wuWtQU248Y8XSyoD6AdGDRO4rjHyKc9TP4Y1mOTH/UscRSbWVZ30hHMv6kcDZsPeEajqe8OAxaf5NQ1S12ylsar1ynRWjrGK9PUuPqa2byMvfLKKzf/kJL5FAXAf0BqOdaDXvMjLpM7Mp+sG+klF8Ut35tL08o6/rwAoHxKMv3YZ4p5n55MeNLNlec5KbZ70WKa1ntNo5xs7YKt+pZ59S2dpmGceHhbhxf5/1CRtuR/3haZtS+U1zSFY7ob2K2VxcnNlN5wO75gpQerL6uGF4vm4ri8h0ofVVFxXCOKoVpX4imPYm8umTP5Mfb71vRRnwyV15N8E6nAWBz0Ha577+zCgbYvhtbgGux7Z3zAScu8tzP8K6+8ovIjtvMh5eGHH66YPvyk0Zuy5CRvxWQNr6ZWz9NlalmaqD+rRnZOL1dqZTzOBQCghwkA+ikJx5PW+2Sl+ADxQz/q09J6uZLPzqX1R22k90xcalRu2t4ZzjVAjyGgqi+m3SDXMrmGyDdjqOROd+cOU59pSL6GGWfUVh9eEWZ9twdu4/lDWMdGn85+9nubmYfPMQ0U677Wp4czvt6X8Pm3juNy6RMm8mdOfa8ovHZdr82p/Vg9Ovpp4OuWln6fDsa+973vwR/+4R+amsh2OqTIT1G0ZukDWGq0h7MXix5kWS5T28vL+hmN9jCL4hk/0hZucsvBAqD/ZAQI9j9ZadpWA6AdADJ7EPlRrpUT7Wc0ZzYWxb1+Afr3AQDwT08mAgCBH1zaS9DrD8Fo39oasrymsQ4GVG8dGGqccl49GZtAHzN69ufmD3rqq32KvfB8X1vmKXNYXPOpTsZp6Wjtlq/txaSTmPjVJfOQb3IJ5uEjinvcoLZbd1Y3wKnrmXm5Rh7GjpOWec9GsV0/TdnpkEL/B24A7UZLTTbsPYitGOUyGosrvNZzppblF26XGpn8aB0ZrV27aHGOHVR/+rEPAACC98lKy5M/CooPCcWs+IiWmjd3dr8yr1k2Lvsz+QPQ/3HB+TDi/dgHD/o5NKuHHKWnJSbraHWtuaLc/5+8d9u1JjmqRkdJfhDDLyR3A8/AecPmBgECAdc8nmXEjfEvLGObwyMAMu5u27yHc19kZVZE5IhD1qy5voY9bH2zMmJEZGRkVmasqrlWe4WFe33aSz9LQeLoFl7SR+1aHsr8Ovfxio71OXJkr3lbursXw9peZTrO+W8z7UlZOVo/PuaFZtg2eIyevCpj/XjcV2RUvjTbIlN6x+8dXWsNP/vZz1byBl4qUv7t3/5NtVmQ8lCUHHZYRroht+2qnZV7thX/Xn+ZPvIh23diiPpnuq4HoF7LAPoLsUBrQ965+vsqANSmMvSj6LkKlDvjvMuVOmljZUwe9Vu1y9pejBcZ+g+5CTkabj8pYa+A3BhugPnyZCy3adtsrqP9UhHh2eqOYl65v/ygz33stsmh32L5dc3b2Rh2dUKqY9D/XDOi5u+SmZDPy6ZkbrHiycBjpfFXfDp9ABv9OPJFFuRB0xqVT70Tw47ulVc+t4uU//7v/1ZByANZYnCs3g6OHehMznje4Wx5lhv5YjKvPWQZP/LxRLui620AqpC42rI4AXoh0m3XVz2Xy+P02xD9zZTO2c+dx2W2zE9FHvmq9uNxpb5iu2xkB3qBcYqmbiyrhuupiNltdr8wa+crg80Ts49kVpe2zYbK/EyZ4C52js49xFpiM66dXOhxXPdOhR/lJM69LkTW63baZfy1XY0v457SuN/+oduzeY7hUluGlmV6KSaxVmXv6MeTe/33D6FbwmmLTOmdGCKdJ//Zz372aYoUCRucPJh39VI35N4hHXEGPC7rc8d/5jfj7/RRade5wFidPd7ePo6hO05dm+2oQMn/Zsox48tynsdeG/fO9V2d5WX6HdsuwCxOls3tTC/7Qm323+J5Er/85S8XmR2XJ/N0WVvKdguEsNDoF8vGTnXj2vNFYgL4QV+KeyNHvs4rBkhhUNJV+621l377h25PWbsup9ys9qas1v6MfpdH5RWZ5w8sJ1xG5aff5UmrumyLTGLnPs3kUvfKK5/bRcq//uu/zmt52A7YwC0n0g8dkw15hWPlkcxrW9mO37t9RBymz2yz/kb466se/Uqn24yN5OKONitWQJ6mdLvXnjYwbqS7Y7PjI+MC/s3s6elrnXOuou+rfDS8cTF5lZu1pcwrCtS15NjrfrFs7LTt+cj6T66j8VZ1cc68wqNy3dsAqD6bq7322q/ocvyzyLSJbRuGbQ9xtuaUi1WXypx+AdKXI2PypW36VDLi0usn00d2TPejH/0Iv/Vbv0XYMW4VKbtPUSqcoZdyJhvy6OD1bBnX8rI4Ih9MFh16lr8Ta8V/bUwAK05Ge7i+/F6Fy+COtv8H3tYxsjms5M7TZ36r+arEYn1kfqrcFAd4cXLq0MALm6EfKHa3g2gMVudxMx6zk7JxrWT9ZODX/WLZwNPCxfM3rklM9lq2K/wsF3UuLy48jr5eufV+b7RFTme7X1jJxVmC1Xa3ihOA2063KkgqSwsYqWL9O3I23v7Bx3Bd6twuVCeGSJfZ/OxnP/u4IuUXv/jFDEgefAMyWKaPOMwv4+7yPG52UFpZNdaqjWzbSc5i2zlUpa7LAJyFBKBf9XjfS+l+5KalXwPhaP2sZK99jvMAdcabjSVrV8bt6ao8q8v0O1wJPl8H3I3twFq8XEsO6vsspL8KvFglIr2ns/JX2upabMKPFSfetdcPu/biLVxn7ZjLCw+fE+si7k7MtC3yJSRC1uSlbp8ye5+w9adkxMaTXZfavipj93D1/nDljt81/BkURbm/gs7K777yuVWkyFc9MhB5GDN9xpE6JmPyKq8qyzhsvJGMHXhWz9oVTtSHHzMAU5xcbUC/vumc0ZYru/cjuQ1oB9rpQ/dhDljhKo+3Vsx415bHfEpY/9VYXrUdMmC9Z4ZMro1ugFmA2A1q9wuzHkYsrH8vTg+ezsqztpWp654Mft0vlo3a07mHS/EaCOJ84Tpr1+z8IiPS3Y3jTntms5n2lNnihKz0trDyfonNNa0yMfIykAc87968e69civHBx3E12yJT+mIcVd0Pf/hD/PZv/7arZ9guUsZTlGXDxBrcLmfomIzJqzxPJuVW5nGqvrODMTtIK5yoD58LALo4uf7OyWh3zvUqZ7StX/OqhzxJAci4G+jNGcXP9F5uJVjeq/mr2jG+RMUXsN4bkm/1UR5NPfkYbHxevJ480jF5pT8pU9di860UKzKPns+lPey8frLrwHfl+i6vt+cVpKrqI/NvkfGXtsjTbPcL3T5l7DB+d3HiFSZKZ30y26HauDeo3PMdxMZQ7m9DP3R3nqZsFynj+ygyILnRStzleHZWXuV5Mim3Mo9T9W39VtsVTqWd+e9N+UoGWF/z6A1s9dsUt9+QV4Eif8OHve7pffGYs3nJxrqTIxtbBLsGmMwbS6azYHM3IMeocID/jZU3whvDE3IrS9t9EfLrfhHqxvUSS0t4Rt8/eCzK7sb1O3RV3qvtUGdyNGX9QrcD2VPFSVqwGPXUNdMW3FI/Q1W4H7rQ8cHiMHKJnfsy03nyDylS/vmf/3nZHG1AbPOUHLq5Co49mJiNlXv+qz49f94hGXGkrNqucO60Pf/90hYrXda5sgDB5fc4zqclrXMP4EAD+9LsfLICqIMzKhCqB3zEtdeAWaMjqKFvULFJPrUfbpw5rMRvdRJRn67+zGO06b0TXqyRnOUga1d4rxQngPEl+2mODbuWZsQfG5fXrxvPA7y7uiz+3Tb1Z/PI5vJS6jaIzzucoP9UbsebxAvwPHhyj+vlZ6U1KgcC34k+swP2X/lsFynAFYg8nJne47CBsINeyj2frfnvyu/4tLKsLW1Yf5VDL+M83wb0K5nRBtKnKRjr2jw9Ma96TlHXAf2GOA/S1q7rebNKHXSuo/EwHbseOI6rT6Un/Vu/tu3N4a4t88EQ6Zff6hn59fhODBV4tp4/T87+xgrA+dHBz2T0gGviul/wa9m2coh+jH3/aPxaxuZcV3mRTdROc3Yjlqfb7tz3C90+ZWnhwWTWjvjxZP1Dx6QpTckZN+17qKr3FMuNkF9NP27A7+8VneV89dVX7ytS/uVf/kW1bWDykN7hSJ7VM7n06R5EhDcQ+YxkrcVPUlh/HqfiZ7ffehsAvFc9o90515Cu3/LBcR6JrctxNFGQtFN0nPdBbwO4nqYc5loUK9GBflfXBXCLIBUPsV248PWhLWkPGYBFvqNfdA3AofMxVa25MVTA7K1+V8fkdrO3MmojZF5hYtv0Gqv/2fZspG8SY+U600d2UfsJO9nOYt5tu/PfL3T7lGVFBV1r1q7gR1/qmJS8Krsaa99w4vbkjg+3X+761j17V7f7ymerSPn5z3+uOrYbW6RjHMYb+qrv1vaepLwqY3FkNlG7wqn2m/Vx6QHgQG/G30vB+XEVJRilCHD0YqX//8B4mgJRgAC4fj32aKogYcWKH/M93Wirm3kM4OxTxSNjMO3Fj/RFUIoLep4k7uqZ3PNR1TNkNkwf2VQ2+qxtZRGfFhoQMdq5trJxTfpa+j19RnMStT+lXaSrzPFOOzzYm2lfBD5/Qt8/YjvWXuxYbFVZv1hlp3yJb6gKOb4U8tKPe+qZvPFXsVK/I2ecn/3sZ/jmN78Zk09sFSm/+MUvVNsGxQ5pppOQPM/e2g5ddOAznsfdkUX+K/15nN229FHJh+T0y9r3Urox0IuQ80xuDTgOHG3cBgfU05TTTv3tjgPu0xOlG+7AbxI+nno+ZF/qFQmLIXi6MmRjDJWCwlsLjAvEviL9RyOKg+m8zXHq+oUro4eA6ScsHvrF0h7XypeQUxm7lubC1+61lS1jLLYznpVF8dz1mbWXvOnGKm+mPfTZ3DE5afcPHsPUMdeF9Z72Be4nknt+qnEDDSp1hfl8RffVV1/hm9/85komKBcp8g+4AddGKTH0kU4iKz6qcqlj3Mw+40pZ1CfjMF50sDIfWb+VsQ+5jgEAsu+lAID8/gmAQxQoB3ma0hXXDSMPfHMNwC8ODkB+ryLKW5ZTVhjNm5X1KXj26Ur/8IuMxUaqWGwbOqaP7ouPgtdnFEuDKBQNjcqEr0xvOfRwI7ohDw8xK/N8jmsZd+E6a1d1Oz6z9o5fK6v6BdacevJofuiaMxwqs76TGJQuycGUReM45YsMG2MSuuvSjxto8G7RbB95Rf/VV1/hd37nd1y9RLlI+fnPf67aNoDoYPTg8Ya8UlRIXeYj8ntHVu3DyqSfKv9Oe0D3CwDyQAdGcQLIpymd1/8/FvLZbueyP3SxArTruyjHFcPRDjTxdGUe/vZJiygOjuO6tpAFiW1bXReKfmXbiWnhiXanCRnW/m3cNCYhrxQn3g3v+R46IPZ7F16fTC4PbKpzeHJzZRut51fGQH02cd0v5rWK38wja/ePxq9lHIXrHV3U3vHJZNUYqvFU2u7cX4JV3pI2yHhZH45vT3Y12yrz7gvGjfpH4MuR07EZudISOQB47rvOV0Y6y/nqq68S5oVykfLjH/94XntFAtPbwL3NsbXad0ukfOI84KZ8HHiSW5WBb+7Hsf7E5/EyWXTIevydtpRpHqD/68RXe9CvggVQT0/6iX2+0unGqkBp/fsow3w8TQHQv4sivpfS9X4xwA5eeaBHeVB2Y34bum/TnnNPihXbHnYAdNxj3cnr0X0Qn7yO7pFlrQNXPEQfFS0SrO+dwsXrI+rbbsoup5l2v6B6gPcpZUsR0S+4rgmO5WVtJ0aWaxtzVZe1q36ynNl25dqThX5trkxeF/mpyw70JS45N0Zeme9LzeVAMRfEPo1Jqtj9xca20E4tkQOAf9u2QHcyons+0P3TP/1T6WlKuUiRyDY2G1i1aPH8RjadcE3QcRxr23CWw0vKIPojMul3yHhB4Mve1fZkQ95F8if30Qbsf1TwrDtwJgFHTxbmd1PamYmjFyvA0QuUNh7hd984+gdOV10UFwNyfK3pwmTAylh7mV/yVITGZNrKbthCy9XTFTMOYI3vFsZ6lOOScgC/bL+c17v97fIBbhNt5Eo/OHKNYLVvfcBab3xnB0TkY1zTfittKZN9kmsbp8fP2u/QMdmTvmx7mZ9+scqEXMlQiKGtNuH8FeZYoroWGdf6XuKE76sr/bGNRrsuDbpgde/JBSPZJzL94FR4QLFI+fGPf4zW1icdwBqQx/F+Shv2Vi/9ejp5iCmd2LSnHyGbk8tkEP3ZRUD80sNR6COZHfvd9oB3mFvb6xoAZPFyLc75REV9IfbkifbRGtpxTDlwzCcT3bzzGtanKX0KeDEg45RzPK6jXCx5kL7nsM44SQwA+BOf05eykf2N9dHWtZTNpYS79oXfrlz76zTBeTOijYYdPIvO6qfJZeseYMZvJluu+8WWzm1LvshJ5fojdBmXye7EztoZJ83nOqmLbOmTcDxZ/9B9Ttk6FCoP7wM7dq+vq7HGmena/EdrSUNQtdwdQgt0JyMjEM4PfvAD/O7v/q7DvlAqUgZsJzsbLBtEpPd0TK5szWFHN/JIJv0JWVdc/J3Dh8Xfmv+9FMuP2tbOzoln268BgL/qgfp14rN9upJFSTsrm0PIr5SaQsAUJ91X03Nx5jwbM5Mv+bPzfIY3CgwZAwBdyAje8DU4gPDXG70vsu6ycbA5m3EDdNzLuAKwezRDZcNhYJvvoiP6MReMIw+E6kFCDwXiT7at7932lA2xiMG73tHtcD0dm9eK7M5YWNvKonmabU1IZXTtWjuvj2ZkjMfcF3I45WaMU3Y11jHC99epxKLpC9PUOsd1rg/iKuorKBUpP/rRj7YKEqZnnKHPbHeKHTnJx2EOKJBDqyKbHZHDwxxGXqExIHmejceXbc8uyjnvG5BfnB2yPvYDV7Ey2gDaWZTIf0WxMpK4FCgzZfrJRbsUy5MLr0iL8kd9nW1AzHPD/JQxLTFbDlaZ1YUFi+h7kWPNwUSmfzOqG064oUuhumyLXvU3Xa6+6cZvYrWc0ZZy63u3PWVDLGJY4inqIi6bj0zv6XZ8ZbY7vgCds9nuF7qtjZScjtVwqL+g3ylz0lgZ99QRP+k4bfxK52ja/OfSK6LMGQwi3cWJtoHyHnHyKk9T0iJl/FaP7Tz6iZ3pLccrPCI776fCaT82cYhDS2zswDnpm7LpUy6aY5WlP9kTmXcIR/wBK8v6HnLdNwCcr3rQh5y96gGO8wuy9mnKJe/m3W7coNGTC/Y0BYjHOOR07dm5Kr7umW1RVC2c076rLrulL6c9c0FinD4lWJ9SZ+gsf+9CuIlLheH4m6/QNe5j5zBRh6PgeNdPtAHTb+F6R5e1PR1bCzt+bXuHy2Q0j/1ilQm5lGV9dMH4iH1lc+rJvXuMxnZjjEMe3TPDUDHaciGplg0+DJlrot3YXxj3yy+/fL1I8f6ErexwpyCx+qjYyQqhTro2ZDXBdmMfB+N5OOzIFp/ygGEHwiljY7Syu+2I4/Es97oeC/DoQ3Zf9YgipJ1jPAC0UaC0mbPo6cm0HfkTh/hSYMDGeo3ZK1DsPMi5uuJu+hqrbvoMYgdwFTzj+hp0/DRHYPrUwv7hFScA8EtxDTPeDwTdvEFe43TFZcMg47djsbbW9cbBuFz3C7+d9GU5ql/nekf3FDfLEZPd7bfUJnPpzsdF0DLbDmT9Q9tel3ksU17MI4BlbUzZ1ajJptzmsKBvqtWvlnCNHR8OgBbo/DxYVH4VOS1S5J/CZ8UGgLJeIvrJeCDSXSQxieNQOuX9o62HA9v8vQNhyM/NX/m0BwKR2YM0Kz6ydpVTse2Xh1hsI1fAeJWj2vNgP+1Eu5300Ye8KWUhsBSN5mnKjHV0bwoUb/EvYz2Eb9EGoIuQOcwDfep03JOPizfXi2zD6KDHptoSp06JBb+rhJLxR/yWO0yc+9JDdYOx8DZ4FpPksU043KyN/8U8OTykjbXfbicHbvVwTw/yB7iZXUW24y9rA05++4VuB7J0/Zyy/qH9e7IpX0NOc5TJqzGUxqX0Jt/q4tLpJhvLIgl0grW5bwz+V199hV/5lV9xeWmRIp+k2CDs5pfpJSS38gSA6VozXzqUkzg2+n7ywB4WAK7DR8oEz5N7T1KYzMbIxjCupT4qPCIb2R/LpeYCcwGOmNspkU9T+kX+NMX20Z2iKe6pM3llT1OUL1OgRMXLsLdzPttNzA/Wp0DAGSvjOwUL8y91oy/RAfWzyCL+VJHi5wXsbjYW7GBZ5BKM07ifUGb9mO6kTB22hvtqGzD+nevdduQn0+/YZpxde8pP5me2+8V1LfnWL+NZmeN/VwbwcUVypkvX+ClnMhnQ0qPRT3EoV5JAJ1jFvSLiffnll68VKcvm7+gq+oyX2bPDXnHGQQvoCbcbvDloANCCxZPbV0JzAR2rjB6gJ1ojB3tQnFie9cty4hUsug2AvqYArqcna7sPtcn1fPkceW5r233iAD9fLD/senLFXABiztiTHBOn1C/xyvEY2bimOgnBA8T6AZGJtTv07fwfs584hK/iRrKDbL0CJK6ZUj8e5acZLrO3MqVqqm1lVr8cIG9s3+Vmdlb2ii2TRf529cA6b5X5tuuHrm/LC/wruXFF15BzP1XGO+WFcftycgc1RXBUNm8Ly9EpTaI/WRnhRIUXFik//OEPVVs6tAWF1XuciJfZswEpTjunT4jkQYXzUJ1FyDhkT1tWsDD5ztOVGfMpszkc7SwHHq9qF9sCkHE3MlbWHrk5cyD9jptbFjOuL9F3JT/RwdjJWF71jFjmnA1TocNx+hR6W9QymVeAeU/nFK87VP6ZjBUkaqs65OU5h8rhe6AOpdGf6XaJY9J4fMu82rFYe6Vqa/82xg3+nbaVRfyqLuuz6qfSzmQZP9MDzjz0C90+ZWytsHXSP7StJ1NyK1u7K62VTG51pXuGjWHKbV4N6FxQJqGKOP3hhGO1YNzvf//7+L3f+z3C7rj9JMV2VilaBrLiIzpgLSbnGB+HXnCk4GBPUnBci0A+SWHy6DXRckAQGSsWshxU2wMsd1a2cEaM8oCNipWRmzFUNq5TTw92J2dRfrxcqTyIcQBk3s7+cfQ+ZJEx9AAWuSpWCUeOkRVJyoejm3EzvpBP24FGfEuqc/8AWPL5BEqbr5SzGJrhk3b/EHM3VHRzbvQaWH0s+sSfbWf8HVtPl/Uh2zvcHc7deJTM5j6ac9T66cLV13XZuMy4YTJgI4ZNuRvX1VAXykNbJAqN6NvqINArTaDT8MZfxe0nKYDe+CKdheR6xU1WyAxM3pzbpjZvWnA0cUiJRbHIpBxYDmwlAzkcjWz6OccSFRoZx2sPRL6mzMY02m0dq1ecjAJhKXrQD1x7sLNcygP7QPw0ha0duV6m/sDsTx7wrNAYOglZYHUKL26XAsX2CWgfYqxUZ+MkfiaE7eRu4NXNI8MST5OXq47Gb+VzCppqT1nQBtYxP962MQj9bjyVa9a2soyf2TNZ5J/JKIfNV7/Q7aEv9NOFxpb5s/3aeSnM1ZNyN4arscqE3MYPQUQAACAASURBVBo3/c+CluoWaaATrIwgILnf//738fu///uUFxYpw4lXcMhOtosKh1c5dCUmTxy4am7JU48pb8JGHLyTD3EgC3v6JMUUK0zmFSsAwgO40s7sKFccjEuMztMH9RRBxNzaVZAsuTyE/enftlX/wywpUNwbQsZv+7OvbkhxhUPkb7TFeFjBMtcIGePAlJ920z+wxCXMLhmBKny0YuqBde7vILun2UY75aswlC/jmulpYXvKjOvs0HyyvehMPHd97djZdsa9w8n0lTawzmF2OLtrueW2yzphMuM+unfc8RCTKteN62rYCyPai/fSqVagk3Lfn0SVx+AWKdFv9QBQh5/leAWF5QGxH6m3/lur/2bPpGy8+umidsmPyz/7TktYrHQnU6baJ9j4xrXUe/kYiHiMexw6JgDX040D6/hl28Z8DbjLRn5lCAeWAoI9TQH0WLz8yPYcGxkPgKXAApwxmHhleynUIAotkremjVdfgr+DmSPrf1w2on8TloPIrINITuNrlzw8dKwf25+Iq3JAPNlO48n0QeyvtGkeEnsry/SVNuDkr1/o9tATH92FTSSX9Q/dx6Um80FkgBOHI9/xEd4fit60iOgWiRvzwnR0ShPoTkZGMPjyyy9dnVukZH9kJTv8GFjxYg8JT8/8q37E4aYWJNm4L1pfQLYIGR/0cAb4a5/RVzOHz/DTLo5qn/AKDTt+lq9MFnFn+4A+zIHlcPeeKuAwfqO8tUmafYw8qIJp0IoFioLwDVzjUWPYzKM3dvUEZExhEzojn76g4xpg8Uksxcm1bHSuoe1pnt4I1b+6LMglZorWXO0c9B6f8rK28SPbGddyor7SODbaGfcpzm4bwDK3bI1ITrRWQlshU3I7P8mcZVwgGCfjsv5MbN4YmKDpfxZcoWX6KXHkgrG5t1j+F1984TCTJymsY1ZIALrTCofxIn0aSzsnUojk04x5wJzcqTcHDyAOqFPODhWvEBk82j5t1aF8YowvG7PksJx7OVTy44y/tXmNdo2PHu7kKYOUzfGJfHpF3Ry/yOGMRyAqSJYi4hDjcV71AAifptD5wLpG3IJFjksWZDJnYsxSzuysT0DMyYCMCVduLXY3kafADoIlxkjH9EHbytwDx+Q/87vTZro5lx4nOMyzg/4u91XZy/2yHPYL3T5ldm20xv/qtGfvyaY8aFtUxuPJI9/ZepZSdaX0Nk+rbNXPVqKX8iBBAlXel19+iV/91V9d5NtPUliHWbFR5d3Wz/Px0IuBvN6RfDn59oAaB9Hk4Tr8xgFlC5Gu6rLWO9Rt6L7k+CKZlLOD2uolqFzGx15RbD55sDZMthR18gkKxHUwpigHY8NSuT6w9TSFrTe7QVDZGGvT18oX1jiU7lxTUt4gvhAMbTfXsuBKkdU/DW8fcDfZfsHll6Cszzb+7JCc7cxnhdOca2E72lGcyp4dgsGYMn6Wj7scJtvu18nVkNl14PonXM+nklmTwhiVzsypJwN8P25eFrEYCdHNK59k9CuHh8h8E1akDNBawxdffLFXpHibEAPb3DMe49zWj7UmihJVsByD1gX2tQ9w+VaHQhOb/bHa0++fsKcmhz40ZF+tkd+MKRYxEp4+lMv4klc7o5BQBQLhDCg/ow3Rj8hLa+ZagOXG5m/ByLcY3xKLMHMLlGxO7PidAmZygKkb8i66bOy6X/obcvtEBVduAdHfB2LEyjZ/70BQukA/C1nr0/DdA8zhM/krbarrF65ssYnGQNb7Dj+zr3C8PWgnDiDPlV0XbE3TWBx7T6bkyl3D6l54MDpvjbtrgKeR6ny+zPkqW3WcE+md6T51gdLBrg0tUn7wgx8wMd207/LkQfOKfh5IgF4EsmARmzc7MLr4PExGv+RwqRy4fS2Z2KQM64HXGvmLqYJXkdmJLxctRx8HfdUzKOPwhenzvHFmXs48KD9DdvJUbuQXZg1snKxt19nMo50D8jSlq/icy36kbwlWkFgccJ6qFGwl7LrrDaIvOPTWxdNwD7IRo9N9ttFnG/hyOCZ8JesX99sZd8CzIdesDZBxBm13LhJO1keFV/HB5pzmc+i8tduSXO/IFjfrHGS6rbW35Vvml8szHecAvm/N2d0+KvvNP/7jP+IP/uAPFnn+JOW4NkGqPzkS7KnB4Flfu/qRw3lYN7GwpL0wowWLibnh/Iuox9VGE/6Ok9MvOid6xdOdXLHBPyCyn9p3ipVIJuUzzob1VQVwjf3Q8bKDnb1WG7kAkBZztrDwCpBquwvXeVHzCagCghUOdPxkDiVvjL3qb+qitTGcLEMUedUKrS9sEBZ3bCyizTfTe2NWeqHLDsOF7/invGLb+mTteW9IjjOOtG8yR2keknaF462NiEf7MeOZsn5xXbP2EHvrlPFlzkV7yqirBtuFjYvqmLzU36lfxnV6Xmxkjn0d11c5AMuDh2xsHry5pEWK+j6KnGyz+UmObl58xc18FfTz8hyQOoQ9e2lHvhMweOrQGgfKKVieDBCZPXwBHR+Nmci9ticb8gpvifPALM7G4lJjF+by4J0HoHmtM2S2mLOFm81LlKeKfrRbu8ak1qF9QnQAl1o/0QnH33IeDmd+LE/6MH7VZqeXy5V7FZy4bER/wt3UH0DkO9q4Ul2/4PrgIKQHQ7/YkkXtHa5sU3m7PgeyNkDGzQqChPOUTcaj/RRzJgxWmSdnPpx+FiaT026Zn3xcC5en09F1AZ8CmW9f53OA2D+ueRT7aBXRWL/44gv8n//zf5SMFilfftV/Z9krRhrasnF6fMuVh1X/EION9BKH2KhlFg/Hnmzg0mby2nrwqMMYZ3v4Zk9ShtuNAmPovMOXyaqFzpDNg97MyXzVM6dhfUWx9D04gD78B58UCKqN/EmIzUclF8sYAd3/gWtczcztaIu59/q7FFA8Jkvn3PYl829iUcWJnn49niWoj8OYA+8AkzwqN/nIdMuByDhGRtvaQMtJm147bWs71gj1T65ZGyBjT9pPcNx5S/xQfTKmMI+ErxUrl/poRrK4a7Bd2Hmr6CrrMpMDwXhPA66W88D0NQ7t2/U31H6uNDqhXKSoyRSboSpCvOSazVMe6gD0YUb8MR+MKxfaPLClfBzCQf/D5rjIc4EsxYnz1GSRDbfBoWrlQ7dTnHi+ItupO6CLizFeMX7pY/ZtOKxYAdYc0Tbiscjx2jFFbYmlKJvD13OrxiI555BUf0Ru51Fyl41S8JlflX85DyLXTNdFPA8ebKE74G+ENWSHU0UX6dnGZ7l2HdN2v9DtixDzWqxTbYdveXMMjr8ps6HasSftpzgVGyuj+iRvTOat9cV/xacyade/Rr7KSByqm9U/71PomDy8Txp89TmWRd+gNkTKubiebu7jdp+LwjXI9gCAFClfffUVGvTj+YGGNjdoC8bvzctmKRiIP8tR3E64eEPXLp2Nw/bBnqTIhSMPC1WIOE9NaIEk5bjis4dCdvgyWzupleLkUpj4z3W6HNC2eBI5mTkC9HdZ7PyIpyf26UYU85B7HC8fsr3YHqBF1BXyoYs1wC9YsObJnRM4PuSYTG4Z3GIHoh+tmHpvE4iKuwru2EY2mb87B6TNaeXQWHLZjKxpG1d3tvtH0IeUZXwbtw01yVEpZwHHm6OKnPo1YyjnScLmPJK7+TRM01hDb9LU04Rjy+RTx1MLHleXA0h1x+HZd56nC++hAF5eLL744qcA/h8lW4qU8edppVNZENAODj9QdtAz3Smgflj/indcvqZcbNQqP9GTlFNf/v4J4B9Q5nBlXKbL2lLmydnBvjxVANanKc5P+PR1kLUffJInVSzgSGO2YDlhY1wNybo45XLeVbFlnq5I/WV+AIczn9AFhVeERL4bxA8JEHMm5mDKL8PrMvhOykBWFGR4xT6z3dXb3NJ2v4jbQpbZZT6y9nVZ8Om0pyxqs+KgINttezIr3ypWeoPKvLVNY6D5Nx5Ioyk5k/XG0iMbizMOC5sLpQvviwZfvep0uxGZ0G7c60s2QtO2XP30p+tfng1f98ymPdgFlkLjUgDQQaunGMc6oPHTtypKcPKUqdb3eW3XoXTKqK19koJrfOpAEwec9EMPPaBcnMgCg+nkQezZ2kVT4bZ25YH9Sm52uLL2zEn2qgfQRdLogxQX4RMRYxPqz7jUPNnxj7UxxsOepnTiaa5zMGXCv9Idh2pLPvWNKz/tUiw8u6aHnhYvnwiVjS3jVA69KTN5ZrKZl5a0A5m0cXWsXZGZ6/4RxCTb2dgLRUXGyfSZPJPZcTFZKaee3MqUul3/MrnHXfh+H+H4ClyLe0WLFkYu3LkNg/JVXZ2Py2J9kvLVlyqInSJEqaPXKgDQxAZvfFmfNgalP4SfJnRGvtjOri/frQfV5U0fBrSAEbAHZyYb8PhRwaGejgAhV8nHOOWTEJn7JuxHuw9Wt42PZT7sqx7EMd7JgcVS3Iy5AtScAus8Txn6+MrFySH6EHzVFstEFRgqZUQ+7CzPxDbkXcRzk8EWzgxZQeGhahfxssNNycUczXa/iNunjOUwOsyXOKyPrG1lTlxKRvhTb11HsTryLN+ZPpMv/Zm4w7F7MnS/9oetwef3qWG25QLNyFaKc9dV4ybGu/eC1B2HjFlpTw7TXRxPn8XMQDMTJeuE/fLsWqR8cf7XCOXhReD9lswAWyiAOZCuWVNYCgD2mmgqdV/Tv5SPAwniSY1cMEIv5epgP3n2CcFA5TDe5WftrK/l8B/jbOKAFaGxwmBwWHECmLx0gZLZsdM+Ak41T/TmHcNv19wPuVewLN9FAVKZhFybpSczEDFIf4YzeQ0630NuYf0RZIXfQKavoOoj24RLMrOu2T5jZTKHNIZ2cRZ90/ZL+46Njaugl5D9LUWBk+OMV87/TVk4T6ecnStq7uR107ZWL+VQPla5K1MXvbGMlPXNxriE1haZxTpHC4PIunxeOX1k/dN9ZyUtAtfqVPz0pz+Ni5Th4m4R0qlj18eCebBYpWhK37JwWPSzG7Fht0snD05p19C0rdQL+TjYlwP4hPcEwMqs3NN5B/NOseP1j+Oa0+w7FotPHHFxwvLi5CoaU1Z8eDbM54hhQK4Z9fTnAPpQxNMfiDzh0luZxKK3nONqL8XJyaUx6InqH/bpldSJtZrBO6wy3LUD/Ln1eFUdlfVFSNvZYbe0h1j0sx4QN3zaeDIbwr9UerzAZrxFXjX/nrw8V/1ilZ3ydA6HmMXW5j+XhaKdOqIUplOy9DDDL8SYjNsiu/9ifUOkTn17sYv9zYLNiZswAlWkjC/NAnEioyKkU3mix2GoOJfRxZFi8n0Yr/iYentImjijwkTK2WEL+IelJ7PySFd9ipDZXsJrXOzQ7ap25V/2Pw5K+cVSmS972J82UV68gosVJJU8SE54g8k8mDEAl0y95hN5YjKJymuYqDiRPHstuYtsNAtfln03WuOvIBl++ctflrjVQ87T273IbQcyNS+2b6NnnKydcpzYp8yGJMd/o28mq3A8+c780vFEc4bAv52bNv/RHtpyIagylxAwfpzYQh2Ts7H76eucjfvhDieKb+jpD04XoSoEAPzf//s9/OEf/uFsL0VKa+KLq+teDEAELfqxhyeDOgylc3EpByqLBgn12yTswGjtOpQAPvFEb+X2kJz2YkIrB+iQeZu4LViqPj2dirdd4+of5qCU83Hgmv/jmgv3i6ZDf1zzpGTgOZDtAY/n2WR+F5t2xYYD66F+yuYaIK+D7LiH3dD1phiTsW24civ57s1t+sVsirHJ+XwAabGX4KUDaoPryTyd3ezDg6+ZNvJYK/Fl7UVm47Cx2vEYd9LXdt+OzMt5lefpsvlRskuQztMptJanfP5z6dcLNCYz3MX/DH+NeZEn42bI7tFX9JUYlrxXxhmB5HiA/nYPC3Jurg7YoKPChU2SLTjc76KwSe0ExVkS5OkDO7Zps8M1OnClLNIxeJzKAd8F50fwpVEcp7ydh6bzXQpZNLbjKmajHEQyb0yS59l4hR3jLDZjjtm8H1i/NC1/e2m8KhuicwhLsSD0S4HRRGySP9LB+hVrcsAtcKSvBPYeZev0Cez4y7jVA5Ee3EZm96Hw0GvExnIKbSuj8ctYbL82/qh9I7Yqr8LJdIsPb4xCxg7EkuyUD0dTu14IGpNdF6qHk0BH6sTYP9RgF2T3Q4WT6nuAsX4VunCyMJT2IoQqUv7x+//o8eggDgCIChF7CAGd3xrOE0LzTQf2ezH2AFieopiFsBRJQq90nhxYDsAhs1w5Vk++Y8MO8qqtkssbwRx+U9bEIStf7bBfURY+ooUYxe/lxHJlnj0dazN7wPR7kDFImciLWneDLnLWm4Jj9LaPoZcy9RtR0asbZi/ko5Bk65Yh27wi3LHdsakebJ5s6tBUvsJDz8oan4elP8sjdsuBnLSZz/5B4remwlclX9VcZ+1M5/bDxmDGqWSnvDQ3J5eyZZ4Md6XEXOX7jI3+IMHiZmP0U9vVhXtpd34WTiXOCCR3FXzve9/DH/3RHwEwRYra+AFEBQgw5qduo/kNaHqjhzGVSVC8OYdi4IfhYJ2EnUN+h1uV79hkcUhdSX5gLU4gZLYg8Z6meL/VA507Nk42xohr7artKTvjozlvYv2McQxZkKux8UzddHxxBiL90I1CUnLpze/5d/wC67p4J7w5iVDhAJzn2brynuRV1i90G8YP0UtdeHBGbaurymQ8SmzaJheVPFbyGs1bxT7iAc64rsYqO+WrrEkTxR3SqWuqdVFt3ISrGKbP9H5k42E0slcyvKy/Aso5nr54Xy9w7Pgfc8OYB210AKgXIXP/PBvjcGjKh52c5ekIgH5+2FgMr/HkVYoH95AT2CoIArmns31nfqXOK4SUvMF9bTP0siCxxQstTkjOWdHBxjlkEVei4lfZHqBPSlS4bBzW7sBSACw+sXKq+ob1jxcqiBgHX6udfgtg+a5shBGYbeYv0w/s+PY2dfcAlPl1cl2WM17TbRWX0VGZ08eURW2bg0Ies3ZFV+knkttxTFm/0O2h9+IUcsVoWtL0P7FsNtoqOwX0vmTyZJzAXu6q+swWcMbQFbE+QqHfAfok5QDAipE+T5dzxfD4s9GW62P8q85S6f8YwgXZl2cnb/RVOMilzOrZZm7llSLHs7Gyit9ybOygM4cnAFWwzJS2bmttlsPS9FkZV8U280tzcOgYZ/7aur5U+zgujsjZchOOPATFQ1pcODFdhKD/Uw8ATOXB3gPyN2wGZB6ze2AXmX2m9zie3Rif1dNDvV/oXLO5Y3ZCZ7lu21s3GcfKbDyybcddyF3WznSvyIB1DFPWL1bZKfcOSjd+uc7VhZCbtqYQe2D6Zb3SWIIxecjuk3DOSC5DXm/4ugqW+8+BmoiLNYuUL768/mZ+n4NOmltYsQhZWMRuYE5nAy003C/OAu7ksgID0BOXyaONOpJ7fUS6qP9yEYLEZxM5YofnOHTNqwT1U/qB5WlA1GeWV09+p5BZeE3EDPKEBbkvW8AMW2DNg9TLwjrSexvJTvHSade89g++/gHeZ7bhRZyKLUPFrjX/8fZOPEPmHn5Cpu57pTA2RsbktG11jM9kLYnHxiLHUczfHZtMV/Hj2pI8v1KsYK4DXzebO7LZ8P27uZvD0WPQlOYELTjR3FTsB+dAyHVzO/StZS4u6OQt6n/4h3/AH/3R/wtAFClffvHlxRV72zQfGx8M7EZo1WLyFlshoQUJm7CuvDgG7GarFBhSLrFzwEZyT1c56Md1ZO/1N+XicFvySL5/ISdM2Q0/yPvcHa+UyTYretK8H1hf29jxE18sjgbyV4qnwZUP63vYT5C+LbxxXYS1D0DMidBFm9fTyOaHIeOwe9nTV+TAmZ9m2v1CXTO9RFUe+Q8Ljzs2NpbN/O3k8xXuzvyEsn6h20NP9g2hvC6B62C9/hFUMp5LucqEjo6yrbFmY2MIc5jdVySfp4KCjqTJyyAPVMFZbbnomEVKO/8HAOTvp2EUI2wy1q0WlB9M99nnPBWXxLCnKPawUM3kMIzkEhVbqYt8Rochk1vO+KyOQenAD2zgzONIPXmaouyCVz2AjnF3vFIW+Un9yjjFWGXcWb+27Y65BTqs45V6bzPJ7BUGNaFVsdW3A2lX8VHhDFhuZOvp7Ca9+LxujFA25aQbKV/6M768Q4vyHN1lmoytmL8qz9O9IgN4Xivzog5M63vey1rGIuhUk4NLcbW1cpUjyB2JmQXjrbGpT+4fb61QXgPsWUp5XKE4h3DkuqMKLby+kxLnaT4RuQTyMDMqQE3mimO5HENhT1C6pl0HKSuLjA07yKpyiYqtp6seUJVD3rOtyKXuOMyBLQ5xwOT5xkE/5Ko/h2PlVhb5cYsTGecB/jQFcb9DVp0/q4/sAN928LJNZ/AA6HlzeFk8Eu6hUYgpQ8VHxtmNL/IXFRKhrF/UuC1p9wvdZrKoTYZoxy3bO7mK/Fi8Yl+dJyXrFzpvFwH9oCTpsTE58qlz+aql+zl1q2xcLgNadU5K0nsks9edMQIRuc5cvTcviaBLhfj6TsoXX7iDsnXDAdAJ7crDdTMpS5LEBl74HoqbsBOVAsLKmZ5xsiJD6thBwHTRgRnF6x3qO8UDmsjnKVp+k6dw0AP5AS550Zgth/Fp33YsgyLGFY7DGVs2VxIVu6GrzLHkS1RzLNeDRGbvIZuHCio2GcfT78grhYUnAxyfram1V/HHDpWsGMnawBqfG28iq3AquorfUO7lrTdWGaBbwq8nv0ReDOofqCshl7LsgO+X61gs0nuCrAGluxohGsQT9IBbGdclSp6sEJv/+q//wq/92q9dRcpPv/ipIqhtzThoAGA2vtkKEzkOP7gdyNcNXdMUlz5FMWAHAtNVNu9KAeLZsEWVFTnZIcC41mfFt8I4nE+1zHn2NAWIx5TlKytY2GGuxnHGNWUibgD616nZuIQPb2x35jfTS1225hjHQ8V/hGhsFpYTzlOAV3iRrcs/ADnNVb/lYqWR3BjbsDAR8qwYWdrOnFiUx/yCPyav8jKdHDc9LFuXm6kWejs/XD51Lv9qWUu2LnRTTeSCcpHgcCL/pb4JosLE1U1K3KdVLEXKOgjMDX1ANe2kOUVLg7SzQZLNGO06NBRX6ANkG3z1EPE43gZcKVqsrlqw7NhHOutntuUCEwc2gOvP35NFWClOhizLY2bn+rCx24JkmJxDrRQsA6r4GTISx5AD+ZqKNuMq2Bof2PWfrXdPFqF6MDFk3NbMvFpdQYa2wXXkr3Bl2zto0mLEtAHj96H4WNuTRbpXZFPHcnA1VhmgW6fvpQc7XiLTuvkP1JW4sDKvkNLNSV6phXsoKwKyosZDZlcZmw9jTezcP+YGgCTxhNrIh9JfHE0yla2NiB+a/cPfmCV2DomsoGE8z97KW4t/G8eTZ7KMO5D5sYetW7CwvzdyIutjyDOZF8uQ2WJlYNocWAupM3YA4X/FGYCSDd6UD5x9VOYy0zFk/ExvERUyEhVfErt8i8w+03fS+GgAobtyxzeTv8rNZJWio8obft8dc5Xj6XbiG3K2f9AcrIJVpvTWJ5drMbG5DLWW9R/F7ISa3Q9hYZP0v3DirhS2fa/KMr4B9O+jqGQc6mOFHde5Icbbok3mWqLIXyuaRck0y0flbczVg4VxGC8rEuymwXReH69yJaqFz7IR2EOfHNDSFohzMfyz4oPZem22YdlCShYgM3bydIX91tIAK05mLhKwMUldNqeSG+kl6EYu8v0uZBtohF1b7xCPdJ+6WKHtc/1NmYnRO3Qi35VYInkpboMd/0x+h7fodOJWmcVpvzBkH/qfBVpF/Nk4orioqG3JKe9q+Dqiz7BVEF2KTbSZ45/85Cf44z/+416k/PSn+vsobizHPAM0vMkHcJ0a1layj0UkD8cqvIUfHeZsI8847KBhfe8UCQOVzTs7CAeyOL2iod8PJ+88wO0irI5NwvZTiaU154vAY22MWMcyY697xPSlr3sm0fi3cuT5nSYk/so8R8j6jOQRKn4t2P1Ssa1uvAOZz+oGn/XL+tnJcTjPjctZTFR22lXiifK19F8Yc4UT6SoxRzIgmWMtWGUWMlemreWLxNVJWVQwlPRRbr2xLWmI+9jlSeza7BZJ//Vf/wVA/p2U1nDtT2JXl+DrQ9gxzBk7rwj5sH9rhRyWCaKfGtlhYnUSlZ9i2Ua8W8zsFBuZj0jnxWm5imcPaXE4S9usKGLyim10gx6HiAvAKEbs6xwlw6pf/nKsCHspXGw+Etw57CObypqMEN0fEjsHiQfvz9FXkG18Ux+4/joUK1n7rizTe7Jq3FaW6e/Kd7ie3Fsr4f3ZiFaOV12wPheSbeZxNcw9y8Idv+Mz5F3CJCe+yqIShxfDLkYuzH+7Z15NWWVvY3n1N0VJPqZIu5D9FwKAP7lAfvBVDoDs4JUyayPllUOd2VR8R7qsyFlkcmEf66Ed9eHFZMeb2Xoy5f+MDTjjPW/++bRDfh/F/peeBV9uGvZVELCOf+i876lE63EgW3d3Ch2GuwVDBTuHytStN3wIxq9shG6xYmLL4qEHZGHcVbunfGXtSHfH/47sKXl0SC5rojnrZOqNts1/ItEUrLq2yNx4m9GzsQShTw5XxJwoJU48ESqFS4ZovPEXZwHYdVKsGcQCuwxW25WzMMhCrRYuA8PH2Kx3DoeMI+WR3+ohbHVSnxUakW4n/iVH7VqIkb8oj9JnFl9JdhYIMzZRTABYC5LjuglswSJ5/ZL4k3eQ7XsDH1F4ZOs7wk6RZXHLprjBuQUHF3JO423Fi2Jgh6YzZimv2llZhcNkWTvSZe0dWaTj/AbPjZtnsn72ChMxT0pOpV1iiMyOrbFKARDmkYw15XVBrHd4EaqxSFTGz/ANoCemHyJStR7Unavbeb0gFkEDqN/zwLg0sdOdzZAdCta+sql7nOjQ2Sk0rA3z5fmv+rkTz8DdYkfKIk41tilr56K3xYQpTqZstI/TuUjjfgAAIABJREFUTgyDFSeDXypODuGDxC6Rrd3qemL/BeOBrA8PXuFT9Ud5Ip8VRBtsZWOMOB9ZrFQ4r8gyjjdnVXnWjuQ7XMArTJj8nLHK3J+8vYJl/hOJpoDp2NqJ1lOq6xex3sM0dx24qNxrEllhtAO7TpzXPcDoJStC0v3rsF99tQaHSKbHMRgHU1LMAOuAgfUAiQ6DjGMP3tbqTwyszrOR8uohlvVdLWKGvDr+TJa1PdmQL7yxdrzi5JR1A3E9ReKpysmlRQtAv6dC5RvYWYvVg8ODV9QMVP1VeHKDVfm8CCnCIuJqUHic7UMkGGvlgPbsK7ZM9mo701XsXx3TqQFXOcUJk+mmp9FocWHS/AvNMU6sLFy7TnjZfUXHRUVeBwVeHMKCaDwRsrEO/OQnP+lFyve+9z2XZH1lRcsCtSgO9dEvbbCFDub8JwM9rg1SIjoImD7isEMk0tlCRuo8G6nzuJZfLXAy2ZDvjD+SeW1PVrI9ADRxGJriZD5Badefe2ZPVRZ7QP9q8nzidyj/o5iRay1bYx7vHfDy+hQyv959Wt0kS8XK0B+aZ4uVqMC5e4AwnZV59lK+00fUrvSVybP+7smrBQiTt+tf5sOKTh5fY8KXki8XTn9daHV3ChMgyOHqKOdYfXbPp2o+ph2kMQSYRYo+KCzNHk5Wf+E4DwLrRGzd6gOkRIH5qdbWGJWnJxPOIs2KEnagZAdnprOyqr/Kgc/4Ud9PySrcIY9i94qQAdf2pEVfnJWFiPyyrN042BdrlU/bz2WI5RXQiMHJk4fKuovwRCG0GzNQ50VwN9s5JUbf5KVqxBzmb3GtuUoXjNXqPG6Fd1eWtT0Z01Xj9+T+4VwtTHzZ9a8SwczsgiX2Nv9x/C0NGjsde79Y5U6AWUEQjmyamv9yvcPTIiosIYt5F2xtLV+ctZzjqPc+bZcJA0j1Y0qUQ5AF2CQPHPKSb9AMLBHR5pwdHlHRUykoPBsrH7pX+q4UEju21TFU/GW5Wmzn/dGutdCgipHBYV+WHU9Tpg/J9Xx2wmXfoOQHzidl8L/YahGN29NnazKCV8wAsY+K/6iYAHDllOmUqskGl2c6j+PZLK71elG6xv8a6tBFbSav+Ink7/IVyZic5jeYZyAoQqZcjE03Ly4M5tQ5nTeiMX5J9wZticcbbzV/i546i/VsTYcFjuD56unoJWTjZdj+7R6JYK9boRydm+51iWz0tAhJJstiZ3POfqLMColXdBWbO1zL3/XLbCtjyGwzXyH3LAzm9B/XWjjaMdeXKkKGDymzBUu/mOuOvQKyxUl317Ru2GysvQru2DyNSgxp0WKx0JtscLnRz/mXheWgtII/LwYrF76Ww7pwKDFOlNNKH5n/HXmZ1xf+ylvkMraV7cmb54OK/ZOAjsezi+I7tL4+fqFL7p1oPS56gsx/J3niuO8IpX43UXzdwzsux2OcHksS/A18oKFR2t0nKNGhAfBkVwqMp3SZ3PPzJDeKocqTsqwtZVY+dFNmC4Nh1q41IX/tmPoAZnFiN5SlOJF+RX/L0xQDbw48sHVZtbXw1vhdfxJ3fcgCwsoY4oPFsZ1T1laO0UlZJJ+6ZNjLAZ60d2SeTrZ3fO3IyzKTozhn5/wovRwLkfkXvJtm5lTI+8cyyapBulF90+W5mdfjONK15d4j3jgYlqHGPjPc3QM8eP7S1z0j4uRMj6GcHmiLr0t/iNZSgNC11gZ51cuDxIAlZLdwiQ5Uqd+xy2wq8le5FfusMGHy0b7T59DNdtNzz77gioZZhKB13hKD2RxU0SJ9SL8A/37KVI4P/jogWmfRjZ+tT4s7m4jto+IjOgQ8zEKPmjbZWGWanOvPfkp+FeVaA5rSFpnSm5yVD/iizNPJtme308fi3xk3k6+yM5u0Kxm3lq82jVxJQeO6ySErhfW5yE+d47iaQyajHNm5l3OGdunC76ZIJBTvPriLyp4ikb7uGfD82n0z775Bf83lUJdyUbbg+zCVAubKrVbu/IS5c6BEG3ylMLljkx30zEfWX6Uvprccr8B4os9OOtfBuDFHdw262GiX3AMrWqpPUyTkq6e5WWwe/N6cZXa7YGs76yPTD9zeHJu8NAST1wXN0UmfNn7m04thMW2LTOkrh9ELMiav2kbzWPJJxm5lPD9NXR0ALve2XyLzLzTzdOqOso2PZRCmOYkUr8zLkB/He56kZPfCLm+hkD396X2qtYbju9/9bvvud787hcfR53fzh7Y6HMeHuGpoaxFiIQ4kj5r6OLHzE2qFG3Hu6J6yeUXG5E/aZnmV+oV7jA8hJ+7k906mjI2B8Sq+CbJxVTl38A6/dzegUtFi4PbVEn+R3tM1eakahOofXDuH0x1Z1V/F1658q1jpF7RNGpd0itv1r5HRloiNex5KMvtqulVjQVRMVHNeuYdKcaxCpVc/UEXIwwnH/RS8vLive7w8vrzvKcfXYWCXmJfYYzXwF41VsMMMa3KizT1aYLaqtHKrs/14uoo/z1fWdyaLuHdsszaz9fSdBPpfNu6XurCwN5p9HMqevrBXPYtvmLUm1lk2LiBeUzt4wm80HxbZRhnB2rqPppvTT1EfjsOzVVPdFpnSMbnTZ/XAuiurcO7I3UIkydNq1/SVo5sSGstCCuVUpxQtDGOnIL0jn7IDQaBLlFLh6rK1varU5L2E1pz/ev0NfKO1phxm8PszipK/4NWPI06rQqwHyMRcb5cPNu7KwcLADu2qvGpjdR6iIsSTe+OOuNV+KnaerdWp9Tpu0lEYsO+mnDwAsxDpooZu2mW0iGG/tjxsJcQU2e+r3Jk/i931t4NKMVjxXbk3AYDRbIF5q2BBHqerZ77V8lnXkqa2RV7NZZVXlb3qz5NvFSu9EeTNxgwcR/+UuqYuiHwKAp3E6We11w3dr6WueZi6Yo4XGcuro6OcgHepXUdlZPeXxA7XQ2vtepKiDxnK30MlwOMw+fGTWH11A5yTYeiefXRIRjwP1UM702UHBzv4Ml8V/96B6vmwesaRMtaWsVfyYwsnHHCfplyUA6wQGfaKewhfTdgD7vekVHG0c9ef8PI0UF1/DFmBk/nO9BG2ciGpLbcN4wrsx3qj9m18GF2Tl6qhaU5MTG5lFY4nr/K2ZOxeGfJ+4cpWTmNNeQEZQr82Y2REqyMcnhmpMLO9OgMJJ1x/r84HQ3lNZgioleLoCVTHDDhfnM3sq0VMGkZr59Z/rAeL6SObhOyLtJ797mFQ3fCfLky6rmEkJosT8AsLK9uVe4WG1VuObFu7zJ7Z9GVzAO2c39PssL8+dpz6JkXXmgtjlMUNsKyr6MnK1AXzP1A9dAaydSiR+doFvZeKXWT3MUMWf6bvJN23smkkLqXWXE1b10Vr9T/0VpVVOJF8Sza2miFzxr9VrCiemId54c+hO05N8nVDfxynoq0c0yChXtpiLiNdtmazYuHxe7Bg68XsFvwPYf6dlI09L1pPHIHzuVysz7OdPkEZB42T5czeOxw9ZJORHfZWlx3Iq66dOuDaTeICYLQZZ8DrO/KRtaVdFktFLnXHueG0a6HQP7J2Cs7mMeVL0WJjlMUJmfKlOBFLRxVOWNdVtoY8RPP1JLx5yHCnAGFI+21JX47+tt82PoTO0Ow6GX09cXhVZBVOWSbHq4bMx8/k2rZZk0WnVMk8tU7i8tkw+SEyN77F9am35k6cT8w5AysKqT5DgebtewzV+DN4fsTrHqpXKJzhHKnzQ23yElHix2EQwT1EGDeNcz1wLNhhXJVnOqnvqqFvpw4YA1WHOXj/XkwZ37PPxpgVITvyKTtMUSCHMSmnH/tfRR66g8RobtLxxU73tU8T/WSLsoinipsMrJ+dTaqCck7mFAWvZAx/t2Cp+Owf6xxfl+tainK2c3BVD7KKnSevygA+LrcwETKePxOzagQ5cvRTEumG/jgUT+vXxhpuoyGm68nhhGuC5NfVa0UJ0dp+FZV87KD8d1KAaA21cULeRFNJsgeCUBgrHhAtQtScO3aFMWQT8M7CxOrHPTeKk2buKq9wyGSermJfKSwqBVFFfhyiOAGAAzjauna8L7/22kavPQs1nkP0ZX3BrKvj0nm59cY3EK21ylqtIlvTEei9tOEuKjBUXC3mXtPCOdEB7hZDnk8Vll4PUn5g9Rv1x7gZx5Mx+Y6t1UXjFA3CbVKlofyvsgjdNRnPvDBjB3A0M5NtuZAhK+La1b2CZXcOJLw5cHk+oYRqXO/C6P8b/eKBYKIBbW6oI8lsc8he36iDRInzGLxJ2TkQsoM103V5A+Dp59VMeRN31ihYpF2luJCoFB6ezNoMjM3Z2khbpqsUPbMgaGbtjBDkuvEKjVMdjVkuq53XPQDPR9RmiNbT1w3pRjmg0rtn4/KZPrCxc1wqSph8MbsE6sB3rndkWTvTlWVmXOH4jXyVmZgBgPbZ/zmOofbHprSer6lu6DeqyD8jqnnTcttFdh/uzovSX4mM9Vq4hayPp5CNNcL5nRSfsHE++ygG2LBu5itn9aUKkGhC7UFSRDXB2UG085TADmQUH5dZpG9Gtvbl9S91O8WJtWNjfy0fq3y2m1kXox6xv3Ej9qfw+yk4+AYg7Ox66k2hewDZeqogvZ9kHhNkRUEFYW6avCw6bePDj40VHal/j8P6szIvFGf+ygVDQbZ7KFbt7di83Oi8OFkWfTR1YWOBixYQLp9M30yf6oKEsRYmQC2XO/rUlqy3CNX7zKXc2GvehfR1TzVWcV68BHUo2ULC2UvthLgFiJrnvUgrGzmb2OqByzCKjM4BxgAu03HqesXJJevyvGDx5BWZ1x6y7NDdiWeBcE1/HVnIZ2HSSZBPUqbdqV5iNpsFfd0zu8nnWCLLj8eLUOm3womwdS+1Db6kjaWOwN7TR31m8QQ+5+Xm4eMWAje5FU4mr3JvFSuBTCZSNxvUpCfotmRc82JcrT5NGLPRjMy6z+6bl/U9aSl2CxiGal9PIhv/gClSakYMuj+yidb31Qm2qCtPQNjfsqjYRcgS6h0c+4WJ5ABjTmRhcpm2+bnqpV1cTEzLQiHCZB4nakv5QCVXbuGj7tN2FQrRf3gQwCxYhD17/aN0V0Ot0amb3fD8esjWGODn8euIrJjQomRMUm3n2oLpnTkRRDSc3yMJfIaHbzCEncLA02WFySv+IhlwjnEnr43IAIzNS2nactGvmv6t03Xf47hojNdId5on98+rLfX1vD2lB9acV7BzD1YQ7eGVMdzB/BVki+Pgc1z7IY4tTisQh4dQ2kPAgiV9KUBo93sJzA4Ui1rRIcZ5HjayiFg582q5QW14bR7GUl9/mgKs8UkZ490tYJ6ULzjDzP5U/pS3YXZMXli0SIXwp3QjBrMu09gFKkXvHeyua4u7m156/xl1yh9Q00FsGpE3ny9lNNfMlsXgpSmYv+rhJ2VuUbEhL8vM2HYKk0Xa5j+Xbr2gZ5AHd8xdSXWXXkuaaQOri50cb+l7IrfgrccdZHF5uGvHIM+Nce2+7vH6DePZ2v+8BaWTXXkC8imenEhEG3922DZzh1QLk9Zsn3tPU7rc/57ITiESyRjHs70rvwq+Y6ZSFif0uym9cRUtR5u246fpUZzQooX5G3r791oSsPWTrb/M5l1FjodwrEmXXhHBeOH3fpq8nAthlUm0wjwxjlxnou3B5j2ah6xoyPSRLNJ5fLv+2YFo8+P2PfY9JdMS0zRIEn2i+wjGP/9RF8ueu7qwBUyc5yon01vsFDL0vinavordcQ1Iu29oJ/ccTiwHJ4GkeN3Jw5iQvg5PTiSyifAO20sPXEXEZArdKWk6ecfR+YMjn6awgkX20/mjD19WKUSYHZPZsT8hl4XQlJ8heH/cLftuypDR4kTaDAzb2VRGvegh+Zn8jRvZy41Fpgd07t6B9B5s8rLGZbyoyHlrsZL0Y7FTGHg6Kcv0d+UuN8ull0Mmb/OfS2MuGuRudWENL5m3wQhzPVmGxmT783aHA9R5A946TNc29vv6KLivexjyczzzc+DKoc9d/qy5UnLbj3pycqeYYb7XwuTirAXGAH9Hy4qTVcZe/Qx5O9vioHVkdvxWVvUl5R6/Il9ye4AWJ4dce8XvpgCmf6OPnqjI76fI9VpdZwNRziqI1mvFF51zdu8mrtz7PbCrbKyWwooIr4iJYgr7tvZeDJ57kvedQy9rR/IdLnCOJRmfzZU7ltb/UdqmL5qSyctgPhxk67vZvt32JbeyrI8nORLjvqzaNbR1v6qZvh3ZGNLf7pEo5kNt1ho1B2ER4q7/mm/gXqExkCWUYSwmfeACYzCyKLl0TA+sr3mAQ7zu2itOBk8f+NWnIRU7ajuKBgHmI7Jh/rviXAuSL2QA8i/TDhzrfKsYzGvG3f/IYGUdeuutYgvcW68WVR/Z4czgFRAeBn+8kjPKldtM22KGHHTcuH7JS+SC5NCTeYePlO0UG49wTS6n7GrUZAlXaYJ8Dl4V3Z+Xh8kQ7dmiZjs53dEz3Okrna8i7sT7NLaKlDKeGpc6e1and5+eVBNfPQgyjP6ug3ho8qLkKiYujg2r67vwKljsa56B9fWPV4hkT0M8O4835U3PZ1bcdIWw8QqWqDDBMdelLC7oq5+B6dYpTJrRSXsTI0O2Dqu5roCt5V0fFZQ3wiXVjp0r1oqdw5HqTn0av+R4YwhcVAoDrxip2EbyR7hkjDJn7pqyuW3o96adK2WezAUA3l1uBwzbJq6vtpZ1ue2rcv9UOAM73IE7NsB9u0+Brdc9A3tnt7OJJ5CHigd2KNixvFJo7OdFHCDBIWVviPtFybjTMYsTqRt27LssVz8jBr9Yqcq8YkPmguVGFhn9gxzE0qata2kpfga/DZN2+XeepHQz8aXZ0w87AGeMwu/A6HdrvReLCG9NZut8dy1LtFZ45bPhvnKYK54WXhi3wEJpi5zN4SIX+mzulnyy/gIXO3Nrda8WGzv2QD2fdl6j+Zs+G8w8nlZx+iuEBTwXgPRl995Vtp+/XY6HHdsd7i6Yb/cJ+AO49SSl3P8BiFW5BXfz99D4TfFKsrKN30L15cSzulyLEsvr+ktwyLyqG+k49UM2bKRP/kVaeRBFRcfOT/eTK3NxYP73dUa7fxxiqTQtZz7MWljiY3ziv1/OzqaN3HDZunN9SFtg9s3yJ3FnnbpF4RsQHmBXo4y7RU7Yn1Jd86cpvF+vKHHz6tkF46gWDFWZJ39FFsrR/Hw2J4dsToTcL1Z4fzFq5LH/rbJLzvZktb0H99vde/F/ih3Dk74sbhUpZbwat3dDiH0+e6T+CqLELwcEOTgZVpeXQBcm2pf+3gkMDlW4VH/LZ213+7tPTdxqWuamnfMYFA6L3PNhIJ8GKZum/QAIn6Zc5ofWWzTBsf6dWLObOcq9RdWXRWb3FLJDS4uN4kaIrDDxipootqhgGU/arM3V5GtJcYoFw04R8YrM0419LRujW3xYsPxLWVv9cNQXRzzeeUVkl9zKmMude2qHa3HX9q7dU2D9Vx8CfKO1dmsAvQPPThwAGwvKwj302WJ/AdVkSSw5ayYW4jIrYrrPweG/yTP0x9FlozjR+tpv+axtfUBWn5p4T1KyIiEsTJLDfvoWWOI2/VZe/0iEX6odHOEHuHxV1uWrr3iAeO3eua8Z7Fy/6rdqf7dwaX3iV9nV4HKjZ7rhuxIbi0PpN+a6yn1FRnUyF15OvXwlfE825UHuOBq5smoRZbPMY7Z1etbCJFvDmZ7hjo3Eq/YePrXf209S4g5qnWewB1u/9Dflu8iSRZ8QkENSk5hoFa5njLjRGiAHr5+WQH0C9mnKsLUFy/53UrKnJqxg6YpzzLLgGHEfLS5MiHxgKXyGPHoKIfnHGgtFu+bY5VieWbPRGsnWXQS3MHwz6IHXk7sFr2jIsGPnxRUdpm5xSdbbkF+Xc9G6eLUI8eQVWYWTys0YwyJDC1Yds2Epbm3+UBajkSutXtePtGFxjQa/3+7cf7s2ffx8v93BXbtPjdtFyoeCLfCbeOSpCbAu+MKhxJCtG/81Ty84ZHHiFyw9pu7L/05K5+y/9pE3kcqVLQbQrjyZJylDZnlSPjD03pMUgMQu50fO3ZlG90kJ+WIt5cmx2TEnsE8nKmvU23Aqthme3swqh/cOz2LYzVcxxj4qbLzCw5s3NzfMbzCOanFQ5UXyV2Sezo7Py3FW2E0Oo4k+xyWNW66baPk3E03TF0x3WTT1sYPK/ZRxMv1AlfckdveuXdz67Z6PxNODvjvWNA67qEcNYUEO1wvkBpyiUWhYLi9OukwWK/l3UoCen2pxItuyGFhe0bDD+zz86XdDAjlACg2pI8VJ6YmN+LP4anqanq/KE5UlLrEWKq947qzRj3qy8qr/XfvssJcYeQ8PW+tMrguGSO+swaWLVvvbJ6xtUeVX+vJkntwtTJaUKtKC0I7kzqK1RvdXZW/m7TgNpEmWa29JTHW7/4Rjhwvovu7YSqRnGfb7GLhrF+Fr/yRld9CVCbgDFYc85Dx4YTd7q1yIQ+82PB1+cTLaQP6dFABqM41e87gLX45v5Ik9IWniQDc8AMvfIwGufA8blv8lLlk0DJuzaeOZNs6Tm8ELX+HI8YwLOZTN9TyQrevIr3dAPoW7vj/CrnSQVvQI+pXricgBbftKoRHpqn5esQXOcXr5yvLI9KTrNOZ2ysj925vG/uynUlRqFR/X1BfW4kdygJyX6V9FQwv3yF18490BfzSq48k2/RBz3Z4XBVeVSSuGDgCmoPGLk+tJCuB9JyV7kuL9tEDl8oAeecr+eFo7D1IQ3hRc/MqTlIGxkdHXPCD94OTY7r2/JsumtfX+6IZ4YvcVT3VdA04OCmDzzfR3cNd21y482MV6c3WXgOucdTd016W2WagvFgqRripj8mpfpVxu6GjhU4m5Yd7jo624RhCup0BlsbsuGXZ82Htzx/ZpVPp275Fgm/POSPd1T7ZpcrDA7vjRkAfnU4gSTX/ylIevRT5ndNL4mArOAFzhjUIEABpaW9sARLGy/yTFO0xVjkQhAJzjJYWA+9/NGX12R2u+BH/4Lj1JOXpMsjhxn6ZIu+hpyuAIPxY2RruGdw4HD+8oJoC6fZU3YNfRrv1A1Y4dfEp3NXzdkNk+id/wcK4cuIEs01X9VO2rPMAfd5SPqbc2O/1KmbokfoP5pryAs4vKeq1wgOd5H45K7g3c1z3PDfIZP5V4nipkaF9z7TZ6qAH80IzgjWlvGA2tATjEEX667fnoDf3lWQCkWOm8+pMUVSg0nZvdJykArqcpqgvR9/geC0zhIeA9RfBeR3mFhuQM0MLFwvAlp7KGJbL1HPnzfuJ6pTjYxVOHbQWZXVhAWGGTl9rO20hdv9Z1q38/xZPtyqsyJvfide3JmId8Pl1k+qr/nbGQOa8WKxGytVbFrh/J/8j7OMISw0Nno8TRWmt/+7d/m/H+1yDb+G+j6PaVyVI4WJeHK7+G3S9s+5LJNo+VyseBb2T9Q57clqIDnu3mcGX70L9ZxMB06Rqw8RA51W8ijeMG3uFTYndj3OV7qPipcAB+eC26S7DKmUyicAhH8mgcr/qpFANVGQC36Mh0QC2WSG51O8VKRfcUKuuywtnBjr9oz9jxU8Lm9vT5Z58/+cXZhwcDQOZH53FzpAK3kl45nIpu7cYmn3ZsoQHtsFG08/+HyVeD/aNu2X8tmb32md5GDg+Rh3aO7RiqYw6L/kf5plmbvOVJShP+hR/5CkV+DnhPfujTBVaQqHCvsdp4lJ7hWPkSlbW4W3RUfL4L1b6rvAxVP+lBejW4rpm2w7/E2m7Ki4dtJMt0VT+vyAA/p/TpUZBjoN5vNR+7MWeorrNd3PFr97M7Piye8FHGZlefffbZ1/9XkAd0iGu8u5v5FtiNFf0qqsErB1U4rHbe/qRYae2AqAXQBzEOaeDOa5+ByqsT7xVPN+ubhX2KMvpRRcbpUPkWfaKtc+/FywoWvX+Khi1eZN9mTtz5bcanQHW9ZutjwMuBLdiq/TJUY6nyBlhcFR8VjsWdgoUVHXReqWjtr3rYRrJMt+Onyt2xj+TAmpddH5X4KCeY/zu4swY97Pqq5OaV+z1DKd5i994e2tCefJLyaVFJ2N0JYxsS++2Tk6zb4PadksezDEuf95PUzrHJ4x3t6D3PWqBNxvA7/sDbJZNPVkTnxxXvlAtZ707cHN5v8VzBzA3DK1a6+dnnscqmW5Ok8MA7Y6brZYZ8qI1Mzt9xaJ3VX8S1H+8JT4bKuq1sWBHvDnZ8ZdxM/yRnwHvioXSnPnoasMw/07M+okO8OJ+Z3NNVZDs+Wwu+a7M5/lflWTvCDvdV3O1rx26H+xZk3cuzgKE9+ndSsmieRL5pM9yeMNKdTar8WyD2kPOgD7+AKNEAwBYfAM6x6WLl9K+KldHnKDgAHA2HlZ285anJoYsE+WSh9Fs854blvfIZsMUJ/RXgA9MuKgDUIc/GIXT9Q9jP0EdulkCVfqIZPyC2Au96L+w9DXsHdvvY5Q/s2A1u9mjcK1jSpyiOy92D2dPt8iPd0zIr964tqkXErtzqqv3s4ik/DO/0/W64hYaD6jlZ/hXkp5LH9uJ919yg8hPnLXjxqbOv0WuJ+LWPq4I4z0+0+bE8QWkNwIGmbLqs84e8XVZTLmTTXe8rK1YAXP89niGbl6JwE7LuRvTH8nlyVDFk+gXW9ZkWLU30YcHGJri26LH6CN4a3b2/qmt912+EXV+v8LOiYqDCAVaeW0SoReXLIrnFzqHv6Xb5ka4iy/Ja8eHJPoXca7P7KBv7K2jt/l+OHbhrV8Vbc8L2+AQf8CvIGm9yCyCOmR5atX3ehfdfz/XAfkLvl4mfdu6B85CWugYctrxoQOuFysU/GcKXspry8+Y1Mcmb6+K35UC/9WRF+Oxi07d5msIWd1ZUs/kfB+FyUzbSxww5ODyPVZ/F5SErQqp+3o3dOKr87JCJsMMFzrkmJkyePXGZBbXVFw/TV3Sv8u/E6OmG+98VAAAgAElEQVSrski3E0+Vm7Uz7PIZdvPw0XhrDBXXZuv7BgD8yZ/8Cf7+7/+e0Yuo9Pwk9ooDwEl8Jeygq0ol6BYgTV4SP4ft+pg2sjY6AKA1AKQoGYf6lLepnfuoedVz7cH9wivuWGHCnqx0+hU7RGHifa9HPbVQ4zZyATu/WXEgf1L3bkr3icnMp4l/5EKKKr4Jntwo7rxKuvvTVIUjscsH9m2qfFaAZEWJKx/t4qF49+DaObA9XVVW0Vd97dh78uo4d3x+BJ7uV/rL9pUnsMT/dJen+wPH9ds9lPdwIi28XGbddrsstgez9mJXXiGz//RE+FFfShX606BZG1WsrEVJN+P/vQV6AzTMw/qJYmWikeLj9Dn03fRYbKOipHLgVjidiPCJToToFVSEVzeenb4GqgdAFe+22eEOeE9QPF34xKVfUOwekndy/6r8Tp+Rvirblb/CzcYx0Br/Lbiq/TtQ7bvKexSvdBlsbQ0Nn38u/k7Kxw2u99PsT9FCF0VeC5OQXtvnfbT10EwLEIAecPQwGvufUF3FBzCqvYYxxIbxxZMrm6dW+TJFSbtiyr43US1WAF2Y0GLFIPotnslB/iurUUFQ3YC8+ZhzJ8a95IbAu8eyIuTVe/NucbSLO76rNlWexI7NU0XJtDlW/c4Bm+l25Ux/p99MXykWPPluPFWZJ9/tr4LKXjPQWvyfyvjfCPaDqYU9Px/67Z47yY1sPF1++LuohHjT/fKI17QrRQtwLVK3WDFndq81ToUtSpanLeZLrYD7+kTeLNmBfhy9g6XAMX2oYgVtyTUrSGQxoDjIN4NIH20GJd4oTsS4UxuC0deODZDbZbm4izt+3mVT4VhUbbYLFuZ2rPWNw/HuobnTh6ff9V/Rv9LHzpg87nHo74dl45DY4UbI/GR6hjs2r6C0J0rUjjsXdk91frunEMgnQRbXy9mpYbOb3aJlzscxumLViWy23hBPVYDztQ75eyW0INh53WP0bBF7xQqgC5ZpNwSkIJk+bB43npZk42A8CWXT1lg8vNwXQbZRZPp3Yaffd3CrPCDnbhclgW7ncM7kke7d8grHyjNfFX5VZuXetUQWn8Syt70RO3G9G9uxbNIVSGo/weseQI9iRDVk9xZAXzdyUTL9PmhWnFTR4oOIyq+G2tnVfBox5FfhcdJ6szWIyuaUm7/bwoqVk7y8ujHwblImn+tp+BM52ypIbsQjdUzvrfXdgqKyWVXuq2p8r6ASq4e78ezaVflP8yRsoREWJd7Bd8dmU57pd+WR7imbXT9WVuFE8iyXEruxfgrc2cc+Bao/0AGg9803AOBb3/rWqrmNjYAArPzIPjpEXFWsf3A+afGRxSUJ7NDupP5xVSmdMUztE5QG6GJFxEV+Ldj7bsq0KT6VGHL61OFuQbIZT6Z/shCpblbZppH52Xli5CHrowI2v7t+38GvcIANXl90ZTng+96VR7o7Nnd1kdy+RpG6imxX/rRsR/91wG6Mu/zHUduSUvz6578OYLtI+cSDp/2/mJHqkDa72X3FA2DG4v6qbYMoPC4crc1C5dI1/Su+omBZvptyFhGvPLGoFCv947woFiRAXpRYntVXD9XsiYzF0wWC5+/OIWOxO7YIT8Qz8C5+hfcq545uVx7pPpWNbDObqp9M9xGyHXj21X0AeD2G/xG4M0SSws9//XMA9Iuzd3q4BzlhOxOtEcc7uuj+XxibY9ow8nuEhcxW0TKoh7azr20UvZHfeJG2m09QskOt8rRC3ZC2KDH9TVqxEGLweHZj2CkGnniSIvG0Pw9ZDjLs8iPc9VWxq3CAZ3i7utb8pw5DX5VX4n/S346vSLfL9+R3Zdk4PezY7XBfwUf1wzDWcbYH3wYb2in7oO+k5L55/88lhPln+c4jXdHGvy0pPgTsax5q12CKkcvG/peFgWuM05exXZ6gOH9dFtD52i0cqK6ZMVv9oAX9Rms0elpS9ZPFY3Hnhq3cZ168O/1V+rkLG89uX7v8gR27KrfC2zlMra56aO7K7+ju9JHp393PHVnWz0CVN8D4O/fkwG6/Xwd465liPyUhZpHyrW99C//5n/8ZcR0Ugr4Nz/czWUjzfaObrScmA+20E9TlOy3GzeynnVxSzNjXPVNui5Wz76de91R0O/qIM2Bvnp2ixeMBWH4SjvzeRbWIerW/LIfAXh+7h9cuKj4qnIFX49213+VHulfi2/V3R/eU3NNVZLs+M1RsKpynsdNn5Z5/HPXwNJxQZ5Hy2WefOUXK3R7fiZ2YvEmSPgbH+C13c6gPCfplWg+D6hUUjnnD+f0Tp5DZ+u0egZ2f6Cu6ir7Kkcj41SIAyLnM9tWNYGfTYaj2f6efOzYMr/rZsc+4mV5i95C9c1A+Jc84d/xlfT3Vj6evyO72Z7HLfwrv7Pdp39W95hZMqH/xF38BwLzueXpAGlXfPAlRbuKwfeXlsxrbBXObAED6HxyUXxodcF/znLzsFc9l0nC51wULLVaG/PCLp7Ee7hQrQ69eMxn94FhUOBLRurVPQqSs0jdDVsg8gWzMEtX+n4ybrYHMX6bfjS/TP8kBfF7lIK3q7/gaiHhWt8OVcnY/3fF1Rydlu7aRvII7tjv3xv8UbI+jvo25+IR/cdaDt8AeGK2Bm++bXZWfmjR52WZ/7LddWLGhihFgiXcULMqfKHi8JyjZa5DwECHFztBH37+xi363cMgO87GxWpn8HMh8DbB4qrZVbG8GJ6I47mzsGZ70mR1MFWT8TC+xM7YdblW/K884d2KMxlm1qeiq8iqvqpOo8qq460/ajfv5ri8P1f1q9FvlL7gbtujuRpFyt9dXsdtvNanW7yFEWZ8HvQRQL1iA2U34360hLqLvpUj98gTF+cKsvRGiomRZtE3EQwoWykNS+BC9hXfzRj/FeE9SdjaCV2yryMbO8I44XvX5qj1D5jPTDzzBqx6kmX5XLvXsCYfUV2QV/U4e7sqtrsqryC2qvIGIn/2Qdwev2EbY9Vvh39mvXIjuZpHyp3/6p/i7v/s7rSUoxHoDl9M7A+Ux8UBz9zsDFFzvSc8B/SQB8QF+EtYiR7rwCpYmfAvOq1+YZZxIZwuRwesfG4WP0VvsPDVgRQvjDFm2Dr24MrsdVDaGHbyjsLL5esLnQNXXk7y7nLuH5a5dVb4T413dkzY78T4lz7Brt8vfxSv+n9yXPOzEl8Xzl3/5l/NaPUnZ6aSGfX9rDM8mtzpEL4fBbTmv7OuUlSmEziHPioxpYgsiVpAQTva6B3AWz+BEBYlThEhe/2iDuPDt3GcL2VuvWbFTeZJSvRfecfBLZDnYQSW2Codh55C5i6q/j+TtjHusuZ3DNIsx00ec3XFF8ki/088O967cosp7Ah/Zl8ST/T6xJ+3Ec+N1z0C9k9ew08+rybv66jmU/mQcB70coMWAh4b4NU8XGhOdE/o3U2wMwqT091GigoTp2/hoNCe0EIPw10lh0TJpLxYvQ1+5UV7ty+NlfgcqMe4gOiQz3LV7BVmfmX7gSV71YK0c2BVOVSfxlN/MZrfo+pTyqp7hjs3/VlRzUd3jMnzSvzj7PBq8/N3Ll5cLIX/ja54uOtYwnKLF+zP4vekXFDSuJmKJChbV5VoQXXSHq0lh0TJpwU1y9xWQh8oNmT25Ycj0A5UYdyD7rcZQwTiwxvW7UPFd4QCv8XYPyKyvp+0qnF0502XtTB7pduQ73Ai7/HfhnXE8vUd6uDsGW/geTbS+853v4Dvf+Q41fA+8QfTE2PzcHPMWXpiTE0UHXnFw6ri4xqe8I9BZeNysyHgh7kpcr9wwn8o2wzt9P4W7m02EJ31WfL2Lc/fwZU8gsv4zfcb5aF2k3yk0It2uPNM9hY/o41Pi3fuWrENeeN1Twd2J6nb1eX4uYbzPU1iamM5ND90G9XQh/B7LMcRa4b0auv30JOOKfuQrKuDksNyJeCZvQPrzciHAbvzqzfK0LUPVn0Tm+47PO8jiqOAJHxGq/iu8CgfgvCcOxqztyXb0A7u+7+oy/W4cnn4n/5n/CK/YPgkZh9wPhvyj9giJndy8Gt8LRUpDP1Xqwb4PbHHq9pWoF+KdTvOku/8l44WI5SAH9ouWpZDwipWTY/tzC5eGvCAh8VMeHF9TOT4EJymosptl59HmwN2bKovFotLPrs934ek4nvBX9VHh3eXsHJiRPNO9W/8OXaTflUe6XTnDDvcdqPa/swbfhcq+JbETH/OtipQ/+7M/C173sI7qnT+FjfEq+AcSFSewvvjhfl1q/jIRxJ379KHKt/0nh70qXAzN+28A9eZaiFz1khl3oWiZvElY/UxeYfLuFCKVm+qJn2gq/VhU+/Bikn0++R2SJ3xEqPivcIAar7X9VzJ3D8u7dhXOnXhf0UX6OwfsbhyZvypHYpf/vx139tQqWmv4q7/6KyVznqT4X0B9Fq908npCAJTGmedeOknJfZLVuR8XIeHTB8Dle4f92HzdRWWGo4qSoGCZaKZvUrTQV1UQvMPwCLLN404hUr3R7m6QDNU+gf0+djd5hipPQto8WQwNVHxVOIDPG/JMX5W/oqvoBzLenRju2Hi6V+Lz9HfiZtjlvwvvjiO6J3f2I4k7MVf6WoqUb33rW/iP//gPxr2B/aDrqPkeeePJ2PERJ/Ny3+a/2ZOLeZm9GjJhVvntaFRPN1+vaIr6Jr9NNHleYXNyW2uLTfrqh+BOIQL4dtmNxp6gMN0Osj4jRPFYvcd5ArsHVYRdPlCzqXCA+2O5c1BWYso4r/i/Y/vRPu/oshirnAqkn+oe8FTfd3EnpxbVsUZgfVnZUqR8/vnnN4uU2sCeQjGPE1ni83xbe7v5Y0H1iYAqWCo2Dh9YD3r5CqccQ/QKpgHXpbg5m/mPCaowjL92+lvEhbEbVA5mhiftKroKKv1bZH1m+gru+Lhjs4OK/yc4d+f7ru5T6+/o7vR3x6aiv9OXhzt2d2yqaC14+v0JkI3Vvi6txl583VPBeyejozaoJ8DyHefUGsQFRfmLqp18frTJ7R/1ooW9EmIx9I+VazlNd7IUI0M/ec2JlxU4uqJZ9B7uPg0BuG1ml722qN6EHrL+7yKL+1Xc8cs23Dt+Bqq2GS/TR5wdeaWfgYy70+8u567v3THf8ZfpMp8SO9x3oRJDhfMEXt3LgDVWFnuln6VI+eyzz4xkLyl7OczImV4iH+wu7FgeKVoGGlQRUnnKscOvflm2fzQa7vK0Q9US07jzjn5NOQLLqx+s/b/7KQqw2lbssg0i0++iElMFr8R1x7ZqU+VZVO0qvFc47zo4M86dfiuczPZuv+/oL9LvyiN4e8yOr13+1wE78bJXztW9q9IPLVIqhvt4h0+Jy38WfjF/BkfqV+MipxPWoA70Xb5bjBBe/+Bcy3Nf0zDeoKruHK6Aeo0EzrG4+z2UgbtPUTLO4D2FSn9fB+zGucvPUPX3BO/OAXjHRqLCu9vHnbgreqZ7xd9dfWYzODtPGysciV3+gGd3Z4+Rvu7YR9jJe9b3X//1Xy+yF173eLg3IRXcnOsFkR8/h9Job5LHhGUTNLC9oBpqRU4bH+eFobGCwXLsax/A7899RSQ52W8uEWQ3fZYza5/xgbzPgSqvikpsr4LFvLNpW9yxiSDvn6rvjPeqPuLsync5wPv6eFqXxXPHZ0W/a5vx34ndvnf5Fjv2T+8/0V7jgRYpn3/+Of793/+dqQzqg93BRg4fh9e3zqMk1SdRTlA2MQOv2KT8BhX+KCrob/cErlSM/bEO58HwupBzjs55ZfwWbjH10IKrxreDp2LbRbXfKk/ijg3A7TJfmV4i4945FO/YMNz1k/Xxim3GeUdO7uozu4HW4v9o4v/fsJuHO3ug7OM3fuM3Fj0tUj777DNTpOSBbo4lQeRsPwlPwB9fMwVMLT47+ZXJ3T2wVR+H85RChjHrhnWw0a8bS6hXP3D6PNY+Kl/0rdwwu6+CKnmsohLfLrwN84m43xHvEz7tOq/4rHAGMm6mjzhMXvEnUeHv9L/DuauL9HftMl2mz2w9TsXuXfiIvp/YOzxE8Vf6LRcpwMckq2O3n2zROoqRH6Iv5A7Ryaz71B1UJgZYN+YMu3x16Kt6QzRk6EvN0GRD0EjxMvReMULmwMZWee3DsHugP73OS3Oxgbsb/0dhN45X+Tv2VW7Gay3+6XpXbjmVQuxuH5k+43y07uugH6jyKrD7wpO+d2H7fnrP8pCN2YuDFil//ud/jm9/+9tM9SL2J+axuQz8RH1ceZOk+qTuHpqAtsm4wMofbddWhOR+J6Q4XK94GW1bxNCnNKRQyr48a3GnEKnkdhfZjbiDr3t8DE/63/VV4d89PKWuyqvIme6VcVRsgb14qvrMLuO8Q/c05y5e9V05Eyochldjk9jp14I9RQHe8sVZAJsHzIM5ehw2tj4HUrg/KWkRIbC78LzNtFKw7Dz5qA5bfQ+F/Prx5KhapuhcILvR2PgzmzuozFEV74jvLlp79u+aAPftq3YZ71V9xKnYAjXeKwd0pq9w3tX/K7aZPrMdqPLehTv9V2w8zpP7E4Ptd6e/3/zN36Ryt0ipfXlWB1TI3f94rGO8PymlIkJgly8xbY/xQezlUOYDFWdSG/Exmp5J4b+A3C9rC2knB+ym3bGvorKBRIge/b8S76txATUfFU4VFV+t1V6XDO4dnYXHzXxkeol39/FKLl6xzTiZ/Su2ElXuWF/j+i6qa/TdeMfeEiEas+1z+0mKLVI+JsHVPq7BzbieyLHo/u6kyTzt+Ni1s3x5M4Vo46MtOat+P+Wi6PnynpRMmOlNY0hQXZOVx6NPoTQHAZ7ahJ8C6/OVTfuOzUD14M76yPRVDsB5VduBce++Mvev2Gacu7oq5xX/mV6iyt1dTxXs+tjlS9zZgz66P2Dtc/tJyvv+qNtAtDBd1WCURAsO1Hjgk9bnoj4h0QYfQdrt8KP5on4MvfT9FAtV1xSTC993xUclJxJeXnb9VPDee0ZjJ/4n4/J8fUQfDBn3lUNwoMLLOLtx3M1zpq9wduJ5mvOqvsqR2OXfxUf085H7HRCP6Yk+wycpz8C70aj4vXixzx7z6mRnIuyEZra7BYuH6ecInlbI0A6EBUOpgAnwyvdQKjd6JVcVP7uo9PsU3hF/BU/0u+ujyt8tBO5wBl7ty+IVf6/YRpyKLZDzXtFntlWORdVm8KJ7u+rrCbRWfGpu8O5igqF63v3N3/wNlQMPfXH2Iyfo64hXCokd2x2ui4ar+IiKBG9KZ22yEnYKDQCqj+wJyu54K2ty12cFlX7fha/LJgq83t+OfcZ9t77KAeo8wOdWfGScV4qCV2wHMt4TfTBUbRmvavskKmvgiX3M68d7tXu3zzs5PFpg9e1vf5v+KvKdjvYw/PNEZAfaE9g+cA3uTiLwmq1F2ZdDK+WhQMlQ6idAeZxvwqfu/2m88x7f8b3DHfj/2ju3HjuO62yv7b8jnqQhh1e+cZA4CZAEARIksXV0LImSSDmxk88IkB8R2BZFSlYsUlZs2dcBAuQI5CY8i4rze+q76Knd1dVVtd61alXv7j31ECNxut61atWhu9/pvfeQi7Fo3+3q3kOSArkhtWjnNLXxiIaL59pDJNoQbRyK3zfh9605xHVJ0+c///M/Z9vYJylLTCQFpmPanaJv+fwkiX9zqgddgNS8aWLRmBxwrtRU7wh7YqJYppjcr8NHx8/tUzSPFq7/Q7DEBbFFXmnOmpsfp+GMA5I/RKLn+s7BtXOaJeKJbHJ4pPoQJBa9HnG5uPYSzslf5uH6k+ZDKPWp6a9oUv7kT/6Efv3rX5ckENxEmdK4K/imnyCeByS+pr+Y2TrsmCcYmbmM32BLVP8kZI+jiTHK7R3pXFjvQWn/h0AzZk2MBGn+FnoLDdfuQXWenL72hn7oeCJeV9teQhsbx2nzaEj1pbmHlEj1kfrhprYfT6r+3Kd6POyTFA1LLuQhqTUQ0g2HzCuXY4Kj5PtTPNAbbP2hhHGRIjE63FyI5kEB1/95oMUcSHNyeq7dw+m4dg+is9DUmAau3UKDxBPZ5IjRxnlq41O0yEnE59VcBxFzFKPph2jIW21SuF/qxhXfAuv3pMQ3R5+/5qapWbRa00PEr0c2byIMeoPtKK6m+Gki4Xzk5mG3s/ulStKatkTtHNXGE+lyoDGczvLmKdHntEgOTlPbXtIgsUS8jmtPoYnxSGK9ljvvJTlbw9XCjQWl1A/Xx6VLl4rtYpPCDbqWSX6b+WPJ3Rz3x6NmbtKJ0vOExHksTE+Kfd6dwIS58K9jvAfOU0HNSRBiuX8tc22RmvE7p38TYXizsDITnJZrRzUeRMtpasduocm1c3EeVEck08ZYxtbkQpDml1z/YnL3qfj8rIG7dlc/SXnhhRdM3peSgl0M2VqNaOZW0FdYt2QhtXFE/EKLcZQ2Zzv/PyanC/8afAOan9xJkDtpSnD7KI7X9LEUS9QmmXsNaJ4WN1kuzo+d03mt5HgKiZaI19fUZKGpXTMimxw5auM9VnmIbHOlqLmvpPD54rotcsdwBoUIMClWv9St9UJNWLIr5QbRxqXg5laU3/n/RTlB85E1Pwm4uj21JwvSD6I5FC1qs8hpkYNIngfRa26EXF6uHdV4EK1mHGg7oqnpH9Fw7Rw18dpY59qa/BpKNUivmzEtcnMv9RABJoVoeJryf//3f5yMiJZdqPi9I+jNsQR0I87gxy5dsNScSXOUyK2JqA+XmF/UuBjD7THRuEi/bq2Ix1dbV3xR5eavFsv80lyI3s8Hp629QXustFye2nYPp6up0YPqQjQxnppYonl8bb4ckrzS6wKXW5ovRJvb5EkK0fA0JWVSuMKsYd87YkA219lhZCHDefEXQyQuJHWjsr6ZVt8Mne3cc6D1afelNq41FnVZ5IipzamNR+I4Tard4uZLJNMS8fqadm1bTE7L5eDaY6T6mNp4IpscHstcMbnc6HUyhqtVm5conxt5klL8jbMhf/qnf8pJTHDBDX3JGyARkbQ77aJp4zha5G2R05ot1IiSOh0l40MuXOApr8IytzQXqve6mqcpXFwKJKZWY1Evoq3tB9XlqI0nqssxuU9V5FmC+NyXXE84anK9/PLL9PLLL3My7EmKJciCIhqI1PwZpSaa14kuWO2NKAd3g9Js0Fa1WsLtF+RmtGYsarfI4anJVRPrQXJoNbU3Xw+iRzREvK7Urm2Lqc2DaDi0ObRxIZK9guLjpWZHev2N84bfS3PFcPccC+AnKb/+9a/pV7/6FSebAaZvDvTr3Q2xWCSLHChL9mXB1ur1xBemVFsKbrzIedbSrLXIK80p0TtX974ULi4HEsdptO1cXEitKSHCdSm2GBtjmQuBu0aghOeFVc6Y3W5H//Iv/8LJiEjwJIX7lM/SC5JD8hIRqq39t2TQmBhkTrW5Y5ZwxJZobujIfEqQGo0QVOeR6lMgOXL7FonNURMbIsmDaFMaixs8EaZHNZyZ4vLUxIZY5pE+PQjRxKSozVMbb02qHs31O8zDjVGTn4jPGwKblBdeeGH/d0kHLUFNhpgoberfkpEsTjxfkliO3FqEF4Ga/qQbXzI/yD5C8sQgeS3Q9FOaz1K+pYxXCJIb0dSA5Ec0MUgMp+HaU6AxpRsFlyPXzsXFlPRIrtr4GE2MpyY25FB5NNdBorb3HiL+/pPjlVdeKbaHwCaFKP8pn9aYmhGjVOHicAsSo7kZSSld5HKgfSP5EA0CmgetPQTJLcmL5EuBxCGaWlr0YZ1Tkk+iDVniJm+pqWnnYmOs5qaENJdUz2GZzyqX1gzEWOXhSPUT9oF8qscjMimS35eCAC+gZv4SqUOzY/l+lHgcNQuOzElN/hKW41gaZN40tMhbmxN58rIES/SP9IFoUnBxXDuqIcJ1IakY5+pe/kHrqO2nhDbOUxvvscoT0iJnidw1268fClq3JGdM2EdTkyIBHThLRZqa360SGhnJonPjRvPkyOWvzRvDjYNjqZcorMadqgvNbT2mEq36apG3RU4iWV6Jliivt8qTgtOG7SltjZlAx8vliZHqS9Tkqon1WOTIkTMaGrh9UpObiJ8HJP/ly5c5yQS1SeGKPQSI8cgShu6G7+N8fszIQpQI5642Vwi3JtxPRqHOAqQvC3InuUX/FjlStMrbmvAcWGoMXD9cew5kLFxurj1EovWkYpA82vF4UB2RTIsgzSfVl7DMFYPmzuksrsut7j2e0hh9f5KnKESEfwTZ86tf/Yq++OILTrYYYmMilCO0WGyidnlRDt3/oQlvYpxm67QcR4vcaE7n+JctQjgd1+5BdSFcTM6wcOPT5M0h0eaozVEbT2STo0Tr/CEtr9Mtcv/rv/4rJ5kgepJCJH/JxxqRKRFIa2jlTpGNbtlfDNL/2ojnw2IMFjliWuRcmqXGgPSjvUlzubl2VOORaIny+vB4zrzkkNQg0aaojfdI8ki0HJa5WoHUqL1P5HJr80lf6iFamUnxE7Lb7Xgzwq/LDDZnDocvCrJhQtC8Obj+avNvDW4+WnCIPiUgJnrJMVj0JclhreU0XHsJLlZqSJD2EIk2hTZ+cu0X5pDqU1jkQJH0ZXX9TvVZk5sbQy63xqSIX+4hqnvJR9GdGpUpYUJqFhahdX4JaC3cmiLvEUH7soCr95CsubaQmpuKBqQPRJMDieU0XHuIhVZ6XKqJ0cSkqMmjiV16r4a06s/6emmdLyTMLX2ph0jxJIUIe5rSanFKQKYEkJSIx2W9uMi8WfeZA6kFAcmDaLbA2sbB7dfaerXx2jiiZWM5fW17ilKMxphY14AwhNflINLVoZmjFFL9knC1Se8R1vlCfG7NUxQiY5PCDdSSJQwJAncTaAE3z0vUcKxwc7s01vVY5HMu/3F8i/wpJHklWo8kxtIQoHrpjRfJi2hS+LDdbvz7WUtKDqGvRRcXYpFDSthni+t1bkzavizyaU2K6uUeIqIvvvhC/ZKPhqQpUVW+TiSLvbIx6+sAACAASURBVFUOOUblNlexZF8xvu9wrnMXxEPWSVTXf00skSwe0XIarj1GY4SkxyXY5CCquWhra9DGWWJZQ4vrqEVOLse//du/FdtzqJ6kEBFduHChqUmxXFSijMk5I/6lbRzcYmhI9duin0OCzO2aWbr+mv5a3rAQrPvR5GsdozESMaiOKK3l4rn2HPq42ZGUDEJTgyYmxiJHS+L6LO4TFjnDHHG89ikKUYVJQd6XgtJiU2RNSeIw9NJRQGkxLJHMS8s6zgOSubbivPSZwtdh8WbGJeM5bW17jMZsSvqQaIliE+K/2QV/1zHmleeRj0GmXzul8WjvC7X3uDi+xqSoX+4h0r/kU9FlFokpaUl40dUsbgt8HdK6ajeqB1lvbf5cboubX4rUHLboJyTOH6/n2qmt8xDxkhhOy7XHaAyI9LiUmjzpUF0+bR3aOEtK16qlqelTE/vv//7vnCSL+kkKEf6ST4sNsjcl9qmrCMeqHbdmE5SI69DUpYmRYJ3fIp/mZlELkhfRpMiZnRSaPrTGUBMTUhtPJMthuS8QvbY/JHcKNA6TQaIJQ155nAetP0QTk0N6Hki0ntp7RNinNJc0tuYpClGlSVnyUz4tcq6V0liRTdEpY7WXnEt/ysUqfwqf26JfqZ4DyYdoUmjjcqD5/Bpzeq7dw+m4dk7DxXPtHLUGwpMuQ5dXOyZtHEervCGpPrT3Bq5eyQ8zKe2VK1dmxyRUmRQioj/7sz+jX/7yl5wMhpswDbOXggy70G4MLdz8LF0PB1evhEO/zJHq17oWNB+qSxHGovsF7c/qZbCaWI80R04vPY62e2p10uNSkDyAJEAkJqIhv99aSD0xmpitYWlcQpzL/8qBmNS15aBPUohs3kBrvYGWfCmIqx1dXCu4erZM67G1zN8ydwq0P1SHIs0n1cfUxhNhOfyFuqRF8oTU5mphTtDYvMwR7T8tieUiivPlxpU8nAQdR2tydSx1X4j71/aryeOcoytXrhzepFy4cIGTJLHaRFZ5WqGpL94AKXfa4efW+smLVZ4SS/QR4m++nCYHF0ukG5MmpoQkn/Tmj+TmNEh7ySQh8TUM4ViOodbw+7x2BBIl0Y5NG2eBdd/IeUiU7heNDUFNS61BIaK6T/d4vvjiC/YlH4Nu9ljmOiY0m60lW1ynpWo+tn5qsKpRm0cSx5mFUMfBabj2kgaJRUDyAJKAXL3Jw6GCExRBxnFMWN4LpLlC/X/8x38UlBgmJoWI6I//+I8n3xulhS8KnY6Umj1VE4uyRB8Ivg7pxSpFzZhqYkPQPKjOw+lbt6Maj0Qbkg6T5cp3LcuTQjuuY8TinI1Bc77++uv02muvcTKW6pd7PC+88AL95je/4WRFWvxUUBNbC7qYnTSHXLuYVrVsKW+LnCGW+aW5NHrkh6fW7ZwGiUdA84CyAHHAvo9Wb6S1evO3BbmX/tF7S6p+NDZHmLOUy+KlHiLDJym/+c1v6O///u852R6jbme0yrs2ajfaIVjb2ljWY5krRev8S2ExDoscHiQXoiHCdJymth3VpNDEyUOmAVg8JCqiGdvW0N4TQrOtzUE0j/3P//zPjFKG2ZMU5A20LTZKi5xbgBv3mn4aWJqU06+dg9r4HK3yhizRRwss6pbmkOjDC3spjstZ245qPBJtiml4adzZpgKqoAm149sq8bhRwxHGpeZOk+f111/PC4WYPUkhIvrlL385ewOtYfo9LXJ21sUh17i279p4jtzFqHW/raipuyaWSBaPahEdp2ndjiLNg8u5+outpUYWZEzojdmD5AyR5Pe5JTEpauNT5HL+13/9V/K4BrMnKUTD0xTpYpWwypX6d33Cf/lYQ+oXxFndLLifzLxmi3DjaolV31Z5QmpySmIlWo54n+b2pHPO7NyoiZfGSvSIltOU2rlYD6oL0cR4+NBB4HXj+0gy8hmwMItmfJoYCZr8qRjJfcDK7ISkctb+htkYc5Ny4cIF1RtoNYtWophvR0njApMJtRoDkqd2w1qA1HkIrOuyymeVJyS8SLTIXyLuz+ImSyTThqwxjtPUtHOxMVJ9jmmadM5cV+USdPX5nKMB0uXZIuFY0et/aX7QHDFhTsuXeoiMTQoR0cWLF1mT0moTwXlB2daAx78RlhyPVV9WeUKQnIgmJheDGB7txSyE64OjJl4ai+idG26Ug1RnLrjYQaPLLUWaC5cPQlwfkw5E8sVjstjHMdy8oX06x/+ixRCLsZWuCSjWT1JM35Pi+aM/+qPJ9w262NMydwt8vaVFl27OrdNyDS1yW+QI8etrmdcy11qoGZM2Fo0bZRK93py0NCY18XzoKOC1OdSBRFQ3vjWivTdo40rEOd944431P0khIvrzP/9z+sUvfsHJRFhuNP9Sj+R9KeHLQ6K4TN3ceLj2mBYb0MMZK2mtrbCqwyIPl4NrL1ETi3Aok6wd1xJxEi0Rb2J4U1LXHiOt36OP4xQpsKB0biz2GAjXRHKexmspic0R57R+ikLUyKRcvHix2qRoT44UufefaN+X0vJfVdZiOV85lugjhWW/lrmI9PlCI6DNUQPXJ9eeIrzoaeJRJLklWo8kZirl5nT/t0J7PkepnYtFkYw9BAsLRbvJ91h8iDjgYJTmNDYK0h8QtIaFqC42xYsvvrgdk3LhwgW6ePEi/e///i8n3aM9OVJozQdEw9TnFcu1D7HKa5WHaJqrNm9tvDVW9dTk0cSiMRJDQoTpMePCtfO1hKDjjfFxw0uVk5akft+abEZqQDRpnNvGG2lTtcXHUAOhjSNK1yGJJxpe6mlBE5NCRPQXf/EXRZNivXHU+UrroEypQeK214Z67o3R1KGJSaHJE//UpMlhDVIDsh+RPBZo+pHEcCZh3wreiLmbe6mdi923CMYXg8SWNEB4Ac0cE+Xi6mpZD+F8I+eeJzSVGiTGpdVTFKKGJiX3NAU5CVBMchmkkCKtW6o/drTzoYnTxORAfmqSILmI1PQTY5mLo7YvNN654SdvvSlBb9ypPZBv52KnGmysIej85CiHy3JjpUCio0VjWCTXCY5crlYGhaihSSEajIo3KTUnQ01silYvB8VvqLWu+5hpMVc1OWtiQ5A8ztk9UamJjYlzaS9sIZb1xUhzD/rxvRGlcNSUpHPMD3LmAzEeg4Zv136STBMTUhl+Rl2S3Bg0e9nnSsXWzpVHUpfGsHhqYmOcc81e6iGiNh9BDvnDP/xD8QJK9SVaGRIiqj1/jgrLNdOirUEbR6SL1cSElC6WUmprORTSuiV61JAQ5W7EJdOBaJB4oliHGJsckvlJgdSXxu9hRDuCzOfW0Z7f2rgQSY7vfOc72zYpv/jFL+if/umfONme2nKamZJGaYmCmn0f+P6YsSPdT01rxXIs0lyDXBaTQ9o3kS5mq8Rj1f7075HGojd45GbsXPzSUVpbutFysXMNX3ftG0mncTpzEeLTxffDcnn6/raMxDSEaONCuBz//d//XWyvpblJISL6gz/4A06iP3FabNoGKWO04z0G4icBLeZCm1Mb50HjUd1SWNTTcj1LSPtD9WkTMb48VNZOWse/JXPm2qbt+yOTQ+mOBw02Tg86LxxGaUhaP9EwBu6makGuH+kcamrVxITUxhONOd544w36zne+w6jraPqeFM+3vvWt4tMU6cIS6WJKaH9ZmwTrmteIZIwSLYc2FxKnueDHIP3k0MZaXEQltMqtzauJ4wwAn3Panpe7Ytvku6SupOFqHOHHw6Ptu5ax33gu7GtIPdmz6CfMgZoHTUxIXHdNjhdffJFR1rOISblw4ULyuGaRNTF50s9h1E9nzsJqH1WvmaXHZdWfNI+FMSHi++Xaa2iVu3SRa9UnQk3fpfVGTAJRTjdRDP9l8iHmZa7hameLm1Eznyi+i/A+iYx/aZaZi/x5laPWsBCNOaTxL7744vGYlIsXL04+jqxdcG3cgEv8rZJMIk2damMUY5RmKTRzxaHJiZoS5+ILKh8TItV7uDjpBYaIz4lilUeCpk9pzFQ+j8XSDaKSMSnnmTbKaioXKJ0PDn06R86F+1edaHU4p3/5SWoeUuuJxhLl90MuR+uXeTyLmBSi4Ze7ffXVV5wsif5kik7wjKqIKohnjb9avwX6tZOh6YeLGZtLNwoevh9hwgQWOVqxdG01/eXWfN4+awE0RMMNudQ+aPZ/S2q5/dhmv2njMGS5JTdUi6cNMZK5iLXSGmrqr+2bKD3Wl156aZGnKEQLmpT4aQqCZCMMZC4syaMJYKGc2Sd4Nox8Xeqw6E+SY5Dieg/aB6rz1FykWiEdQwtqaxjj02+GHXXJo0x7CG5M9AYnc+3bH2YL2FM7ryhxN+WXfLCauNq59hyWL+HXGIfaa0FN3yFLPUUhWtCkEA1voP27v/s7TkZE6GYqXFiyLQlEYhxsDGkcOfM38NbU0wrrmqT5pnLkRiXL70HqstKkWMv7RrTU1lyO527waY3eUIRwuqGRM0r7I7NDKQ1UGIRtLk5xOCzHGaM1HqmaJPFE8xxI/FLvRfEsalKQpynYZshcVJJHEySEa3hPSFyDqiZFSCuwtaxH0s8gLeu5mxMKVxfXbslSfS3VT4maGjgzqjcUITXGZGzPa6LrCDMmlJp5PQ/4+UFu9Dm0hsVjFV+K/cu//MtsWwu+xgms+da3vpU87pwDT4L5CehmRxM4N37R+OX/iHGZLwEu+hM0yHIp+7fAr1vqS0scW+oD7WfU5vX77cFM6KAr15Sri2tP6dDcVnB9H6qumJoa8rHzdXcu3Bv7o/uvMT7WhDmmuoSCzRO35+sJay7v5ZBDrm1qTL5+zdc0N65FKeWxyE9Un6cmPje+pZ+iEC38JIWo5pM+8cbLNkWkG9FeiUgoLuNSyXL5Dfstga+BPbm+NTVJY+byefxUI82P6yVaIrl+K7QYlyYnt+58yvCmlVHwSYjOTIesPXdO5dskhHXnfuLGxpamInSPpH+JVkOcX/OEgwib9xK1dTjnFn+KQnSAJylE49MUfHNMT3jupJ1+pVuTxKFFMYYL//jCgfw+hsMl/mS1bu6O8TWoo1XfaC6/b4Yvr58vxFRHs/Z0XvnYOC2SY43k5gL9qqE2p8vujVgzOTL7GnKktGNMqa5p/ZL2ab1hDeOYcJD5RDSdKRbzdIgcS36iJ2TxJylEw9OU8F9ILjNMYH4esQmuDBfhyOXzFvpzicbUsSJOEVMBusGl1OYdwrEc8wt9GlQXg4wlp0Fic4SfSCj9xBu31fS5NJpaJTFzaW6dkocj0qaDbyu1jwdltUIFH4TUnlwz4X6S1h3vRWk80XI5DvEUhehAT1KIiL797W8zCkf+xMyfnPyJllQ5QsNhJq5UkNcFf1Q4ajIeT+qnJKkDL2Gdd4zP5/B7arq3pjGxZsyZzx3XXRqL1XhLhHlL87xELTG5enK1cO05dDHh3kive6jJp3TB/11GV2oL65+1kI+b1zDfo4PGj5+fgxjJ/HEga85p0C9JLpRSnCZfSG08Ubk+lDj+EO9F8RzkSQoR90kfR+W55Sd+ds4aoV10j0OKASQtqB0bilU/aB4HboZ5OkQ7v0ilwGvFdCG5X2Cl+YlKiqZeCZr80hhUn5Zxsblr2XAw15YrKV9rvA/zbTnwecB0a0BSq0SLEObTnIvpeoY8knQWdRzqKQrRAZ+kEKWepnj3lpQTJX5CyCocIXIicuU/zsCVBn+Cg/mvRFwcz1Q9/glqjsdiMbYYrg+0Hy5HKY9z/svr0pth1A1fuYWIddOcebBasTGVyM3N9Fg81nI8+rUGJDVJxjCds3hvpNc/nudp+jFu3ja2p0tK1TqtY9pnukY/Fsk8dOqxm+vS/uHR1PHSSy/RSy+9xMmacbAnKUTTpyn8hJXb9+fl9EgWgVSFC5MK8ju2biZZopmfWx6LHCks8qI58rKxAdGUQGrRajQ/BY3Mb1YtQMbGYf2L5yQ5JFpPec/sqLy/+LZ0/ryZmXy3/1Y2Lvv9V4brz7e3rEGDc7onluF4NfHj3pA/WQmJ531N70XxHNSkEA1PU374wx8yqvIJJr2wKM9bCHktMv2EitAS0jFosOgDyVG6KeQ1RNzkTmPyWn8R42rl2lHNlJ364uWR91mPRZ+SHBKtB9lX8fHcnpGak3kbn2t2VDVmPsbyTdip2Jp8teTOY+RGX6Iu3u+HOrPiiWs59FMUohWYlIsXL9KlS5cK//hg5iSb/gdCKIeRnjgiY+Kl4eYThCNI6+ewzCfNhV+kZ0dSMqWBmbbnxsCNTftT2oj/aXv603yI9VOLpUFNYIxUTxTuBSwW2Tu42Rjb+ZjSXsZq16KZ162Ajq3OdOT6GXOk04V7o/6HE893v/tdTtKcg5sUouFpytykzBdqeg5iG4Yod8LLQTdpjqI5yTTtY7Rda+MK1M5DCm3O8cKbvxGPumQL0+4pXfjz7YOGTb4HNTh5Uhcom9pCfJzVT865N/8iIDpEE6OLmR1JyQCjgbSn9m5Ki40jNV7pDbYzJ5xX/Xz6HLvJeucMi9fo+1vHUxQiop3TnIkN+Pzzz+nzzz8/+84F/w0QnHQ1o7KckqQxKaQXPWVJURnusZyDFLX5uXjOlOy/A3X7o+Ae5OrzoDod6QuU9LrVtsZ2SOqWaGPQPUEU77fxm5K5wdpy+zp1nK9TA3pDROcayZczy1tAX/M8jkul6et//ud/OMkirMakEBH9/u//PnNT524MxeYsLaZA8gREbUyUYSms5sAqjwfNN70o74K/53Szlul3oG7WWqgXHwuvm77EUf9411/EkL7XRHiTktQu0cZoYnkzwbVNNbzZSeWS193B0RiBEHm83KwMGl703e9+dxUv9RCtzKR8/vnn9PPPfz4eKJzAkxbxCFInej3SqRSZE4FUgrTmkJrYGG0uLo5Pm/uUxFQzO5K5GcRw9XlQHQ/32nUbSvUjF8UYu/kYqcmpiS0ZkGl7qW2usTIoztW+56lTon5uUROC6tKk6lzLUxSilbwnxePfm8K9P4U59yNSJ6wdqosXV3TUzOpLVIQS6cbHYZEzl6OcOnehj+F0+WBkbIiGKH8TKd9cwtrLVyrJhcyD1h6iibGgtl9pPKrPmYaxbf+dsG2eM3U8rBOtOab+Bjzg+7fKtybiuZWP0cePcfFyDSnDg/6JaNheJq7zzTffzCgPw6pMClH8JloX/DdB4aSNUZ6LE7QnNBHljUb2sL6vqtCKMeaozYnEjxLk4j9rnX6X1OYTlG46QztfP1Falzdj8wvT/IIkOye2+JJPWKv0JR+i+rFK4m3MybQ9t+/zpgWvtwSXR7oWKa38pj5HUoNFfyX0hsyPIfUDy1nLvmmqnbeXeemll1bzMo9ndSbl0qVLdOnSRXqe/UgyRedefhMK9ucEycbmkP5SN7E5EcpjrMZ6qDwlPZeq3Fe6rXQzGTXYGFAdz5BnSKd/elJbT+ki7JzspQVNLeW9IM+XQ5OL36fy/SYxKJqaa7DozyKHBE1/kj3tifvxho7P5eMkZoWIgk8EcV2s7SkK0QpNChHRt7/9Mj3/6v/NGzInZYxkr2k2Jocjx5U4gzUnwnwlpGOW6ktY5crlmR8eD/Bdc1pu39W1o5oB5OlJ/mIWw128iPDa8muDxVti1acmDxeDmZN5u8ScDMdltYd6/sZ5vkkZDik+x/D/dPw0re8TMStEod65/Lm+lo8cx6zSpAxPU6Jf8FY4ofcSwbkoPXE5tPlQc8LqOITh2vHEWORBcmAX9TTl/Pm20k1maOfrJsJ1U/yFjSi+WKV/miqjKuHA6OatTG1ONJ432aX23B6fHkdq4TRce4ncEzVEt1XqTYuPn8allyH/9KVkVvw1Iw5d41MUIlrXp3tifvf3fnf4C3siFZsnWA5XmwsyHM7/D9CGCOUh2vGEaHPo44jKF/TUcaSv3I0g3TZqkNy8TnexQzTYU5NDw81PLVb5JXk4bdmA7L9LtKVi+LoQzaHA9vv2kI+L148pkacwqfYdvfnmm6t7L4pn1Sbl5z//OX3288/KIrD62mHWxhMVDEfisOa300rQjMc53a8gj6mNJyrnSDeVPmrsiILfWJuLL8GNiWv3YLrck5MY/gJHNMQ7x1/MUiA/GWNjakOLvqU5OX3OaIxt6fZUHNcXqlkb+ScG8rHIjcKA70sbnwLLhWjKZoXr5uHDh2XBAVnlyz2el19+mZ5/9Tz97/qAexPdxFY34JiZ2QDSS39LLYJ2XHGcNI9UHyJZk7nEZY7HePOSEspvHKOG7ZiIcN2UMGaXHeNuF/567LSGaBzPqB3Fmvo0MVa06FuTk4vh24nK+2/exuVENQhhHuxGW4dV3UT1ueL4mvEPucb4dCrfX7kf53z89Prg24jS+e/cuTM/uCK+xgkOzSsvvzI94Kh0b9jjnIM2Y6hD9Bw+n6OzvL5eoO6zqPjgJM5J/jg3GR9HqJfEeazj/bG83n/Fk+z2bZnIoJ/p8Xixxj5SfQWR4LgRHaIJ1JSqh2g6/vk4ZvJAi/Z9GFL7zKLempxoDNfuNan1HNpo1obm5DQ5uDkprQfytXXqxzKutyuen3z+eez0+hDnPTk5WeWbZUNW/XKPZ/+yD7Bw6Gishl2bx6UGlTzE9KMoo7p2Zbw2LiSXY34Y3R+pk7hc56DlNPxYEc0U9LVn/xIW9pOe5gfCuHbtT5U+T+1THATn8Cd0OaSxnF7TzsWgGo9E2xrtPlob8nGg5zYRd16XXgb2bWt+mcezCZNCRPTNb34zcXQsHR1FzXBrYmOypiM6jJoYFM0YNDGeJWIRY1FO5Yrmxjnav28jbotBauY0/iaKw2sl7ztBP5WxFSxq1+bg4rTtXJylZi1o96XsXGoLXovEgOS1pe7eeuut1X6iJ2QzJuWrr76iv/3bv6X45oGiHaY2LsXMcBRSS7QlNPVrYoj0cSGSHIO0ZBiyLQVNqq3UB18voiEq6/CLGxF3gfOIUm4AdJ5RtPm4uJp2LtZSY0Hcj2wfr5PaMeDxvK70tGTyXaQ7OTlZ/XtRPKt+42yI/90pz796PhwAzzH0ZER1Epw7e6xMDq83FBZiii//gH15NGPXxITUxHOxJeORbp9qpu252LobCRGuIwq1/IXL18ZdDMPu4evmgZHMmZSa3Egsp6ltRzRcey1c/lQ7t0/XRq3x8vF8HH/OO5c7d8Ma57/EbQtPUDybeZLi+Z1v/k7p/rAHHRaq46jNozInFV1q6106zoPEl8zFvH3Skmifioe2fA1YfZiGv3h5UB1nQso/dcUg4yDiL8JonhbU9i2JR7SchmtHNFy7BMtcKbi9s2bktQ96LEz30s6o2W3mZR7P5kzKV199RX/zN3+TbUeHg+py1MaH7I0HYk6U3Wrr1cRpYkKk8byBmB0ptOfa5vmROi00+EUP08HpNgo3n1K0+bg4rn1pTYwmpiX4ebAOZPXKflCoMSuPHz8uC1bGZl7u8Vy6dIkuX75Mz58/nxxHTyhUF6KJ4UCfiGjNibZmaZxUH6KJlcRg5iOtKZuT9PGxna8R0Xi8lr/oxTnT+rhrNu0GkMwnQk0+LpZrRzTcHvTwefgca2GJWvlzDAc/b4nGtRy0/Dk61U9azppS3d69e3d+cOVszqQQEb3yyit7k4JuXGudFOdk709BzQmaL4dmvEvFhEjiSxdw3JxMj49tubz1NwPuojbNgV348tfHsYG/IM4Ja8EuwvUgc1iDNj8ax+m49kFDhJzwWC5eo6KUdpmtogadE8me587rKY5yxqP83pO8WSEaYk9OTujk5GSmWzube7nH89lnn9H9+/c5GRHhGw/VIWhzoaYD1aVQ1wbGoboSkhyIdi6ZHtCYk1K/WE28hgi9uCGaASgdDf2iNW6JmjFJYxE9ptn/rSQDc/EaGItU4H5cM9g5iutG5npxijOePHnCSVbJJp+kEI1PU+KXfWLQExLVpaiJ9aCmQ9OXJiYEjUd1Hqneg8aVjMe8fa4p3RgkBsW5ul8eFsblL3K53PxPWDm09R4S65q1+ZA4REPk16usRTREeJ9ZgHD2F08G7GiXzqm8ER8Kf45z+PlHtAN+cuZPPuEURPTRRx9xktWyWZNCNH3ZJwV6QqK6EE1MCjSPta6EJEcrbYgmrnTRXsqchMdycfFx7uI16su6MU1p7ub/7o/kwrcGNHujRG0+JB7TTL7LySBzgmiSZEIkJoQjlStrXAJ8nD9fuDnlzisLJAYkPo/5kPl5j5qVrb7M49nsyz2e58+fJz/tgwwL0YRI9SXQXKiOSKYNkcahelSXQhKLarkLv8acaE0LCnLBmzLVi8MDwr6ldRPla5fkqnkCJUHaRyt9aQ9KNEReh/UbyixNiBU72q2iLsn5KNGG5y0ehsVs9WUez6afpBARXb58efJpH/xiYKtDkORCtagupHVMK61HGsNd1MvmJH18aCvdSFK5ZHUTzWP4C99U7xynz1/gNPWG1MYTrScHkS4PGsPt0amGCNOV+0ZrY9Gm4bfmnjUYFKJhzvhzcECiDSfRn7N8qI8Zn4jGMVt+mcez+Scpnt/+7d+GTzprXQlpDom+lTZEEodoEU2MLoYIu5DvjyTa0/FcPRKDIjchROEj4tzFqUxaLMuxLrg10aLJK4nBDcX+b1WavUJQ44yK0CIb2n/YeToi1Q+gZoUo9QT17bffprfeeiuj3w5HY1KeP39OP/jBDzgZfHKiupgl4jgt146A5EA0RLguBo1DdUT8hTxnTrg+Su0S0xIju7jNL1Q4c3EcrzNU7UDnUEJNTkkstw/3rZPm0p4ta4jwPicIpE3wWwytI7NnW+1VaV6pfkBiVgauXr16FE9RiI7g5R5P/LJPjOwC0kabAo1HdIgmBxqL6ogwLaKJ0cUQaS/guf64OrRxIaGWv8BN8w6hO/Dilhp3QjZp58cR14zELI22Jk0cahTmqbn10e3tLAJpDslLNLvcY5RCCsm/EI+sFX9+zZGaIKl+YIhxDj2XmDIOuQAAH2VJREFUh6cox8LRPEnx/OAHP1D/Nlqista5uo+SeiTxqBbVeVrqES2i8Ui0HiSGu8hze0HahtQkQXahIyo9Txen2giWc67J5RxNXpYr3XXlxiSt2bcAfc4QSInO5qTR3gmNi8TwWCA/twYkcRLtlLJZefvtt4/KpHyNE2yNV199dfK95MKCaBFNCTTeOQdppTpUT0QiPaJFNLGO03okMc75C7gLvuL2dI5Sfq4tdYyrtYRkzAMu+zXmKcWvk3geZHNSRptr3ENu//94n021kyNJ7bwEJB9f92TO0D/hnOS3Ff6VIOxvaTRrTkSiGG0ftJ//ecvVq1ePyqAQHeGTFCKi+/fv0/3790UbgNNy7SUksagW0SGaHEgsovEgWkQTItcTZa+IhXaun1J7ri13XP/TVRrrfAgWfabmp/Yj0Qg1eaWxc3lur8yOqDQzhbBeIkLS2lC/hcyR7uvW+hAf+/TpU0a5PY7mPSkhr776Kn355Zfsb6P1aG4yJaQxEj2iRTQxaAyqI8K11joiqZbo0OYk1V5z0fJwN/sWcGPUYpXXKo9Hki8tXdacEMlqJiI0rR1G/fmnMBZ73s8Zmqu1PsQ5Rx9//DEn2yRH+STF81u/9VuchD1ZuXZUk0ISh2gRTYhEb6210oRI9DljwrUN7fZtCJqLF0KrvIekdq45JPnz0tL+mx0Va/ZHJ4fxuolILD8U6EtClntdkkui9Uhibty4cXQv83iO2qQ8f/6cvv/972fbuaHXtueQxCFaK00MGoPqiHCttY6I17YyJ0i7FsmFTEPqjeKt+0RpNacpNH2NIXwsYmQQzf7I7BBfw4SCfP90wug1mdBgcDlRM4JgsY81OaQxnP7q1atH+xSF6MhNCtHw/pR79+5NjiFD5jRcewpJDKJFNES4zoPoEY0H0SIaIlxHhGtL5oTLoTUuLW78Fjk6w9qkzBkCZ3RDyumnjahBSevQejBdDm8wkkYCTX2ALWxx3khzSPVE+Zhnz54ljx8LR/fpnphXX32VLl++vP8eORG5mwuSIwSN8TpUy7WjuTyIHtF4EC2i0eg4rXNhzrkWy5Fu52JTbWHdXL854hy1+c4DubmSzBm3l+ba4SujoDBHXjvq8jn5eoj4/Yrizv4EB9ASRpzgi4L/V2BxnkjjJVpPqo9jfoLiOfonKZ7vf//79OWXX3IydvNw7R5UR2Sr5do9qI7IXotoQjg91+5BdJym1F4TW0LzU1cJ63xbQ7sOKdBceVm6AdEjmhJo7RNKITumfQmMtnbNOSKNleqJhpiPP/6Yrl69ykk3z9E/SfG89tprnIQ9aZF21FFLtETEarl2qY4I16JjQTShjtNz7aEG1ZXaUu1cfq4dIc5Rk4toPr8WNa6NVmOU5HJu/AqORl9zbT6tX/+cZpozB1J7Ei6Ea1+C+dSqUM8Ryc95idZzcnJyLgwK0Tl6kkI0vJH2r//6r2fHuSmobQ+RaIkwvZWG6HA6IlzL6bj2kJKWy6ON9W2an6BSWOWRIuk3nA5BWOFm3BZu7XPMw0r7INsUMQjLeiyZalyKkFUh2G8lJPs9RBrH6a9evUo//elPi5pj4ih/T0qOy5cv05UrV6CXfayRXBxQLaJDNETr1xHxWq7dSoMYEKQ91nIXpxy5PrX5ULixphn/WXkccYAY3VhGxnA+D95VnTmZxsGdEpFsPrhP5Ghxztns4XAoFem0P1xI4zj9jRs3ksePlXP1JMXj35/CDZ1rRzRcuwfVEeFaRIdoiOx1RLgW0XGa2nZOw8Vz7THoBU1Ci5xbRboeOSR5ULOBpUyL0rFQQiKSjSdHzrQ4tI5Y1mDbWpwLmhy1MT/96U/Pzcs8nnNpUoiIvvGNb7AnZE07FxuCai11iMaDahEdoiGy07Vsr4mVoLmwSWid/9BYrUOIJGdeOm3AU6KGBk4oGk8T0O6Nt6rl3pfkkmiJBv15e5nHc25Nypdffpl8f4qHm5ZcOxcXgmoPpSPCtFYaIlsdp6lp17b5dulFKqY2XkNtn/G0cOmAJSb87qaHW88U6ZDcNSN5OIEDtZCIiHRjM8Gi27rtOKF2b3skeSTaq1ev0ieffMLJjpJza1KI0kaFm46am5MH0SEaIlxHZK/lNFx7CKpFdJymZg0tYyUXKZQWOW2wqItf+1q4NUSYp6gzJ7KaMK0spxGturTYWmdYnT+SPJz2PBsUonNuUoiI7t27R59++ikR8Sdurp2LC0G0iIbIXkeEa2tu1h5UR4RpOU1Nza1iQ7iLVQ0tc+vhasLmTQu6LgjpVOsyJ7J8I2Gc6E2yO0LKskVQHofFOYPmKOnQfyj3WDk3vyclx2uvvUaXL19mb0K1BqWUQ6PhdKGWwyonkkPTF6flNEh77njNeLn2GK6/Glrm1uOYL3us5sG56VfQQrn659o08vp4rSzfQKoOl/iTRd4lEVXuBpG4jHwd5qDxub7O8xMUz7l/kuL5q7/6q+RHk0s3KAmcvrY9pIWW03HtqIbITse1lzSlWC4v164B/YmsNbV15KYmTKubviHI12e5BvNU4YHy4wK8DCfSckxz8foQy7krPXlJGxz5/mIjWAFOzf6XxO52O/rkk0/O3Sd5Upz7Jymef/iHf6ArV67svy+5aMlJjLjx2vYQVIvU5eF0SDuq4XShVtse6qTHLfrVEM5Py344UnWE9UyP0ewrn5fXTHHR19lRw7kZc6X7OlPN4ojQsUznitOm+5/P8Zgrrc9hOXceV/iTi0h/5WEjsDQQNXMkibtx40Y3KGd0kxLw+uuvs5tQstEQuHxcu4erW6rzcHNR045qQl1tfyWd9HjYhvRrTdh36mtp5n0Wbx1CrPKksZg/58avgoqIfB8lXchUGPaTzwEnV493MRwFg8X3QUrt+DAI7Xwhc33t2jV65513iprzRH+5J+LLL7+k733ve7Pj0mlC9CUNEk9kr/Nw+traEQ0RpkM0RLqaU8fR/kqkUwwHJY+FJbTKW09cV/38lrBYP6LcGuYYxHjMVMjHsYIZVvNgDlqW4XauOTe0sam4a9eu9fehRHSTkiA2Kpop4mI0N0ypxoNqEV1t3USYzkpDxOtaGhReXhZoL4ASdrtdclxL9B3Cz5WE8XfRSNcshzzNGIDHSmJYwQyruTCltiSjbVq737XxPq4blDT95Z4EV65coTfeeIOc4x/NpeBiam70kppQrUSnaQs1nM5Kg+paGRTnSjcZF3yV8WMIv6wpzUHpK60n9VcdLvrC1j+Hvr6xBjxWEjMdI0rNXBCRtDuezDDiVSx9JYMqqJ0jbayP6y/xpOlPUgp873vfo2fPnnGyCdx0ltq1bTGo1kKH5FhSQ4TpSjdmyfGY8s2lPdqf5trRqh7b+ZyuW11ucKuQ74fXs4IkQ15d7J7KcI9RGpbd7C96tOeSJu4f//Ef6dq1a5zsXNJNCoPEqHBTqbnZczlDUC2q82hr49otNUT1utRxPGfyaOrgQdBcONvhP7aL1tRmHtG15XCOaLdDzAYRbkw8sDDIicdkUaZwcCC69vXUbn3tuYPGdYNSppsUAM6oIFPYyqAgmhArvWY8MZyOa0c1HmnNXO5yM17XIUAvoMsS1oTNvWQY3Hoi6FPoP82TVMwkfAxEIg1uPGoRLKYQyT5JoT1fuLhuUHi6SQHJGRVk+qQ3R6QNaQ+RaIl0dSF9IBoiTIdoiNqMJd+M1XQMpC7A4JIQEX7jkOQcEAdkkfcdIjEmRLm60zlEiXkOak44wI0CgO65HJzpyJGK6wYFo5sUAaFRQaetzQ0S65vIVqsZC9rusdRxGs38L3LDOGPe13BAe6FcjiXrs517YFsBSMyJZK/BSWWs2qBwyPeaxemjOQfDmG5QcLpJEfL++++bvEdFc4NE2j2ojgjTasbCtYWgOqJ2/XGx02bJzaUGXTLNRXQZauvSzUeO+rUaE8hySfaPKDFGJuUWzEk4P9Ntju8ti9NDe4797Gc/6wZFQDcpChCjormRamKkGo+VVjOWGFTL6bh2T71BIUpd5cHuGUySZNFeWNvB1WM3H+P62OUkkq577nyZHUnJ6tmgOUHmt7yt840Wp4PknOoGRU43KUq+/vWvZ9s0N25tm0TjQbWcTjPOEEtdjaY897MjTLsGkySLILkg69iR5Xwg+0KLLPVcnI4XJZXh/P8UfeRCGmwH2byOyLfmECCPS8OdG9euXaOf/exnRU1nTv9lbkp+9KMfJY/rboS6Nt/OaTyoltOV2i3ya3SltlweLn/JoDinv5gOuOBrO4TzOf3iIlF0ifx6DF/5Na8l7Adjusb5+HZ7YT8fZ39EcGU54VcqhaPCvODIY4ei5HFpSnuuGxQ9/UlKBc+ePaP3339//73mxq1tQ9o9lrot1VtX6+xIoQ1FHbhR5j9Z1v7UWlqXVujWexqUzqFKvIfbw1U0SD03SJWboYB8n9nu1fCpSjcodXSTUok3KpoboiYGbUc1RDY6bVsMquV0NfVMm5GbTQlxQBKu5hLcY+hlKdey23FzrJ8HKbIpL+235NHUwalCVkA9ht2Jn9jssdur8m2fDpDnGTk9Pe0GpZJuUgx49uwZ3bp1K9lmbVCQ5UI0RDY6bVsMqkV0NTXZGBRYCORkBSaERsY5dwBjk+pvmbGH8OtBhNaVz4XsQawPMwy60xsTBN1+lG9jO6Ny7do1+vTTTzlZh6GbFCNSRsXSoKAXLmQ5EQ0Rr9OMIwWirdVg8ZPvCm0p7F7bRtZ5SZY3LG2Z7wU/vrp559efFcDnuRmCrtqaEBTdXpRt4bwYzdMNih3dpBgSGpWlDQqyjIiGCNNpxheypA7JMUrm2lI4khvDKk9btmRY7NamDN8NK4DOcXPA7tZhTmLk+1C2dfmXJXN0g2JLNynGPHv2jD755JPs71HR3Ny5JeLaUQ0RptOMQaLxINqaeRs0+78x7bMW4ObEUZ1gVRzKwCDr3AKsW+7c5TXmMN0VTYkj7v59APCCZFtUblTee+89evfdd+cNHTXdpDTi5s2bM6OiuaGWLmLI0iEaonodEo9oiGx0SA7uBpFO4QptCOrAavycHMpMEOn7RtZzCUqmVQJnjpuR6A56UgJIkuiWW4GsI3wb8kKf69NPP+2/qK0B3aQ0JDQqmhtq7ibK3Vw9yNJaaDRjS2GlRfJwmnnzeABIHyEOKMLVjqI1DOeR6ZTr5//Q5gQyJCFCOcQi247vBN/+vPDevW5QWtFNSmNu3rxJT58+zba3MCjIkiIaIl5XaxaI7HRcO6IpmZN0ew5YmGTpm1k3LGm4/YJgZXC0qMagCNHiqPWnyeQv28zJi7pBaUs3KQuQMyo6g5JuGzX8crbWILFEuI6I13LtiKZ0MwHSn1Fam2xTBCxsRtubxrrg9oWGdMq6flrUmWSBbvJPdIZ9t9z2k/Q3F3WD0p5uUhYiNiplg0KUv0nqjcESGiSeyFbHabj2QbP/W6EtBdd3sTkAFi7OFg0LsuYtKBldDYuPo0F34peYiChlCFpvQ2yfj5puUJahm5QF8UZFb1DmbWM7d7Osa/fUGhREQ4Tp7DREufnLh5fmIdsUAIlWx263288pdlFvD7LGrSmZXAkHHYtB1zpDUoLfY3bbMJ1omn/4phuU5egmZWHee++9zEs/k+8ybXKDgiyvhabWvHhQLaKr1cybJNocsHCztDIvyHouhWUtlrnUCEuwNyMc2J6q33p8gvv373WDsiDdpByAp0+f0nvvvTc5ljIipZsk8pMbsrScpnV7CKrldFw7oimZxkkL39UZsPDcEJsZbk0OiXVt1vmqAEvZG5NQz9/TjcE6rDMr6eDT01O6d+/TZFunHd2kHIjQqOQMR+5Gyd1Ah3Z+WWuffnAart2D6oh4LdeOaLj53bfwXRGyDjm4Omto9bTjmGgx/y1yqimUkn1SkotZfDthHeq3+TSwG5TD0U3KAXn69Cm9+65/olIyKGM7dwPlDAqy3LUaJJ4I1xFhWk7DtQ+a/d8ATQlIlIRbwxacN9OC7AUrluwLxoV/BetDZAfZRnynuu09BHWDcli6SVkB7777Hj19+mT/PWZQxuP775gbLLLUnKa2HdV4UC2n49v3fyvJCgYFqzPHIYxJia2aFm6dl2ANNXjMatGkWXwLlTvUbOl79+7T6Wl//8kh6SZlJbz77rtnn/yJW+oNCnID5LZBbTuq8cBaR+xPglwubH6yLbkGFtQYrYU1GhdubZfgUDUs1q9FN4tuHRuzcu/ePTo9PeVkncZ0k7Ii3nnn3cQnf3L/kN14cNqOm5dRw92g27aHSLS1BgXtizOIKFZ51kRL44Kuz5IcuqZF+2/QlSPcJNSjNyvdoKyHblJWxtOnT+mdd/y/olk2KNxNr7VB4WJRDRGu28MYFC4f1z5oZkdSsiKcwTxP5AwNshaHYE11LV6LYXepVMsZlZh5x2Etw/tP7s00ncPRTcoK8UYlvzQSk5LOwS17bbulZo8L/1qIqzQwg2b/t5JsRj61LE/nMCB7YwkOWoeway/fkSz0cEZlzm636wZlpXSTslKePn1KH3/8MT15Mn/5hwg1KPPjY3udCVnqCQsRzYbAfTyy1M6/PLT/W0mWpD81WTeiPXcgDl5jofsWla3FqNy8eZNu3rzJyToHoJuUlfPOO+8ERmVcqumqbcegcO0TXPhXJs7MoAjqO6O0FlaI5o2h5ftIDonlHC3NKmpPlDA9Z9rsm0Nvx/v37/f3n6yYblI2wNOnT+nGjXfIX0W4m2LpZsstd017TewEznDEcHrIoIB9RXCGsAZtTVLW+O/xICw1P61YS/3OOdrRjj1Hptjuk0Nsu9PTU7p582Y3KCunm5SNMBiVG1UGZWivu1lrTQqXdxDxZmKCC/+qNChcewFurjVA87QCljQzW5kTjkONo22/dvtgwS1Fp6endP/+fU7WWQHdpGyMGzfeoSdP/C9+S5kUvVGoade2Ie1JOIPCtZ9pNAbF0pyoxn4EbOnf7dGy9JiW7m+KjcNYwqj0l3e2RTcpG+Tjjz+mjz76aHacu3nWGAlO06JtRtKLKAyKK7SVUJqaENF4O4uzxfVZV831LqOlUekGZXt0k7JRnjx5Qjdu3Nh/X2NQattbtE3IyGaGYfatwsCk0JqaM+Bxdg7CVtdn3XXrnUYLk9Jf3tkuX+MEnXVycnJCd+7coZOTk7OLld4M1LS3aBtFtGmD4pzDxtk5CFtcH1/zmut2LpxbeZ3WQ7t582Y3KBumP0k5At5+++3gfSpzuCWuaW/RNgi45onjyLch7Sk0hiaAHd8C+BqWfJPrFljD2khZY81oSdPth+9Fi23bX97ZPt2kHAlPnjyht99+e3acW96a9hZtJT/APR1Jarj2GKk+xiliKuHWsAVbMz6HmCML1lB3bQnprYLtH+026y/vHA/dpBwZ8VMVtVmobNe2wSYh6Vdc+E0SdT4O5/8niAHh1mHtHNLQbHHuDl3z0L/tmpW3QLkv6fbpT0+Oi25SjhD/VIVb2pr2Fm1Tj4GbieGw0qBItCmQmhVwa7NFljArW523tdQ9rcN2vbDlT4uQ2P705Djpb5w9Qk5OTuju3bt0cnKS1XAXRa3R4PIiZM0EklpiOiTaucjcoDi3/jdF1mA9tnC+rHO3Zo11z+s4RF3pE52bov7m2OOlP0k5cj766CO6e/fu5Bi35DXt2jZ/XZKYibHZYZrxG0yXFiQOyU8hbo7PC9zTlWOYp7WPga8PeIwBgjwRmTMGxfH9V9sfP92knAOePHlCd+/e3b9XhVtyrdGoyTv4jBUblExTNyidmC2tL1aryllk0RkVIl+Hj+8v75wPukk5R7z11lv0+PHjoobbDlqTwhmU4X8yk8LVSmRgUDQxGZB6O9tla+srq1ftLGboTcrIZ5991p+enBO6STln+KcqObOiNRrcNuJMSguDQhTkZeSz/qX6AmitWyEeD/eSzTGy5TXV1263ztotc3p6Sp999hkn6xwR3aScU+7evSt6rwq3TdSxOYNy1pY+7FgTIdZNDxRBDQo3Z2tGU/uxmRU/B7vdTjUfa6R+HHZrLNkup6endOvWrf705BzSTco5Jnyqwm0DtQlh2jkDMz+EGQ8ivi6iwHDwUiI6PoPSqs4tGpZWc7EW7MZns7boFrl16xbdvHmTk3WOlG5SOnT37l26c+dOtp3bImoTUmrPGZRM20wH7Go0n4c1KPt0YMKF4NagNWs1LIeelyWxH6vNmpa2Rn960iHqJqUT8Oabbybfq9LEhDBt81dgcEMhMimAjqhgPHJ1VsLN6xY5pFk5xvlEaDtum/VMbYv+xtiOp5uUzoTHjx/Tm2++uf+e2x5qE1JqL9342YcZmJmpNijJQ2DCAtycHQtLGJbzMpc5lhl//TqGW6G/MbYT001KJ8ndu3fpww8/LGqaGBQitUkR6cBdL8pZATdfx0qtWTmv88ax7LzUrSHRYFT605NOim5SOlkeP35Md+7cMf+4crFdYVDQJx3DYVdsD0G1NQaFm6fzRM6w9DmSsfx81ZmUW7du0q1btzhZ55zSTUqHJWVWmhgUookhQD8a3MKkcGPwaA0Kmr/TkXC4fSU3Ktev95d2OjzdpHRg7ty5s/8UUGuTghiUokHg9MVQx5oYj9SkcHPT6UhY137CjMr16/1TOx2cblI6Yu7cuZN9vwq3nVQGJWgbv+UehcTf8jn3h4FTwgX/RUBydjoc699HeaPSzUlHQzcpHRWPHz+mDz/8cPZ+FW47LWZSBtHZ//h842H+KYrEoHDzsVX8sCrf99oB2N4emm+K/r6TjpZuUjpVhGaF20oWBgUyJx5X0Ce72RdRBDUp3HxsBckwummxYft7Z9gI3Zx0aukmpWPCnTt36Pbt20UNZ1IQQyExKVx/80N2T1GGrnndmmhxJeimBeeYLsXXr1/vL+10TOgmpWPKhx9+mHy/CmcYVmFQMm2jZv63FGPXeL1LccizfcuGpV8mMbo56VjTTUqnCaFZ4bYYYijMDArRzDsgn/rZmkEZ5mDdrsDStLBr3mlKNyedVnST0mnKhx9+WH4ZqPQU5ax9+B+2TaHtnDMprEEpiCh+SgHU0YD0+A3dQEM40wKtbWdRujnptKablM4i5MyK5VMUaCsLn6LoDArRkiYFGveeLRgWyXg6h6Cbk85SdJPSWZTQrLBbj3vKEsDm8kw8ycyxlL5NHtm3HMCkwGPOsgbDUjuGzpJ0c9JZmm5SOgfh9u3bdS8DBYi2cM6ksE9RMiJa1qCIxipiKcPSqv5OS05Pr9P773dz0lmeblI6B+X27dv06NEjevTo0bQBNCmi7dvgKUq6e0FNIKJxVmNlWJasudOC4anJdbp+vZuTzmHoJqWzCh49erQ3LE0MCtH+nsn/wrgUCduS7V5YVwHxGJuAmJY11Nmx4tatW/2XsHVWQTcpnVXhn6p88MEHRZ1q2+ZMCvsUZX603L2itgDV2BZjR7Xj66wT/8Skm5POmugmpbNabt++PTMr6u1q+BSFL4EVZBly6+NbEo+b+8hwZxucng5vhu0v6XTWSDcpndVz+/ZtevjwIT18+JCT5nEZg3LWFvwvL/DfNXqKMubV52gBd4VYs1lxztFuzQUekP5+k84W6CalsxkePXpEDx8+ZF8KmrGYQSHSGoy1GRR+nHPW5gXCS1s3KgOnp6f7jxF3Olugm5TOJvnggw/2poXFyKRgZwok2rPkx5cRsDGWWYsfiC9t59mo+N9tcv36dU7a6ayKblI6mwZ5ulLc4s7SoBBJTEY6Jx5vCT4+nEN7gtS6nyej0p+adI6BblI6R4P/VFD4dEVvUM4EJL2BY+K1GBTZ2HQcwheU1v3YjUr/+HDnmOgmpXOUfPDBB/TBBx9UmxTZ2cGLW73pVsowL8verJf0Btxl7diMyunp6dkndPrLOZ3jopuUzlHz8OFDevToEf3kJz+ZtXGGQX5mMJZnVQbFs+TNeplP2kguaUvU04r+ck7nPNBNSufcEBoWftfbmhQ+FyswYX66L3mTHvtuaQ6kl7SWtVjTjUnnvNFNSudcMvzelfQTFp1BIUoZDTwPLFSTP9WXuklP+29hDrSXsxa1WNGNSec8001K59wTGxbdKbFeg4KNp/VNOl2DtTnAxprGupYaujHpdAa6Sel0In7yk5/QgwfS33A7PY1kZ5VILAI/vVvfoMt1WBgEfKx5LOrQ0n+XSaczp5uUTqeA/3X8P/5x6mWhkPE0kp9R4gAI+and6gaN1VFrEOTjTVNbB0p/WtLp8HST0ukI8C8JzU2L3ftYatGf0q1uzng9NQZBP+45NXXk8KakPy3pdHC6Sel0lPinLA8ePKQHDx5w8gy2p1/96Wx9c9bVIzUJ9eNOI60jxj8l6U9LOh0d3aR0OkZ4w0JE9OMf/5hRe+xOP7tTue7GPEVfk8Qg2I19DlpH+ISkm5JOx4ZuUjqdhviXhR4+fLA3MCM2p579KYzdlDHqakMMgv3456Tq8Eakv3zT6bSjm5ROZ0GmT1t+xKh52p2+vDngsamNMyrt5mDk+vXr/SlJp3MAuknpdA7MYFwezP7O0fbUXY9J8aTMSos5eP/99/d/74ak0zks3aR0OislZ16WO2VrjEqbGmOjUjMX3Yx0Ouunm5ROZ4PEb8z90Y/qXzpKozUq7S4r3qhwl67wJRqi/t6RTmeLdJPS6RwhsYl58OAB/DLSFI1JaX9J2e12s6cf3YR0OsdHNymdzjnnwYMHxX8CYDA4+n8ioET4kkuK/jJMp3O++f8SQbUiin1pjQAAAABJRU5ErkJggg=="/></g></g></g></g><path class="cls-5" d="M218,224.57v44.1c14.58,10.4,29.24,23,29.34,39.25,0,6.68-2.18,20.53-18.5,27.66-14.1,6.16-28.84,5.45-29.55,2.06s5.57-4.43,14.76-8.28c12.32-5.17,14.77-13.58,14.77-18.56s-2.16-12-10.82-17.81v27.43c-2.31,3.29-10.54,5.56-10.54,5.56v-95.9c-8.37,4.79-13.61,9.3-13.61,14.65,0,4.87,3,9,8.29,13.27v25c-14.27-9-28.82-19.64-28.82-38.25,0-9.84,4.73-18.57,14.08-26,7-5.52,15.72-9.79,24.19-13.93,12.75-6.23,25.95-12.67,25.95-20.33,0-7-7.24-12.7-19.54-20.23v31.5L207.42,201V85.21s2.1-.13,5.21-.13,5.33.13,5.33.13v55.18l3.54,2.09c18,10.57,36.53,21.51,36.53,42s-19.91,30.21-37.47,38.78Zm24.7-179.52c-5.83-1.75-9.45.47-13,.14a90.94,90.94,0,0,0-13.7-.46,57.11,57.11,0,0,0-37.6,14.93C167.57,69.43,161.4,82.53,161.4,95.6c0,16,5.69,29.53,17.39,41.47,6.9,7,15.19,12.73,23.31,17.73V130.16c-11.67-8.63-20.17-18.89-20.17-34.56s16.61-30.33,34.18-30.33a68.84,68.84,0,0,1,10.89.94c2.37.64,3.2,4,9.69,4.69,7.77.86,20.32-.71,21.86-4.2S251.8,47.8,242.66,45.05Z"/></g></svg>"); +} \ No newline at end of file diff --git a/tests/test_report/expected-results/report.html b/tests/test_report/expected-results/report.html index ac74248d1..3f4f45037 100644 --- a/tests/test_report/expected-results/report.html +++ b/tests/test_report/expected-results/report.html @@ -1,1681 +1,106542 @@ + - + + - Snakemake Report - - - - - - - - + - .sidebar .nav-link.active { - color: #007bff; - } + + - .sidebar .nav-link:hover .feather, - .sidebar .nav-link.active .feather { - color: inherit; - } + - .sidebar-heading { - font-size: .75rem; - text-transform: uppercase; - } +
+

Loading Snakemake Report...

+

Please enable Javascript in your browser to see this report.

+
+ - /* - * Content - */ +
+
- [role="main"] { - padding-top: 65px; /* Space for fixed navbar */ - } + - - - - - - - - - - + function getComponentName(type) { + if (type == null) { + // Host root, text node or just invalid type. + return null; + } - - + { + if (typeof type.tag === 'number') { + error('Received an unexpected object in getComponentName(). ' + 'This is likely a bug in React. Please file an issue.'); + } + } - + if (typeof type === 'function') { + return type.displayName || type.name || null; + } - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - $(document).ready(function() { - // Hide loading screen when document is ready. - setTimeout(function(){ - $("#loading-screen").hide(); - }, 2000); - }); - - \ No newline at end of file diff --git a/tests/test_report/report/workflow.rst b/tests/test_report/report/workflow.rst index 124933f92..b455d79cf 100644 --- a/tests/test_report/report/workflow.rst +++ b/tests/test_report/report/workflow.rst @@ -1 +1 @@ -This is the workflow description. Test reference fig1.svg_. +This is the workflow description. Test reference fig1.svg_. And a reference to a category `Step 2`_. From 2bc167b77b4a2d7a7f0bb4f3b55aa64099adaf07 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Johannes=20K=C3=B6ster?= Date: Sat, 12 Mar 2022 22:27:39 +0100 Subject: [PATCH 45/45] cleanup --- snakemake/report/template/components/abstract_results.js | 1 - 1 file changed, 1 deletion(-) diff --git a/snakemake/report/template/components/abstract_results.js b/snakemake/report/template/components/abstract_results.js index 2c4854a6a..fe51d294c 100644 --- a/snakemake/report/template/components/abstract_results.js +++ b/snakemake/report/template/components/abstract_results.js @@ -83,7 +83,6 @@ class AbstractResults extends React.Component { } renderEntries() { - let _this = this; let app = this.props.app; let labels = undefined; if (this.isLabelled()) {