diff --git a/.gitignore b/.gitignore index eaaafb2..5c12847 100644 --- a/.gitignore +++ b/.gitignore @@ -141,3 +141,5 @@ dmypy.json # Ignore UV dev environments uv.lock uv.lock.bak + +tmp_img/ diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..6456dcd --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "examples/fem-shapeopt/jax-fem"] + path = examples/fem-shapeopt/jax-fem + url = https://github.com/andrinr/jax-fem.git diff --git a/examples/ansys/Readme.md b/examples/ansys/Readme.md new file mode 100644 index 0000000..697f135 --- /dev/null +++ b/examples/ansys/Readme.md @@ -0,0 +1,90 @@ +# ANSYS Tesseract Integration + +This directory contains an example Tesseract configuration and scripts demonstrating how to use Tesseract-JAX with ANSYS spaceclaim and PyMAPDL. + +![Mesh over optimization](mesh_optim.gif) +![Rho over optimization](rho_optim_x.gif) + +## Get Started + +### PL internal instructions: + +- Our open ports are: 443 and 50052. +- Make sure to be connected to the PL VPN. + +### Prerequisites + +For the windows machine: +1. ANSYS installed and an active license. +2. Python and a python environment (e.g., conda, venv). +3. Two open ports. + +For the linux machine: +1. Docker installed and running. +2. Python and a python environment (e.g., conda, venv). + +### SpaceClaim Tesseract + +Create a new python env. Assuming you using windows powerhsell, install the required dependencies: + +```bash +pip install tesseract-core[runtime] trimesh +``` + +Clone this repository, navigate to the `examples/ansys/spaceclaim_tess` directory and start the Tesseract runtime server with: + +```bash +tesseract-runtime serve --port --host 0.0.0.0 +``` +Note that we dont build a Tesseract image for SpaceClaim in this example. This is because SpaceClaim cannot be installed in a containerized environment. You can test it using git bash and your specific Spaceclaim.exe Path: + +```bash +curl -d '{"inputs":{"differentiable_parameters": [[200, 600, 0, 3.14, 0.39, 3.53, 0.79, 3.93, 1.18, 4.32, 1.57, 4.71, 1.96, 5.11, 2.36, 5.50, 2.75, 5.89], [400, 400, 0, 3.14, 0.39, 3.53, 0.79, 3.93, 1.18, 4.32, 1.57, 4.71, 1.96, 5.11, 2.36, 5.50, 2.75, 5.89]], "non_differentiable_parameters": [800, 100], "string_parameters":["F:\\ANSYS Inc\\v242\\scdm\\SpaceClaim.exe", "geometry_generation.scscript"]}}' -H "Content-Type: application/json" http://0.0.0.0:443/apply +``` + + +or the equivalent on powershell: + +```powershell +Invoke-RestMethod -Uri "http://127.0.0.1:8000/apply" -Method Post -Body ( + @{ + inputs = @{ + differentiable_bar_parameters = [[0, 3.14], [0.39, 3.53], [0.79, 3.93], [1.18, 4.32], [1.57, 4.71], [1.96, 5.11], [2.36, 5.50], [2.75, 5.89]] + differentiable_plane_parameters = [200, 600] + non_differentiable_parameters = [800, 100] + string_parameters = ["F:\\Ansys installations\\ANSYS Inc\\v241\\scdm\\SpaceClaim.exe", "geometry_generation.scscript"] + } + } | ConvertTo-Json -Depth 10 +) -ContentType "application/json" +``` + +### PyMAPDL Server + +On a windows machine, make sure ansys is installed. Then run the following powershell command to start ansys with grpc server enabled: + +```powershell +Start-Process -FilePath "F:\ANSYS Inc\v242\ansys\bin\winx64\ANSYS242.exe" -ArgumentList "-grpc", "-port", "" +``` + +replace "v242" with your ansys version. + +### Build tesseracts + +1. Obtain the ip adress of the windows machine by running: + +```powershell +(Get-NetIPAddress -AddressFamily IPv4 -InterfaceAlias "Wi-Fi","Ethernet" | Where-Object {$_.IPAddress -notlike "169.254.*" -and $_.IPAddress -ne $null}).IPAddress +``` +2. On the linux machine, create a new python env and install tesseract-core with: + +```bash +pip install tesseract-core[runtime] +``` + +3. Build all relevant tesseracts: + +```bash +tesseract build fem_tess +tesseract build pymapdl_tess +tesseract build meshing_tess +``` diff --git a/examples/ansys/__init__.py b/examples/ansys/__init__.py new file mode 100644 index 0000000..c3e29b8 --- /dev/null +++ b/examples/ansys/__init__.py @@ -0,0 +1,9 @@ +from . import _version + +__version__ = _version.get_versions()["version"] + +# import public API of the package +# from . import + +# add public API as strings here, for example __all__ = ["obj"] +__all__ = [] diff --git a/examples/ansys/_version.py b/examples/ansys/_version.py new file mode 100644 index 0000000..21af50f --- /dev/null +++ b/examples/ansys/_version.py @@ -0,0 +1,683 @@ + +# This file helps to compute a version number in source trees obtained from +# git-archive tarball (such as those provided by githubs download-from-tag +# feature). Distribution tarballs (built by setup.py sdist) and build +# directories (produced by setup.py build) will contain a much shorter file +# that just contains the computed version number. + +# This file is released into the public domain. +# Generated by versioneer-0.29 +# https://github.com/python-versioneer/python-versioneer + +"""Git implementation of _version.py.""" + +import errno +import os +import re +import subprocess +import sys +from typing import Any, Callable, Dict, List, Optional, Tuple +import functools + + +def get_keywords() -> Dict[str, str]: + """Get the keywords needed to look up the version information.""" + # these strings will be replaced by git during git-archive. + # setup.py/versioneer.py will grep for the variable names, so they must + # each be defined on a line of their own. _version.py will just call + # get_keywords(). + git_refnames = "$Format:%d$" + git_full = "$Format:%H$" + git_date = "$Format:%ci$" + keywords = {"refnames": git_refnames, "full": git_full, "date": git_date} + return keywords + + +class VersioneerConfig: + """Container for Versioneer configuration parameters.""" + + VCS: str + style: str + tag_prefix: str + parentdir_prefix: str + versionfile_source: str + verbose: bool + + +def get_config() -> VersioneerConfig: + """Create, populate and return the VersioneerConfig() object.""" + # these strings are filled in when 'setup.py versioneer' creates + # _version.py + cfg = VersioneerConfig() + cfg.VCS = "git" + cfg.style = "pep440" + cfg.tag_prefix = "v" + cfg.parentdir_prefix = "structural_shape_optim-" + cfg.versionfile_source = "structural_shape_optim/_version.py" + cfg.verbose = False + return cfg + + +class NotThisMethod(Exception): + """Exception raised if a method is not valid for the current scenario.""" + + +LONG_VERSION_PY: Dict[str, str] = {} +HANDLERS: Dict[str, Dict[str, Callable]] = {} + + +def register_vcs_handler(vcs: str, method: str) -> Callable: # decorator + """Create decorator to mark a method as the handler of a VCS.""" + def decorate(f: Callable) -> Callable: + """Store f in HANDLERS[vcs][method].""" + if vcs not in HANDLERS: + HANDLERS[vcs] = {} + HANDLERS[vcs][method] = f + return f + return decorate + + +def run_command( + commands: List[str], + args: List[str], + cwd: Optional[str] = None, + verbose: bool = False, + hide_stderr: bool = False, + env: Optional[Dict[str, str]] = None, +) -> Tuple[Optional[str], Optional[int]]: + """Call the given command(s).""" + assert isinstance(commands, list) + process = None + + popen_kwargs: Dict[str, Any] = {} + if sys.platform == "win32": + # This hides the console window if pythonw.exe is used + startupinfo = subprocess.STARTUPINFO() + startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW + popen_kwargs["startupinfo"] = startupinfo + + for command in commands: + try: + dispcmd = str([command] + args) + # remember shell=False, so use git.cmd on windows, not just git + process = subprocess.Popen([command] + args, cwd=cwd, env=env, + stdout=subprocess.PIPE, + stderr=(subprocess.PIPE if hide_stderr + else None), **popen_kwargs) + break + except OSError as e: + if e.errno == errno.ENOENT: + continue + if verbose: + print("unable to run %s" % dispcmd) + print(e) + return None, None + else: + if verbose: + print("unable to find command, tried %s" % (commands,)) + return None, None + stdout = process.communicate()[0].strip().decode() + if process.returncode != 0: + if verbose: + print("unable to run %s (error)" % dispcmd) + print("stdout was %s" % stdout) + return None, process.returncode + return stdout, process.returncode + + +def versions_from_parentdir( + parentdir_prefix: str, + root: str, + verbose: bool, +) -> Dict[str, Any]: + """Try to determine the version from the parent directory name. + + Source tarballs conventionally unpack into a directory that includes both + the project name and a version string. We will also support searching up + two directory levels for an appropriately named parent directory + """ + rootdirs = [] + + for _ in range(3): + dirname = os.path.basename(root) + if dirname.startswith(parentdir_prefix): + return {"version": dirname[len(parentdir_prefix):], + "full-revisionid": None, + "dirty": False, "error": None, "date": None} + rootdirs.append(root) + root = os.path.dirname(root) # up a level + + if verbose: + print("Tried directories %s but none started with prefix %s" % + (str(rootdirs), parentdir_prefix)) + raise NotThisMethod("rootdir doesn't start with parentdir_prefix") + + +@register_vcs_handler("git", "get_keywords") +def git_get_keywords(versionfile_abs: str) -> Dict[str, str]: + """Extract version information from the given file.""" + # the code embedded in _version.py can just fetch the value of these + # keywords. When used from setup.py, we don't want to import _version.py, + # so we do it with a regexp instead. This function is not used from + # _version.py. + keywords: Dict[str, str] = {} + try: + with open(versionfile_abs, "r") as fobj: + for line in fobj: + if line.strip().startswith("git_refnames ="): + mo = re.search(r'=\s*"(.*)"', line) + if mo: + keywords["refnames"] = mo.group(1) + if line.strip().startswith("git_full ="): + mo = re.search(r'=\s*"(.*)"', line) + if mo: + keywords["full"] = mo.group(1) + if line.strip().startswith("git_date ="): + mo = re.search(r'=\s*"(.*)"', line) + if mo: + keywords["date"] = mo.group(1) + except OSError: + pass + return keywords + + +@register_vcs_handler("git", "keywords") +def git_versions_from_keywords( + keywords: Dict[str, str], + tag_prefix: str, + verbose: bool, +) -> Dict[str, Any]: + """Get version information from git keywords.""" + if "refnames" not in keywords: + raise NotThisMethod("Short version file found") + date = keywords.get("date") + if date is not None: + # Use only the last line. Previous lines may contain GPG signature + # information. + date = date.splitlines()[-1] + + # git-2.2.0 added "%cI", which expands to an ISO-8601 -compliant + # datestamp. However we prefer "%ci" (which expands to an "ISO-8601 + # -like" string, which we must then edit to make compliant), because + # it's been around since git-1.5.3, and it's too difficult to + # discover which version we're using, or to work around using an + # older one. + date = date.strip().replace(" ", "T", 1).replace(" ", "", 1) + refnames = keywords["refnames"].strip() + if refnames.startswith("$Format"): + if verbose: + print("keywords are unexpanded, not using") + raise NotThisMethod("unexpanded keywords, not a git-archive tarball") + refs = {r.strip() for r in refnames.strip("()").split(",")} + # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of + # just "foo-1.0". If we see a "tag: " prefix, prefer those. + TAG = "tag: " + tags = {r[len(TAG):] for r in refs if r.startswith(TAG)} + if not tags: + # Either we're using git < 1.8.3, or there really are no tags. We use + # a heuristic: assume all version tags have a digit. The old git %d + # expansion behaves like git log --decorate=short and strips out the + # refs/heads/ and refs/tags/ prefixes that would let us distinguish + # between branches and tags. By ignoring refnames without digits, we + # filter out many common branch names like "release" and + # "stabilization", as well as "HEAD" and "master". + tags = {r for r in refs if re.search(r'\d', r)} + if verbose: + print("discarding '%s', no digits" % ",".join(refs - tags)) + if verbose: + print("likely tags: %s" % ",".join(sorted(tags))) + for ref in sorted(tags): + # sorting will prefer e.g. "2.0" over "2.0rc1" + if ref.startswith(tag_prefix): + r = ref[len(tag_prefix):] + # Filter out refs that exactly match prefix or that don't start + # with a number once the prefix is stripped (mostly a concern + # when prefix is '') + if not re.match(r'\d', r): + continue + if verbose: + print("picking %s" % r) + return {"version": r, + "full-revisionid": keywords["full"].strip(), + "dirty": False, "error": None, + "date": date} + # no suitable tags, so version is "0+unknown", but full hex is still there + if verbose: + print("no suitable tags, using unknown + full revision id") + return {"version": "0+unknown", + "full-revisionid": keywords["full"].strip(), + "dirty": False, "error": "no suitable tags", "date": None} + + +@register_vcs_handler("git", "pieces_from_vcs") +def git_pieces_from_vcs( + tag_prefix: str, + root: str, + verbose: bool, + runner: Callable = run_command +) -> Dict[str, Any]: + """Get version from 'git describe' in the root of the source tree. + + This only gets called if the git-archive 'subst' keywords were *not* + expanded, and _version.py hasn't already been rewritten with a short + version string, meaning we're inside a checked out source tree. + """ + GITS = ["git"] + if sys.platform == "win32": + GITS = ["git.cmd", "git.exe"] + + # GIT_DIR can interfere with correct operation of Versioneer. + # It may be intended to be passed to the Versioneer-versioned project, + # but that should not change where we get our version from. + env = os.environ.copy() + env.pop("GIT_DIR", None) + runner = functools.partial(runner, env=env) + + _, rc = runner(GITS, ["rev-parse", "--git-dir"], cwd=root, + hide_stderr=not verbose) + if rc != 0: + if verbose: + print("Directory %s not under git control" % root) + raise NotThisMethod("'git rev-parse --git-dir' returned error") + + # if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty] + # if there isn't one, this yields HEX[-dirty] (no NUM) + describe_out, rc = runner(GITS, [ + "describe", "--tags", "--dirty", "--always", "--long", + "--match", f"{tag_prefix}[[:digit:]]*" + ], cwd=root) + # --long was added in git-1.5.5 + if describe_out is None: + raise NotThisMethod("'git describe' failed") + describe_out = describe_out.strip() + full_out, rc = runner(GITS, ["rev-parse", "HEAD"], cwd=root) + if full_out is None: + raise NotThisMethod("'git rev-parse' failed") + full_out = full_out.strip() + + pieces: Dict[str, Any] = {} + pieces["long"] = full_out + pieces["short"] = full_out[:7] # maybe improved later + pieces["error"] = None + + branch_name, rc = runner(GITS, ["rev-parse", "--abbrev-ref", "HEAD"], + cwd=root) + # --abbrev-ref was added in git-1.6.3 + if rc != 0 or branch_name is None: + raise NotThisMethod("'git rev-parse --abbrev-ref' returned error") + branch_name = branch_name.strip() + + if branch_name == "HEAD": + # If we aren't exactly on a branch, pick a branch which represents + # the current commit. If all else fails, we are on a branchless + # commit. + branches, rc = runner(GITS, ["branch", "--contains"], cwd=root) + # --contains was added in git-1.5.4 + if rc != 0 or branches is None: + raise NotThisMethod("'git branch --contains' returned error") + branches = branches.split("\n") + + # Remove the first line if we're running detached + if "(" in branches[0]: + branches.pop(0) + + # Strip off the leading "* " from the list of branches. + branches = [branch[2:] for branch in branches] + if "master" in branches: + branch_name = "master" + elif not branches: + branch_name = None + else: + # Pick the first branch that is returned. Good or bad. + branch_name = branches[0] + + pieces["branch"] = branch_name + + # parse describe_out. It will be like TAG-NUM-gHEX[-dirty] or HEX[-dirty] + # TAG might have hyphens. + git_describe = describe_out + + # look for -dirty suffix + dirty = git_describe.endswith("-dirty") + pieces["dirty"] = dirty + if dirty: + git_describe = git_describe[:git_describe.rindex("-dirty")] + + # now we have TAG-NUM-gHEX or HEX + + if "-" in git_describe: + # TAG-NUM-gHEX + mo = re.search(r'^(.+)-(\d+)-g([0-9a-f]+)$', git_describe) + if not mo: + # unparsable. Maybe git-describe is misbehaving? + pieces["error"] = ("unable to parse git-describe output: '%s'" + % describe_out) + return pieces + + # tag + full_tag = mo.group(1) + if not full_tag.startswith(tag_prefix): + if verbose: + fmt = "tag '%s' doesn't start with prefix '%s'" + print(fmt % (full_tag, tag_prefix)) + pieces["error"] = ("tag '%s' doesn't start with prefix '%s'" + % (full_tag, tag_prefix)) + return pieces + pieces["closest-tag"] = full_tag[len(tag_prefix):] + + # distance: number of commits since tag + pieces["distance"] = int(mo.group(2)) + + # commit: short hex revision ID + pieces["short"] = mo.group(3) + + else: + # HEX: no tags + pieces["closest-tag"] = None + out, rc = runner(GITS, ["rev-list", "HEAD", "--left-right"], cwd=root) + pieces["distance"] = len(out.split()) # total number of commits + + # commit date: see ISO-8601 comment in git_versions_from_keywords() + date = runner(GITS, ["show", "-s", "--format=%ci", "HEAD"], cwd=root)[0].strip() + # Use only the last line. Previous lines may contain GPG signature + # information. + date = date.splitlines()[-1] + pieces["date"] = date.strip().replace(" ", "T", 1).replace(" ", "", 1) + + return pieces + + +def plus_or_dot(pieces: Dict[str, Any]) -> str: + """Return a + if we don't already have one, else return a .""" + if "+" in pieces.get("closest-tag", ""): + return "." + return "+" + + +def render_pep440(pieces: Dict[str, Any]) -> str: + """Build up version string, with post-release "local version identifier". + + Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you + get a tagged build and then dirty it, you'll get TAG+0.gHEX.dirty + + Exceptions: + 1: no tags. git_describe was just HEX. 0+untagged.DISTANCE.gHEX[.dirty] + """ + if pieces["closest-tag"]: + rendered = pieces["closest-tag"] + if pieces["distance"] or pieces["dirty"]: + rendered += plus_or_dot(pieces) + rendered += "%d.g%s" % (pieces["distance"], pieces["short"]) + if pieces["dirty"]: + rendered += ".dirty" + else: + # exception #1 + rendered = "0+untagged.%d.g%s" % (pieces["distance"], + pieces["short"]) + if pieces["dirty"]: + rendered += ".dirty" + return rendered + + +def render_pep440_branch(pieces: Dict[str, Any]) -> str: + """TAG[[.dev0]+DISTANCE.gHEX[.dirty]] . + + The ".dev0" means not master branch. Note that .dev0 sorts backwards + (a feature branch will appear "older" than the master branch). + + Exceptions: + 1: no tags. 0[.dev0]+untagged.DISTANCE.gHEX[.dirty] + """ + if pieces["closest-tag"]: + rendered = pieces["closest-tag"] + if pieces["distance"] or pieces["dirty"]: + if pieces["branch"] != "master": + rendered += ".dev0" + rendered += plus_or_dot(pieces) + rendered += "%d.g%s" % (pieces["distance"], pieces["short"]) + if pieces["dirty"]: + rendered += ".dirty" + else: + # exception #1 + rendered = "0" + if pieces["branch"] != "master": + rendered += ".dev0" + rendered += "+untagged.%d.g%s" % (pieces["distance"], + pieces["short"]) + if pieces["dirty"]: + rendered += ".dirty" + return rendered + + +def pep440_split_post(ver: str) -> Tuple[str, Optional[int]]: + """Split pep440 version string at the post-release segment. + + Returns the release segments before the post-release and the + post-release version number (or -1 if no post-release segment is present). + """ + vc = str.split(ver, ".post") + return vc[0], int(vc[1] or 0) if len(vc) == 2 else None + + +def render_pep440_pre(pieces: Dict[str, Any]) -> str: + """TAG[.postN.devDISTANCE] -- No -dirty. + + Exceptions: + 1: no tags. 0.post0.devDISTANCE + """ + if pieces["closest-tag"]: + if pieces["distance"]: + # update the post release segment + tag_version, post_version = pep440_split_post(pieces["closest-tag"]) + rendered = tag_version + if post_version is not None: + rendered += ".post%d.dev%d" % (post_version + 1, pieces["distance"]) + else: + rendered += ".post0.dev%d" % (pieces["distance"]) + else: + # no commits, use the tag as the version + rendered = pieces["closest-tag"] + else: + # exception #1 + rendered = "0.post0.dev%d" % pieces["distance"] + return rendered + + +def render_pep440_post(pieces: Dict[str, Any]) -> str: + """TAG[.postDISTANCE[.dev0]+gHEX] . + + The ".dev0" means dirty. Note that .dev0 sorts backwards + (a dirty tree will appear "older" than the corresponding clean one), + but you shouldn't be releasing software with -dirty anyways. + + Exceptions: + 1: no tags. 0.postDISTANCE[.dev0] + """ + if pieces["closest-tag"]: + rendered = pieces["closest-tag"] + if pieces["distance"] or pieces["dirty"]: + rendered += ".post%d" % pieces["distance"] + if pieces["dirty"]: + rendered += ".dev0" + rendered += plus_or_dot(pieces) + rendered += "g%s" % pieces["short"] + else: + # exception #1 + rendered = "0.post%d" % pieces["distance"] + if pieces["dirty"]: + rendered += ".dev0" + rendered += "+g%s" % pieces["short"] + return rendered + + +def render_pep440_post_branch(pieces: Dict[str, Any]) -> str: + """TAG[.postDISTANCE[.dev0]+gHEX[.dirty]] . + + The ".dev0" means not master branch. + + Exceptions: + 1: no tags. 0.postDISTANCE[.dev0]+gHEX[.dirty] + """ + if pieces["closest-tag"]: + rendered = pieces["closest-tag"] + if pieces["distance"] or pieces["dirty"]: + rendered += ".post%d" % pieces["distance"] + if pieces["branch"] != "master": + rendered += ".dev0" + rendered += plus_or_dot(pieces) + rendered += "g%s" % pieces["short"] + if pieces["dirty"]: + rendered += ".dirty" + else: + # exception #1 + rendered = "0.post%d" % pieces["distance"] + if pieces["branch"] != "master": + rendered += ".dev0" + rendered += "+g%s" % pieces["short"] + if pieces["dirty"]: + rendered += ".dirty" + return rendered + + +def render_pep440_old(pieces: Dict[str, Any]) -> str: + """TAG[.postDISTANCE[.dev0]] . + + The ".dev0" means dirty. + + Exceptions: + 1: no tags. 0.postDISTANCE[.dev0] + """ + if pieces["closest-tag"]: + rendered = pieces["closest-tag"] + if pieces["distance"] or pieces["dirty"]: + rendered += ".post%d" % pieces["distance"] + if pieces["dirty"]: + rendered += ".dev0" + else: + # exception #1 + rendered = "0.post%d" % pieces["distance"] + if pieces["dirty"]: + rendered += ".dev0" + return rendered + + +def render_git_describe(pieces: Dict[str, Any]) -> str: + """TAG[-DISTANCE-gHEX][-dirty]. + + Like 'git describe --tags --dirty --always'. + + Exceptions: + 1: no tags. HEX[-dirty] (note: no 'g' prefix) + """ + if pieces["closest-tag"]: + rendered = pieces["closest-tag"] + if pieces["distance"]: + rendered += "-%d-g%s" % (pieces["distance"], pieces["short"]) + else: + # exception #1 + rendered = pieces["short"] + if pieces["dirty"]: + rendered += "-dirty" + return rendered + + +def render_git_describe_long(pieces: Dict[str, Any]) -> str: + """TAG-DISTANCE-gHEX[-dirty]. + + Like 'git describe --tags --dirty --always -long'. + The distance/hash is unconditional. + + Exceptions: + 1: no tags. HEX[-dirty] (note: no 'g' prefix) + """ + if pieces["closest-tag"]: + rendered = pieces["closest-tag"] + rendered += "-%d-g%s" % (pieces["distance"], pieces["short"]) + else: + # exception #1 + rendered = pieces["short"] + if pieces["dirty"]: + rendered += "-dirty" + return rendered + + +def render(pieces: Dict[str, Any], style: str) -> Dict[str, Any]: + """Render the given version pieces into the requested style.""" + if pieces["error"]: + return {"version": "unknown", + "full-revisionid": pieces.get("long"), + "dirty": None, + "error": pieces["error"], + "date": None} + + if not style or style == "default": + style = "pep440" # the default + + if style == "pep440": + rendered = render_pep440(pieces) + elif style == "pep440-branch": + rendered = render_pep440_branch(pieces) + elif style == "pep440-pre": + rendered = render_pep440_pre(pieces) + elif style == "pep440-post": + rendered = render_pep440_post(pieces) + elif style == "pep440-post-branch": + rendered = render_pep440_post_branch(pieces) + elif style == "pep440-old": + rendered = render_pep440_old(pieces) + elif style == "git-describe": + rendered = render_git_describe(pieces) + elif style == "git-describe-long": + rendered = render_git_describe_long(pieces) + else: + raise ValueError("unknown style '%s'" % style) + + return {"version": rendered, "full-revisionid": pieces["long"], + "dirty": pieces["dirty"], "error": None, + "date": pieces.get("date")} + + +def get_versions() -> Dict[str, Any]: + """Get version information or return default if unable to do so.""" + # I am in _version.py, which lives at ROOT/VERSIONFILE_SOURCE. If we have + # __file__, we can work backwards from there to the root. Some + # py2exe/bbfreeze/non-CPython implementations don't do __file__, in which + # case we can only use expanded keywords. + + cfg = get_config() + verbose = cfg.verbose + + try: + return git_versions_from_keywords(get_keywords(), cfg.tag_prefix, + verbose) + except NotThisMethod: + pass + + try: + root = os.path.realpath(__file__) + # versionfile_source is the relative path from the top of the source + # tree (where the .git directory might live) to this file. Invert + # this to find the root from __file__. + for _ in cfg.versionfile_source.split('/'): + root = os.path.dirname(root) + except NameError: + return {"version": "0+unknown", "full-revisionid": None, + "dirty": None, + "error": "unable to find root of source tree", + "date": None} + + try: + pieces = git_pieces_from_vcs(cfg.tag_prefix, root, verbose) + return render(pieces, cfg.style) + except NotThisMethod: + pass + + try: + if cfg.parentdir_prefix: + return versions_from_parentdir(cfg.parentdir_prefix, root, verbose) + except NotThisMethod: + pass + + return {"version": "0+unknown", "full-revisionid": None, + "dirty": None, + "error": "unable to compute version", "date": None} diff --git a/examples/ansys/bars_3d_tess/tesseract_api.py b/examples/ansys/bars_3d_tess/tesseract_api.py new file mode 100644 index 0000000..5e03033 --- /dev/null +++ b/examples/ansys/bars_3d_tess/tesseract_api.py @@ -0,0 +1,147 @@ +import numpy as np +import pyvista as pv +import trimesh +from pydantic import BaseModel, Field +from tesseract_core.runtime import Array, Float32 + +# +# Schemata +# + + +class InputSchema(BaseModel): + """Input schema for bar geometry design and SDF generation.""" + + differentiable_parameters: list[ + Array[ + (None,), + Float32, + ] + ] = Field( + description=( + "Vertex positions of the bar geometry. " + "The shape is (num_bars, num_vertices, 3), where num_bars is the number of bars " + "and num_vertices is the number of vertices per bar. The last dimension represents " + "the x, y, z coordinates of each vertex." + ) + ) + + non_differentiable_parameters: list[ + Array[ + (None,), + Float32, + ] + ] = Field(description="Flattened array of non-differentiable geometry parameters.") + + static_parameters: list[list[int]] = Field( + description=( + "List of integers used to construct the geometry." + " The first integer is the number of bars, and the second integer is the number of vertices per bar." + ) + ) + + string_parameters: list[str] = Field( + description="List of string parameters for geometry construction." + ) + + +class TriangularMesh(BaseModel): + """Triangular mesh representation with fixed-size arrays.""" + + points: Array[(None, 3), Float32] = Field(description="Array of vertex positions.") + faces: Array[(None, 3), Float32] = Field( + description="Array of triangular faces defined by indices into the points array." + ) + + +class OutputSchema(BaseModel): + """Output schema for generated geometry.""" + + meshes: list[TriangularMesh] = Field( + description="Triangular meshes representing the geometries" + ) + + +def pyvista_to_trimesh(mesh: pv.PolyData) -> trimesh.Trimesh: + """Convert a pyvista mesh to a trimesh style polygon mesh.""" + points = mesh.points + points_per_face = mesh.faces[0] + n_faces = mesh.faces.shape[0] // (points_per_face + 1) + + faces = mesh.faces.reshape(n_faces, (points_per_face + 1))[:, 1:] + + return trimesh.Trimesh(vertices=points, faces=faces) + + +def build_geometries( + differentiable_parameters: list[np.ndarray], + non_differentiable_parameters: list[np.ndarray], + static_parameters: list[list[int]], + string_parameters: list[str], +) -> list[trimesh.Trimesh]: + """Build a pyvista geometry from the parameters. + + The parameters are expected to be of shape (n_chains, n_edges_per_chain + 1, 3), + """ + n_geometrics = len(differentiable_parameters) + geometries = [] + for i in range(n_geometrics): + n_chains = static_parameters[i][0] + n_vertices_per_chain = static_parameters[i][1] + geometry = [] + + params = differentiable_parameters[i].reshape( + (n_chains, n_vertices_per_chain, 3) + ) + + radius = non_differentiable_parameters[i][0] + + for chain in range(n_chains): + tube = pv.Spline(points=params[chain]).tube( + radius=radius, capping=True, n_sides=30 + ) + tube = tube.triangulate() + tube = pyvista_to_trimesh(tube) + geometry.append(tube) + + # convert each geometry in a trimesh style mesh and combine them + mesh = geometry[0] + + for geom in geometry[1:]: + mesh = mesh.union(geom) + + geometries.append(mesh) + + return geometries + + +# +# Tesseract endpoints +# + + +def apply(inputs: InputSchema) -> OutputSchema: + """Generate mesh and SDF from bar geometry parameters. + + Args: + inputs: Input schema containing bar geometry parameters. + + Returns: + Output schema with generated mesh and SDF field. + """ + meshes = build_geometries( + differentiable_parameters=inputs.differentiable_parameters, + non_differentiable_parameters=inputs.non_differentiable_parameters, + static_parameters=inputs.static_parameters, + string_parameters=inputs.string_parameters, + ) + + return OutputSchema( + meshes=[ + TriangularMesh( + points=mesh.vertices.astype(np.float32), + faces=mesh.faces.astype(np.int32), + ) + for mesh in meshes + ], + ) diff --git a/examples/ansys/bars_3d_tess/tesseract_config.yaml b/examples/ansys/bars_3d_tess/tesseract_config.yaml new file mode 100644 index 0000000..fede8dd --- /dev/null +++ b/examples/ansys/bars_3d_tess/tesseract_config.yaml @@ -0,0 +1,9 @@ +name: design-bars-3d +version: "0.1.0" +description: | + Tesseract that generates 3D bar geometry. + + Parameters are expected to define the control points and radii of piecewise linear tubes in 3D space. + +build_config: + target_platform: "linux/x86_64" diff --git a/examples/ansys/bars_3d_tess/tesseract_requirements.txt b/examples/ansys/bars_3d_tess/tesseract_requirements.txt new file mode 100644 index 0000000..d656e66 --- /dev/null +++ b/examples/ansys/bars_3d_tess/tesseract_requirements.txt @@ -0,0 +1,3 @@ +numpy==1.26.4 +pyvista==0.45.2 +trimesh==4.9.0 diff --git a/examples/ansys/box_mesh.png b/examples/ansys/box_mesh.png new file mode 100644 index 0000000..89bd15e Binary files /dev/null and b/examples/ansys/box_mesh.png differ diff --git a/examples/ansys/box_mesh.stl b/examples/ansys/box_mesh.stl new file mode 100644 index 0000000..8b15322 --- /dev/null +++ b/examples/ansys/box_mesh.stl @@ -0,0 +1,2 @@ +solid +endsolid diff --git a/examples/ansys/demo.ipynb b/examples/ansys/demo.ipynb new file mode 100644 index 0000000..fe53f60 --- /dev/null +++ b/examples/ansys/demo.ipynb @@ -0,0 +1,24837 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "62c62e53", + "metadata": {}, + "source": [ + "# Parametric shape optimization with differentiable FEM simulation\n", + "\n", + "## Introduction\n", + "\n", + "In this notebook, we explore the optimization of a parametric structure made of a linear elastic material.\n", + "\n", + "We denote the design space as a function $g$ that maps the design variables to a signed distance field. Then, we can then define the density field $\\rho(\\mathbf{x})$ as a function of a signed distance field (SDF) value $g(\\mathbf{x})$. For adaptive meshing, we define a sizing field $h(\\mathbf{x})$ as a function of the SDF value as well.\n", + "We introduce an adpative differentiable mesher $m$ that takes the sizing field and returns a hex mesh. Finally we denote the differentiable finite element method (FEM) solver as $f$, which takes the density field and the hex mesh as input and returns the structure's compliance. Therefore, the optimization problem can be formulated as follows:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\min_{\\theta} f(m(g(\\theta)), \\rho(g(\\theta))).\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Here, $\\theta$ is the vector of design variables." + ] + }, + { + "cell_type": "markdown", + "id": "2a64957e", + "metadata": {}, + "source": [ + "### AD and Tesseracts\n", + "\n", + "Since we want use a gradient based optimizer, we need to compute the gradient of the compliance with respect to the design variables. Hence we are interested in the following derivative:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\frac{\\partial f}{\\partial\\theta} = \\frac{\\partial f}{\\partial \\text{mesh}} \\frac{\\partial \\text{mesh}}{\\partial g} \\frac{\\partial g}{\\partial \\theta} + \\frac{\\partial f}{\\partial \\rho} \\frac{\\partial \\rho}{\\partial g} \\frac{\\partial g}{\\partial \\theta}.\n", + "\\end{equation}\n", + "$$\n", + "Note that each term is a (Jacobian) matrix. With modern AD libraries such as [JAX](https://github.com/jax-ml/jax), backpropagation uses the vector-Jacobian-product to pull back the gradients over the entire pipeline, without ever materializing Jacobian matrices. This is a powerful feature, but it typically requires that the entire pipeline is implemented in a single monolithic application – which can be cumbersome and error-prone, and does not scale well to large applications or compute needs.\n", + "\n", + "With Tesseracts, we wrap each function in a separate module and then compose them together. To enable differentiability, we also define AD-relevant endpoints, such as the vector-Jacobian product, inside each Tesseract module (`tesseract_api.py`).\n", + "\n", + "To learn more about building and running Tesseracts, please refer to the [Tesseract documentation](https://docs.pasteurlabs.ai/projects/tesseract-core/latest/).\n", + "\n", + "### Setup\n", + "\n", + "Let's install the required packages and build the two Tesseract images. Building the Tesseracts can take a few minutes as they are Docker containers with quite a few dependencies." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "5f5b8544", + "metadata": {}, + "outputs": [], + "source": [ + "# Install additional requirements for this notebook\n", + "# %pip install -r requirements.txt -q --isolated" + ] + }, + { + "cell_type": "markdown", + "id": "8b22ac5f", + "metadata": {}, + "source": [ + "## Step 1: Build + inspect used Tesseracts" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "c367fd3b", + "metadata": {}, + "outputs": [], + "source": [ + "# import tesseract_core\n", + "\n", + "# tesseract_core.build_tesseract(\"design_tess\", \"latest\")\n", + "# tesseract_core.build_tesseract(\"fem_tess\", \"latest\")\n", + "# tesseract_core.build_tesseract(\"meshing_tess\", \"latest\")\n", + "# print(\"Tesseract built successfully.\")" + ] + }, + { + "cell_type": "markdown", + "id": "e771cce1", + "metadata": {}, + "source": [ + "### Explore Design Space Tesseract\n", + "\n", + "First, let's import the Tesseract Core library and start a server for the design space Tesseract, which is equivalent to the function $g$ in the equation above." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "64ebfb56", + "metadata": {}, + "outputs": [], + "source": [ + "import jax.numpy as jnp\n", + "import matplotlib.pyplot as plt\n", + "from tesseract_core import Tesseract" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "8a407fb1", + "metadata": {}, + "outputs": [], + "source": [ + "# design_tess = Tesseract.from_image(\"design-tube-sdf\")\n", + "# design_tess.serve()\n", + "design_tess = Tesseract.from_tesseract_api(\"design_tess/tesseract_api.py\")" + ] + }, + { + "cell_type": "markdown", + "id": "bb2d05dd", + "metadata": {}, + "source": [ + "Now we can setup the parameters for the design space and apply the design Tesseract. The Tesseract constructs a 3D geometry using PyVista and computes its signed distance field (SDF)." + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "id": "0fdeb653", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.5\n", + "0.0\n", + "Number of vertices: 180\n", + "Number of faces: 352\n", + "SDF shape: (100, 50, 50)\n" + ] + } + ], + "source": [ + "n_chains = 2\n", + "n_edges_per_chain = 2\n", + "bar_radius = 0.5\n", + "\n", + "Lx = 10\n", + "Ly = 5\n", + "Lz = 5\n", + "Nx = 100\n", + "Ny = 50\n", + "Nz = 50\n", + "\n", + "# Initialize chain parameter array\n", + "initial_params = jnp.zeros((n_chains, n_edges_per_chain + 1, 3), dtype=jnp.float32)\n", + "\n", + "for chain in range(n_chains):\n", + " initial_params = initial_params.at[chain, :, 0].set(\n", + " jnp.linspace(-Lx / 2, Lx / 2, n_edges_per_chain + 1)\n", + " )\n", + "\n", + " # add an offset\n", + " print(chain / n_chains * Ly - Ly / 2)\n", + " initial_params = initial_params.at[chain, :, 1].set(\n", + " (chain + 1) / (n_chains + 1) * Ly - Ly / 2\n", + " )\n", + "\n", + "design_out = design_tess.apply(\n", + " {\n", + " \"bar_params\": initial_params,\n", + " \"bar_radius\": bar_radius,\n", + " \"Lx\": Lx,\n", + " \"Ly\": Ly,\n", + " \"Lz\": Lz,\n", + " \"Nx\": Nx,\n", + " \"Ny\": Ny,\n", + " \"Nz\": Nz,\n", + " \"epsilon\": 1e-3, # epsilon, only used for FD of the jacobian\n", + " }\n", + ")\n", + "sdf = design_out[\"sdf\"]\n", + "surface_mesh = design_out[\"mesh\"]\n", + "\n", + "num_vertices = surface_mesh[\"n_points\"]\n", + "num_faces = surface_mesh[\"n_faces\"]\n", + "\n", + "print(f\"Number of vertices: {num_vertices}\")\n", + "print(f\"Number of faces: {num_faces}\")\n", + "\n", + "points = surface_mesh[\"points\"][:num_vertices]\n", + "faces = surface_mesh[\"faces\"][:num_faces]\n", + "\n", + "mesh = {\n", + " \"points\": points,\n", + " \"faces\": faces,\n", + "}\n", + "\n", + "print(\"SDF shape:\", sdf.shape)" + ] + }, + { + "cell_type": "markdown", + "id": "ad5503fb", + "metadata": {}, + "source": [ + "To better understand what's going on, let's import some internal functions from the design Tesseract, and visualize the structure and its SDF field." + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "id": "760cf3ee", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def plot_mesh(mesh: dict, save_path: str | None = None) -> None:\n", + " \"\"\"Plot a 3D triangular mesh with boundary conditions visualization.\n", + "\n", + " Args:\n", + " mesh: Dictionary containing 'points' and 'faces' arrays.\n", + " save_path: Optional path to save the plot as an image file.\n", + " \"\"\"\n", + " fig = plt.figure(figsize=(10, 8))\n", + " ax = fig.add_subplot(111, projection=\"3d\")\n", + " ax.plot_trisurf(\n", + " mesh[\"points\"][:, 0],\n", + " mesh[\"points\"][:, 1],\n", + " mesh[\"points\"][:, 2],\n", + " triangles=mesh[\"faces\"],\n", + " alpha=0.7,\n", + " antialiased=True,\n", + " color=\"lightblue\",\n", + " edgecolor=\"black\",\n", + " )\n", + " # add red bounding box to indicate domain\n", + " ax.plot(\n", + " [-Lx / 2, Lx / 2, Lx / 2, -Lx / 2, -Lx / 2],\n", + " [-Ly / 2, -Ly / 2, Ly / 2, Ly / 2, -Ly / 2],\n", + " -Lz / 2 * jnp.ones(5),\n", + " color=\"red\",\n", + " )\n", + " ax.plot(\n", + " [-Lx / 2, Lx / 2, Lx / 2, -Lx / 2, -Lx / 2],\n", + " [-Ly / 2, -Ly / 2, Ly / 2, Ly / 2, -Ly / 2],\n", + " Lz / 2 * jnp.ones(5),\n", + " color=\"red\",\n", + " )\n", + " ax.plot(\n", + " [-Lx / 2, -Lx / 2],\n", + " [-Ly / 2, -Ly / 2],\n", + " [-Lz / 2, Lz / 2],\n", + " color=\"red\",\n", + " )\n", + " ax.plot(\n", + " [Lx / 2, Lx / 2],\n", + " [-Ly / 2, -Ly / 2],\n", + " [-Lz / 2, Lz / 2],\n", + " color=\"red\",\n", + " )\n", + " ax.plot(\n", + " [Lx / 2, Lx / 2],\n", + " [Ly / 2, Ly / 2],\n", + " [-Lz / 2, Lz / 2],\n", + " color=\"red\",\n", + " )\n", + " ax.plot(\n", + " [-Lx / 2, -Lx / 2],\n", + " [Ly / 2, Ly / 2],\n", + " [-Lz / 2, Lz / 2],\n", + " color=\"red\",\n", + " )\n", + "\n", + " # plane on x=0 to visualize dirichlet boundary\n", + " yy, zz = jnp.meshgrid(\n", + " jnp.linspace(-Ly / 2, Ly / 2, 10), jnp.linspace(-Ly / 2, Ly / 2, 10)\n", + " )\n", + " xx = -jnp.ones_like(yy) * Lx / 2\n", + " ax.plot_surface(xx, yy, zz, alpha=0.4, color=\"green\")\n", + "\n", + " ax.set_xlim(-Lx / 2, Lx / 2)\n", + " ax.set_ylim(-Ly / 2, Ly / 2)\n", + " ax.set_zlim(-Lz / 2, Lz / 2)\n", + "\n", + " # x axis label\n", + " ax.set_xlabel(\"X\")\n", + " ax.set_ylabel(\"Y\")\n", + " ax.set_zlabel(\"Z\")\n", + "\n", + " # green arrow on bottom right to indicate force direction\n", + " ax.quiver(\n", + " Lx / 2,\n", + " 0,\n", + " -Lz / 2,\n", + " 0,\n", + " 0,\n", + " 1,\n", + " length=1.0,\n", + " color=\"green\",\n", + " arrow_length_ratio=0.3,\n", + " )\n", + "\n", + " if save_path:\n", + " # avoid showing the plot in notebook\n", + " plt.savefig(save_path)\n", + " plt.close(fig)\n", + "\n", + "\n", + "plot_mesh(mesh)" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "id": "85a4ee0e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 83, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# visualize the sdf by plotting a slice through each axis\n", + "fig, axs = plt.subplots(1, 3, figsize=(15, 5))\n", + "\n", + "axs[0].imshow(\n", + " sdf[Nx // 2, :, :].T, extent=(-Ly / 2, Ly / 2, -Lz / 2, Lz / 2), origin=\"lower\"\n", + ")\n", + "axs[0].set_title(\"SDF slice at x=0\")\n", + "axs[0].set_xlabel(\"y\")\n", + "axs[0].set_ylabel(\"z\")\n", + "# add colorbar\n", + "plt.colorbar(\n", + " axs[0].imshow(\n", + " sdf[Nx // 2, :, :].T, extent=(-Ly / 2, Ly / 2, -Lz / 2, Lz / 2), origin=\"lower\"\n", + " ),\n", + " ax=axs[0],\n", + ")\n", + "\n", + "axs[1].imshow(\n", + " sdf[:, Ny // 2, :].T, extent=(-Lx / 2, Lx / 2, -Lz / 2, Lz / 2), origin=\"lower\"\n", + ")\n", + "axs[1].set_title(\"SDF slice at y=0\")\n", + "axs[1].set_xlabel(\"x\")\n", + "axs[1].set_ylabel(\"z\")\n", + "# add colorbar\n", + "plt.colorbar(\n", + " axs[1].imshow(\n", + " sdf[:, Ny // 2, :].T, extent=(-Lx / 2, Lx / 2, -Lz / 2, Lz / 2), origin=\"lower\"\n", + " ),\n", + " ax=axs[1],\n", + ")\n", + "\n", + "axs[2].imshow(\n", + " sdf[:, :, Nz // 2].T, extent=(-Lx / 2, Lx / 2, -Ly / 2, Ly / 2), origin=\"lower\"\n", + ")\n", + "axs[2].set_title(\"SDF slice at z=0\")\n", + "axs[2].set_xlabel(\"x\")\n", + "axs[2].set_ylabel(\"y\")\n", + "\n", + "# add colorbar\n", + "plt.colorbar(\n", + " axs[2].imshow(\n", + " sdf[:, :, Nz // 2].T, extent=(-Lx / 2, Lx / 2, -Ly / 2, Ly / 2), origin=\"lower\"\n", + " ),\n", + " ax=axs[2],\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "1138150f", + "metadata": {}, + "source": [ + "Instead of calling the apply endpoint we can also call the vector-Jacobian product endpoint which is used for backpropagation (also called reverse-mode AD). This endpoint computes the derivative of the SDF with respect to the design variables, which is useful for gradient-based optimization. Hence we set the `vjp_inputs` to `bar_params` and the `vjp_outputs` to `sdf`, to indicate that we want to differentiate the SDF with respect to the shape parameters. " + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "id": "15c4b95e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gradient shape: (2, 3, 3)\n", + "0.006493404\n" + ] + } + ], + "source": [ + "grad = design_tess.vector_jacobian_product(\n", + " inputs={\n", + " \"bar_params\": initial_params,\n", + " \"bar_radius\": bar_radius,\n", + " \"Lx\": Lx,\n", + " \"Ly\": Ly,\n", + " \"Lz\": Nz,\n", + " \"Nx\": Nx,\n", + " \"Ny\": Ny,\n", + " \"Nz\": Nz,\n", + " \"epsilon\": 1e-3, # epsilon, only used for FD of the jacobian\n", + " \"normalize_jacobian\": True,\n", + " \"normalize_vjp\": False,\n", + " },\n", + " vjp_inputs=[\"bar_params\"],\n", + " vjp_outputs=[\"sdf\"],\n", + " cotangent_vector={\"sdf\": jnp.ones((Nx, Ny, Nz), dtype=jnp.float32)},\n", + ")[\"bar_params\"]\n", + "\n", + "print(\"Gradient shape:\", grad.shape)\n", + "print(grad.std())" + ] + }, + { + "cell_type": "markdown", + "id": "e2aed1e6", + "metadata": {}, + "source": [ + "Above we manually supplied all the relevant information regarding the VJP inputs, outputs, and cotangent vector. To make this easier, we can use the [Tesseract-JAX](https://github.com/pasteurlabs/tesseract-jax) library. Tesseract-JAX automatically registers Tesseracts as JAX primitives, which allows us to use JAX as an AD engine over functions that mix and match Tesseracts with regular JAX code. We can see this in action by using the `jax.vjp` function over `tesseract_jax.apply_tesseract`." + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "id": "a35ec0f0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gradient shape: (2, 3, 3)\n" + ] + } + ], + "source": [ + "import jax\n", + "from tesseract_jax import apply_tesseract\n", + "\n", + "primal, vjp_fun = jax.vjp(\n", + " lambda params: apply_tesseract(\n", + " design_tess,\n", + " {\n", + " \"bar_params\": params,\n", + " \"bar_radius\": bar_radius,\n", + " \"Lx\": Lx,\n", + " \"Ly\": Ly,\n", + " \"Lz\": Lz,\n", + " \"Nx\": Nx,\n", + " \"Ny\": Ny,\n", + " \"Nz\": Nz,\n", + " \"epsilon\": 0.01, # Smoothing parameter for SDF computation,\n", + " \"normalize_jacobian\": True,\n", + " },\n", + " )[\"sdf\"],\n", + " initial_params,\n", + ")\n", + "\n", + "grad = vjp_fun(jnp.ones((Nx, Ny, Nz), dtype=jnp.float32))[0]\n", + "\n", + "print(\"Gradient shape:\", grad.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "id": "028af743", + "metadata": {}, + "outputs": [], + "source": [ + "# Lets figure out a good epsilon value for FD jacobian computation\n", + "epsilons = jnp.logspace(-6, 0, 6)\n", + "mean_grads = []\n", + "std_grads = []\n", + "\n", + "for i in range(len(epsilons)):\n", + " eps = epsilons[i]\n", + " primal, vjp_fun = jax.vjp(\n", + " lambda params, eps=eps: apply_tesseract(\n", + " design_tess,\n", + " {\n", + " \"bar_params\": params,\n", + " \"bar_radius\": bar_radius,\n", + " \"Lx\": Lx,\n", + " \"Ly\": Ly,\n", + " \"Lz\": Lz,\n", + " \"Nx\": Nx,\n", + " \"Ny\": Ny,\n", + " \"Nz\": Nz,\n", + " \"epsilon\": eps.item(), # Smoothing parameter for SDF computation,\n", + " \"normalize_jacobian\": True,\n", + " },\n", + " )[\"sdf\"],\n", + " initial_params,\n", + " )\n", + "\n", + " grad = vjp_fun(jnp.ones((Nx, Ny, Nz), dtype=jnp.float32))[0]\n", + "\n", + " mean_grads.append(jnp.mean(jnp.abs(grad)))\n", + " std_grads.append(jnp.std(grad))" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "id": "e8c07a64", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 87, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(8, 6))\n", + "plt.plot(epsilons, mean_grads, marker=\"o\")\n", + "plt.plot(epsilons, std_grads, marker=\"x\")\n", + "plt.xlabel(\"Epsilon\")\n", + "plt.xscale(\"log\")\n", + "plt.yscale(\"log\")\n", + "plt.ylabel(\"Mean Absolute Gradient\")\n", + "plt.title(\"Effect of Epsilon on Gradient Magnitude\")\n", + "plt.grid(True)\n", + "plt.legend([\"Mean Gradient\", \"Std Dev of Gradient\"])" + ] + }, + { + "cell_type": "markdown", + "id": "463a15a9", + "metadata": {}, + "source": [ + "### Define mapping from SDF to Density Field\n", + "\n", + "Now that we have the signed distance field (SDF) from the design space, we can proceed to compute the *density field*, which is what the FEM solver expects. That is, we need to define a function $\\rho$ that maps the SDF to a density value. This function needs to be smooth and differentiable to ensure that the optimization process can effectively navigate the design space. We use a parametrized sigmoid function, which ensures that the density values are bounded between 0 and 1. Here, $s$ is the slope of the sigmoid and $\\varepsilon$ is the offset. The parameters $s$ and $\\varepsilon$ can be adjusted to control the steepness and position of the transition between 0 and 1 in the density field.\n", + "\n", + "$$\n", + "\\begin{equation}\n", + " \\rho(\\text{SDF}) = \\frac{1}{1 + e^{s \\cdot \\text{SDF} - \\varepsilon}}\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Since this function is straightforward to implement, we can directly use the JAX library to define it." + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "id": "28d0224a", + "metadata": {}, + "outputs": [], + "source": [ + "def sdf_to_rho(\n", + " sdf: jnp.ndarray, scale: float = 6.0, offset: float = 0.1\n", + ") -> jnp.ndarray:\n", + " \"\"\"Convert signed distance function to material density using sigmoid.\n", + "\n", + " Args:\n", + " sdf: Signed distance function values.\n", + " scale: Sigmoid steepness (higher = sharper transition).\n", + " offset: SDF value where density = 0.5.\n", + "\n", + " Returns:\n", + " Material density field in [0,1].\n", + " \"\"\"\n", + " return 1 / (1 + jnp.exp(scale * sdf - offset))" + ] + }, + { + "cell_type": "markdown", + "id": "ac5dbe99", + "metadata": {}, + "source": [ + "To verify the conversion, we can visualize the density field:" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "id": "50fe8408", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Rho shape: (100, 50, 50)\n", + "Rho min/max: 3.2785982e-07 0.93798834\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "rho = sdf_to_rho(sdf)\n", + "print(\"Rho shape:\", rho.shape)\n", + "print(\"Rho min/max:\", jnp.min(rho), jnp.max(rho))\n", + "fig, ax = plt.subplots(figsize=(10, 5))\n", + "im = ax.imshow(rho[:, :, Nz // 2].T, origin=\"lower\", cmap=\"viridis\", vmin=0, vmax=1)\n", + "ax.set_title(\"Density Field (rho)\")\n", + "ax.set_xlabel(\"x\")\n", + "ax.set_ylabel(\"y\")\n", + "plt.colorbar(im, ax=ax, label=\"Density value\")\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "id": "bca0eb5c", + "metadata": {}, + "outputs": [], + "source": [ + "def sizing_field(\n", + " sdf: jnp.ndarray, min_size: float = 0.1, max_size: float = 1.0, scale: float = 10.0\n", + ") -> jnp.ndarray:\n", + " \"\"\"Generate a sizing field from the signed distance function.\n", + "\n", + " The field is low (size = min_size) near the structure (sdf=0) and high (size = max_size) far from it.\n", + "\n", + " Args:\n", + " sdf: Signed distance function values.\n", + " min_size: Minimum element size near the structure.\n", + " max_size: Maximum element size far from the structure.\n", + " scale: Controls the transition steepness.\n", + "\n", + " Returns:\n", + " Sizing field values.\n", + " \"\"\"\n", + "\n", + " def gauss(x: jnp.ndarray, mu: float, sigma: float) -> jnp.ndarray:\n", + " return jnp.exp(-0.5 * ((x - mu) / sigma) ** 2)\n", + "\n", + " normalized_sdf = 1 - gauss(sdf, 0.0, 1.0 / scale)\n", + " return min_size + (max_size - min_size) * normalized_sdf" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "id": "ef6170aa", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sizing field: min 0.25, max 1.6666666269302368, mean 1.4966239929199219\n", + "Sizing field shape: (100, 50, 50)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sizing = sizing_field(sdf, min_size=Lx / 40, max_size=Lx / 6, scale=5.0)\n", + "print(f\"Sizing field: min {sizing.min()}, max {sizing.max()}, mean {sizing.mean()}\")\n", + "print(\"Sizing field shape:\", sizing.shape)\n", + "fig, ax = plt.subplots(figsize=(10, 5))\n", + "im = ax.imshow(sizing[:, :, Nz // 2].T, origin=\"lower\", cmap=\"plasma\")\n", + "ax.set_title(\"Sizing Field\")\n", + "ax.set_xlabel(\"x\")\n", + "ax.set_ylabel(\"y\")\n", + "plt.colorbar(im, ax=ax, label=\"Element Size\")\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "id": "90c95ec6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mesh points: 1645, Mesh faces: 1184\n" + ] + } + ], + "source": [ + "mesher = Tesseract.from_tesseract_api(\"meshing_tess/tesseract_api.py\")\n", + "\n", + "mesher_out = apply_tesseract(\n", + " mesher,\n", + " {\n", + " \"Lx\": Lx,\n", + " \"Ly\": Ly,\n", + " \"Lz\": Lz,\n", + " \"sizing_field\": sizing,\n", + " \"field_values\": rho,\n", + " \"max_subdivision_levels\": 4,\n", + " \"max_points\": 10000,\n", + " \"max_cells\": 10000,\n", + " },\n", + ")\n", + "print(\n", + " f\"Mesh points: {mesher_out['mesh']['n_points']}, Mesh faces: {mesher_out['mesh']['n_faces']}\"\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "id": "8acd332f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gradient shape: (100, 50, 50)\n" + ] + } + ], + "source": [ + "max_cells = 15000\n", + "primal, vjp_fun = jax.vjp(\n", + " lambda rho: apply_tesseract(\n", + " mesher,\n", + " {\n", + " \"Lx\": Lx,\n", + " \"Ly\": Ly,\n", + " \"Lz\": Lz,\n", + " \"sizing_field\": sizing,\n", + " \"field_values\": rho,\n", + " \"max_subdivision_levels\": 4,\n", + " \"max_points\": 20000,\n", + " \"max_cells\": max_cells,\n", + " },\n", + " )[\"mesh_cell_values\"],\n", + " rho,\n", + ")\n", + "grad = vjp_fun(jnp.ones((max_cells,), dtype=jnp.float32))[0]\n", + "print(\"Gradient shape:\", grad.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "id": "a5e6f69e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAeIAAAIeCAYAAABnUQxcAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsvXeUG9l55v3cKqBzzjk3c05DDjnM5DBMlGTJkr22rF1LtmV7fT7n9bFX8trr47SWLVm2pd11WEtrBdvSaqSZ4XACZ4ZDctjMsdk554xGN0LV/f54ugB0N4BGMwHdvL9z5gwJFoBCoXDf+6bnFVJKCYVCoVAoFFFBi/YJKBQKhULxJKMMsUKhUCgUUUQZYoVCoVAooogyxAqFQqFQRBFliBUKhUKhiCLKECsUCoVCEUWUIVYoFAqFIoooQ6xQKBQKRRRRhlihUCgUiiiiDLFC8ZBpbW2FEAJ/9md/Fu1T8fEP//APEEKgrq7uvl+joqICn/70p31/f+eddyCEwDvvvLPo19q/fz/279+/qOdYn6G1tXXR76dQxDLKECsALLxQ79+/H+vWrZv1WEVFBYQQQf87duwYAEBKiWeeeQa5ubkYGhqa97o/93M/B7vdjqtXr/oeGxsbw2/8xm+gtrYWiYmJKC8vx3/8j/8R7e3tEX8OIQTef//9ef8upURpaSmEEHjuuecWfL1o0draip/5mZ9BdXU1EhISUFBQgL179+K//tf/Gu1TUygUDxlbtE9AsbTZtGkTfvVXf3Xe40VFRQAAIQT+7u/+Dps2bcKv/dqv4e///u99x5w7dw5f+9rX8P/9f/8fNm3aBAAwTRNHjhzB7du38Qu/8AtYsWIFGhsb8dWvfhWvv/467ty5g9TU1AXPKyEhAd/85jexZ8+eWY+fOXMGnZ2diI+Pf4BP/WhpbGzE9u3bkZiYiM985jOoqKhAT08PLl++jD/+4z/GF7/4xWifIgBg7969mJqaQlxc3KKfe+rUqUU/5z/8h/+AH//xH4/p706huB+UIVY8EMXFxfjJn/zJsMesWbMGv/7rv47//t//Oz796U9j37598Hg8+OxnP4vS0tJZhuX8+fO4ePEivvKVr+Dzn/+87/GVK1fiM5/5DE6fPo2XX355wfM6ceIEvvOd7+Cv/uqvYLP5b/NvfvOb2Lp1KwYHB+/j0z4e/uIv/gIOhwNXr15FeXn5rH/r7++P0lnNR9M0JCQk3Ndz78d467oOXdfv6/0UilhGhaYVj4Xf/d3fRXV1NT73uc/B7Xbjz//8z3Hz5k185StfQXJysu+48fFxAEB+fv6s5xcWFgIAEhMTI3q/T37ykxgaGsIbb7zhe8ztduO73/0uPvWpTwV9jmma+NKXvoS1a9ciISEB+fn5+NznPoeRkZFZx9XV1eHZZ59FTk4OEhMTUVlZic985jNBX/NrX/saqqurER8fj+3bt+PixYsLnntTUxNKSkrmGWEAyMvLm/V3IQS+8IUvzDtubj7Xwul04nOf+xyys7ORlpaGn/qpn5r3+aSU+IM/+AOUlJQgKSkJBw4cwK1bt+a91twc8S/+4i8iJSUFTqdz3rGf/OQnUVBQAMMwAATPEX/5y1/G2rVrkZSUhMzMTGzbtg3f/OY3ff8eKkf81a9+FWvXrkV8fDyKiorw+c9/HqOjo7OOsVIrt2/fxoEDB5CUlITi4mL8yZ/8ybxzVSgeN8oQK2YxNjaGwcHBef95PJ6gx3s8nqDHT01NzTouISEBX/3qV1FfX49f+IVfwO///u/j5ZdfxvPPPz/ruG3btiE5ORm/+7u/i7feegtdXV04c+YMfuM3fgPbt2/H4cOHI/ocFRUV2LVrF/7v//2/vsdeffVVjI2N4cd//MeDPudzn/scfv3Xfx27d+/GX/7lX+JnfuZn8I1vfAPPPvus7/P39/fj6NGjaG1txW/91m/hy1/+Mn7iJ34C58+fn/d63/zmN/Gnf/qn+NznPoc/+IM/QGtrKz7ykY+EvJYW5eXl6OjowFtvvRXRZ10Mv/iLv4g7d+7gC1/4An7qp34K3/jGN/DSSy8hcBrq7/3e7+F3f/d3sXHjRvzpn/4pqqqqcPToUUxOToZ97U984hOYnJzED3/4w1mPO51O/OAHP8DHPvaxkB7t17/+dfzyL/8y1qxZgy996Uv44he/iE2bNuHChQth3/MLX/gCPv/5z6OoqAh//ud/jo9+9KP4u7/7Oxw9enTedR4ZGcGxY8ewceNG/Pmf/zlWrVqF3/zN38Srr74a9j0UikeOVCiklH//938vAYT9b+3atbOeU15eHvLYP/qjPwr6Pp/85CclAJmamio7OjqCHvPKK6/IwsLCWa/37LPPyomJiYg/x8WLF+VXvvIVmZqaKp1Op5RSyh/7sR+TBw4c8J37yZMnfc977733JAD5jW98Y9brvfbaa7Me//d//3ff64eipaVFApDZ2dlyeHjY9/j3v/99CUD+4Ac/CPsZbt68KRMTEyUAuWnTJvmf//N/lt/73vfk5OTkvGMByP/6X//rvMfLy8vlT//0T8+7Llu3bpVut9v3+J/8yZ9IAPL73/++lFLK/v5+GRcXJ0+ePClN0/Qd91/+y3+RAGa95ttvvy0ByLfffltKKaVpmrK4uFh+9KMfnXUu3/72tyUA+e677/oe27dvn9y3b5/v7y+++OK8+2su1mdoaWmZda5Hjx6VhmH4jvvKV74iAcj//b//96z3AyD/6Z/+yfeYy+WSBQUF885XoXjcKI9YMYu//uu/xhtvvDHvvw0bNgQ9/qmnngp6/Cc/+cmgx+fk5ABg3rikpCToMbm5udi8eTP+8A//EN/73vfwhS98Ae+99x5+5md+ZlGf5eMf/zimpqbwyiuvYGJiAq+88krIsPR3vvMdpKen48iRI7M8+61btyIlJQVvv/02ACAjIwMA8Morryzo2X7iE59AZmam7+/PPPMMAKC5uTns89auXYurV6/iJ3/yJ9Ha2oq//Mu/xEsvvYT8/Hx8/etfj/TjB+Wzn/0s7Ha77+8///M/D5vNhh/96EcAgNOnT8PtduOXfumXIITwHfcrv/IrC762EAI/9mM/hh/96EdwOBy+x7/1rW+huLh4XuFcIBkZGejs7IwodG9hneuv/MqvQNP8S9nP/uzPIi0tbZ5nnpKSMqueIS4uDjt27Fjw+1AoHjWqWEsxix07dmDbtm3zHs/MzAxa4JSTkxNxuLiurg5//dd/jXXr1uHChQv453/+53mFXs3NzThw4AD+6Z/+CR/96EcBAC+++KIv5/nqq6/i+PHjEb1fbm4uDh8+jG9+85twOp0wDAMf+9jHgh7b0NCAsbGxeTlYC6tIat++ffjoRz+KL37xi/iLv/gL7N+/Hy+99BI+9alPzavmLSsrm/V3yyjPzckGY8WKFfg//+f/wDAM3L59G6+88gr+5E/+BJ/97GdRWVkZ8TWfS21t7ay/p6SkoLCw0Jd3bWtrC3pcbm7urE1FKD7xiU/gS1/6Ev7f//t/+NSnPgWHw4Ef/ehH+NznPjfLsM/lN3/zN3H69Gns2LEDNTU1OHr0KD71qU9h9+7dIZ9jnevKlStnPR4XF4eqqirfv1uUlJTMO4fMzExcv359wc+lUDxKlEeseCwYhoHPfvazKCoqwtmzZ/HUU0/hV3/1V+cV1fzDP/wDpqen5/X4vvDCCwCAs2fPLup9P/WpT+HVV1/F3/7t3+L48eM+j3YupmkiLy8vqHf/xhtv4Pd///cB0Ov77ne/i3PnzuEXf/EX0dXVhc985jPYunXrLC8QQMh8qAzIxy6ErutYv349fvu3fxv//u//DgD4xje+seDzrKKox83OnTtRUVGBb3/72wCAH/zgB5iamsInPvGJsM9bvXo16uvr8S//8i/Ys2cP/vVf/xV79ux5qH3TD+P7UCgeBcoQKx4Lf/VXf4UrV67gy1/+MtLS0vC3f/u3GBoawm/91m/NOq6vrw9SynmGxAoDe73eRb3vyy+/DE3TcP78+ZBhaQCorq7G0NAQdu/ejcOHD8/7b+PGjbOO37lzJ/7wD/8QdXV1+MY3voFbt27hX/7lXxZ1bovFilT09PT4HsvMzJy3mXG73bOOCaShoWHW3x0OB3p6elBRUQEAvkrtuccNDAxE5MkDTAm89tprGB8fx7e+9S1UVFRg586dCz4vOTkZn/jEJ/D3f//3aG9vx8mTJ/GHf/iHmJ6eDnq8da719fWzHne73WhpaQlada5QxCLKECseOR0dHfi93/s9vPDCC3jppZcAUAjkl3/5l/H1r399VmXsihUrIKX0eVQWVvXz5s2bF/XeKSkp+Ju/+Rt84QtfmFehHcjHP/5xGIaB//bf/tu8f/N6vT5jNzIyMs+DssRIXC7Xos4tFO+9917Q/LOVxw0MxVZXV+Pdd9+dddzXvva1kB7x1772tVmv/Td/8zfwer2+cP/hw4dht9vx5S9/edbn/NKXvhTx+X/iE5+Ay+XCP/7jP+K1117Dxz/+8QWfM1d1LS4uDmvWrIGUMmQu/vDhw4iLi8Nf/dVfzTrX//W//hfGxsZw8uTJiM9ZoYgmKkeseCC6urrwz//8z/MeT0lJ8RndX/qlX4KUEl/+8pdnHfPFL34R3/72t/FzP/dzqKurg67r+PSnP40/+7M/w+c+9zlcuXIFa9euxeXLl/E//+f/xNq1ayMS85jLT//0Ty94zL59+/C5z30Of/RHf4SrV6/i6NGjsNvtaGhowHe+8x385V/+JT72sY/hH//xH/HVr34VL7/8MqqrqzExMYGvf/3rSEtLw4kTJxZ9bsH44z/+Y1y6dAkf+chHfEVyly9fxj/90z8hKytrVuHUf/pP/wk/93M/h49+9KM4cuQIrl27htdff91XFDcXt9uNQ4cO4eMf/zjq6+vx1a9+FXv27PGF/nNzc/Frv/Zr+KM/+iM899xzOHHiBK5cuYJXX3015GvOZcuWLaipqcHv/M7vwOVyLRiWBoCjR4+ioKAAu3fvRn5+Pu7cuYOvfOUrOHnyZEgltdzcXPz2b/82vvjFL+LYsWN44YUXfJ9p+/btCwrNKBQxQ9TqtRUxRWDbTzD27du3qPal8vJyKaW/3efP/uzPgr7ud7/7XQlA/o//8T98j3V2dsrPfOYzsrKyUsbFxcnCwkL5sz/7s3JgYOCBP0fguQe2L1l87Wtfk1u3bpWJiYkyNTVVrl+/Xv7Gb/yG7O7ullJKefnyZfnJT35SlpWVyfj4eJmXlyefe+45WVdX53sNq33pT//0T+e9PkK0GwVy9uxZ+fnPf16uW7dOpqenS7vdLsvKyuSnP/1p2dTUNOtYwzDkb/7mb8qcnByZlJQkn332WdnY2BiyfenMmTPys5/9rMzMzJQpKSnyJ37iJ+TQ0NC81/ziF78oCwsLZWJioty/f7+8efPmvNec274UyO/8zu9IALKmpiboZ5zbvvR3f/d3cu/evTI7O1vGx8fL6upq+eu//utybGxs3mew2pcsvvKVr8hVq1ZJu90u8/Pz5c///M/LkZGRee8XrD3qp3/6p333qkIRLYSUqlJBoVAoFIpooXLECoVCoVBEEWWIFQqFQqGIIsoQKxQKhUIRRZQhVigUCoUiiihDrFAoFApFFFGGWKFQKBSKKKIMsUKhUCgUUUQZYoVCoVAooogyxAqFQqFQRBFliBUKhUKhiCLKECsUCoVCEUWUIVYoFAqFIoooQ6xQKBQKRRRRhlihUCgUiiiiDLFCoVAoFFFEGWKFQqFQKKKIMsQKhUKhUEQRZYgVCoVCoYgiyhArFAqFQhFFlCFWKBQKhSKKKEOsUCgUCkUUUYZYoVAoFIooogyxQqFQKBRRRBlihUKhUCiiiDLECoVCoVBEEWWIFQqFQqGIIsoQKxQKhUIRRZQhVigUCoUiiihDrFAoFApFFFGGWKFQKBSKKKIMsUKhUCgUUUQZYoVCoVAooogyxAqFQqFQRBFliBUKhUKhiCLKECsUCoVCEUWUIVYoFAqFIoooQ6xQKBQKRRRRhlihUCgUiiiiDLFCoVAoFFFEGWKFQqFQKKKIMsQKhUKhUEQRZYgVCoVCoYgiyhArFAqFQhFFlCFWKBQKhSKKKEOsUCgUCkUUUYZYoVAoFIooogyxQqFQKBRRRBlihUKhUCiiiDLECoVCoVBEEWWIFQqFQqGIIsoQKxQKhUIRRZQhVigUCoUiiihDrFAoFApFFFGGWKFQKBSKKKIMsUKhUCgUUUQZYoVCoVAooogyxAqFQqFQRBFliBUKhUKhiCLKECsUCoVCEUWUIVYoFAqFIoooQ6xQKBQKRRRRhlihUCgUiiiiDLFCoVAoFFFEGWKFQqFQKKKIMsQKhUKhUEQRZYgVCoVCoYgiyhArFAqFQhFFlCFWKBQKhSKKKEOsUCgUCkUUUYZYoVAoFIooogyxQqFQKBRRRBlihUKhUCiiiDLECoVCoVBEEWWIFQqFQqGIIsoQKxQKhUIRRZQhVigUCoUiiihDrFAoFApFFFGGWKFQKBSKKKIMsUKhUCgUUUQZYoVCoVAooogt2iegUEQbKSUMw8D09DQ0TYPNZoPNZoMQAkKIaJ+eQqFY5ihDrHiikVLC4/HA6/XC7XYDgM8A67ruM8q6rivDrFAoHglCSimjfRIKRTQwTRNutxumaUIIAbfb7TO0UkqYpgkp5SzDbLfboes6dF2HpqnMjkKheHCUIVY8cVihaI/HAyklNE2DlNJniOd6vVLKoIY50FtWhlmhUNwvyhArnihM04TX64VhGAD8YWgpJVwuV0Th57mGGcCs3LIyzAqFYjEoQ6x4IrAMp+UFzzW4lkcMYNF5YOUxKxSKB0EZYsWyR0oJr9cLr9cLACHDz/driIO9X6C3bL1moGG2qrIVCoVCGWLFssbygg3DgBAipFf6MA1xsNe2DLPlMWuaFrQqW6FQPHkoQ6xYllgFWV6vF6ZpQtO0sIbuURriYO8VyjAHVmUrw6xQPBkoQ6xYdli9wXMLshZ6zuMyxHPfF0BQwzw3x6wMs0KxPFGGWLGsCOwNXsgLDiRahjjYeQDKMCsUTxLKECuWBcF6gxdjqGLFEM8l0DBbwiNA8HapWDpvhUIROcoQK5Y89xOKDvYasWiI52J5yVaeOdAwW/llm8226I2IQqGIHsoQK5Y0lhe82FD0XJaKIZ7LXMMMwBfKttvtPo9ZGWaFInZRhlixJImkN3ixr7cUDfFclGFWKJYeyhArlhxWb7BlaB6GYtVyMcRzCWWY5/YwK8OsUEQPZYgVS4ZAmcoHDUUHe+1A+cvlSjDDrGnavOIvZZgViseHMsSKJcHDKMiK5PWXuyGey1yjbFWcK8OsUDw+lCFWxDyBMpWPyiA8qYZ4LnMNMzA7xxyok/0kXyeF4mFii/YJKBShWKxMpeLBsQyslXe3DLP1PVj/HkwnW303CsX9oTxiRUzyqEPRod7vSfeIFyLUyMe5Otlq5KNCETnKECtijofVG7wYwhli0wSUXQmOMswKxYOjDLEiZnjYvcGLfe9ghvjGDQ03b2rIy5PYvdtAQsJjOZ0ly1zDDASX41SGWaHwo3LEipjANE14vd7HFoqOhIkJoK5Og8cDDAxoKC2VWLHCXPiJTzChcswejwdut9v378owKxR+lCFWRJXA3uDA0GYsYLcDiYnA8LBAUhIQF6eCR4slmGG2vm+Px+M7JtAwW1XZCsWTggpNK6LG4y7IiuRcrLy0RV+fQFubQHo6UFtrqlzxQyYwjB24EbMMc2BVtkKxXFGGWBEVHkdv8GIIZYgVj5dghlnTtHnFX9G+XxSKh4kyxIrHSqz2BitDHJuEMsxqFrNiOaEMseKxEUuh6LnEgiGWEnC5gPh4IEYuS0xhLVXKMCuWG8oQKx4LpmnC7XbHlBccSLQNsWEAH3ygo6VFoLRUYs8eA3b7Yz+NJYUyzIrlgqqaVjxSrFC0VRUdi0Y4FhgYELh5U0NSksTt2xpqakyUlqo9cjis+0jXdQCzJ0u5XC7fWEtlmBWxjjLEikfG3N5gZYRDk5AgkZIi0d8vkJMjkZQU7TNaegSmOnRdn2eYXS5X0AEW6r5URBsVmlY8dGK5NzgU0Q5NA0BPj0Bfn0BurkRxsfpZPmyCzWIONMxq5KMiWihDrHioRFOm8kEJbKdSLH9CGea5k6WUYVY8apQhVjw0AnuDA9WUonc+wOXLAg0NApWVEtu3S8ykE4OiDPGTTTDDrGnavByzMsyKh43KESsemFjtDe7vBy5eFNA0oK5OoKREoqQk2mcVO7hclPFU+w4SKsdsmiZcLhemp6eVYVY8EpQhVjwQc3uDY2lRstuBuDhgbEwgJUXCpu52AOxXvnJFw61bGrKzJfbtM5CcHO2zij3mplUsw2wYBgzDCFn8tZTSMYrYQC1Nivsm1nuDs7OBAwdMdHYKFBYCBQXRPqPYYGICuHZNg2kCDQ0aqqslVq5UU6UWItRkKSsaFDiLea5Odqz9NhSxhTLEikWzlHqDq6qAqqrIyiBi9TM8bOLjgZQUic5ODcnJQGKiKhO5H0IZZq/XC4/HE9IwqxoExVxUsZZiUcSyTOWD8iQVaw0NAZ2dGlJTJSorpZLUfAQE5pgD2/jmDrB4Eu43RXiUIVZEjOUFx2oo+kF5kgyx4vEz1zADwVW/1P335KEMsWJBlnJv8GJ4EEMsJXDzpobGRoGyMonNm9XsYkV4QnnMyjA/eagcsSIsVm9wYF/lk4bLxRafcEMYhoYELlzQ4fVK9PRoyM+XKClRe1wLa7u/DPdv902wHLP1e/N4PL5jAg2zVZWtWF4oQ6wISuCisFxD0ZHQ0EADGx8vsW+fiby84MZV0yR0XWJqSiA+XvXmBjI8DJw9q2N6GnjqKRNlZWqDEgwrf2wR+Bt0u93zPObAqmzF0kYZYsU8Yrk3+HFz9aqGiQlgYEBDU5MMaYizsoBnnjHQ3q6hsFCisFAZG4uGBg0NDRri4oCLF4GyMiPap7QkiMQwa5o2r/jrSf2tLmWUIVbMIlCm8kkzwME+a1YW0NUlYLMBKSnhn19TI1FTo4zMXKwIgdsNJRzyAERqmNXIx6WHKtZSAIhNmUqXC7h7V8DjAVaulEhNfbTvZxWkBebBnU6gpUWD3Q5UVZlKnes+cLuBu3c1uN1Aba2J9PRon9Hyw1rGrcIvq/hLGealgTLEipjtDb54UeDMGZ7Hhg0SR48+2ls1mCFWKJYiyjAvLdT+/gknlnuDp6YAQMBuByYnH/1+MZY++0IMDwO3b+tISJBYt85EQkK0z0gRSwQOrwBmG2aXywW32w0geB/zUvodLBeUIX5CmdsbHGtGGADWrJEYHjbhcgls3br8AzdSAtPTiKjq+oMPdNy7p0EIHrtli9KKVoQm0DAHTpaSUs4zzIEDLGJxXViOKEP8BGKaJrxeb8yFoueSkwO8+KKc0bOO9tk8WkwTOH+e1cX5+RL79xshvVwpmXe12QCvFzBUfdgs+vsFrl3TkJgIbN6sJksFI9TIRyklpqenfcdYhlmNfHy0KEP8BBFYZRmo5BPLCPFkiECMjDDUbLNJ3LunobbWRHV18CiAEMDOnSbq6oDERKjJSQFICZw7p6G5WYOUHGixdau6PgsRqWEONsAi1teQpYAyxE8IsVqQFUtYC080SEwE0tIkuroE0tLkgl5cUZHECy8oVzgYUj4Zm7dHSSjDbJqmMsyPAFU1/QTwJPcGL4b2dgOjo16UloqohDMHBwW6uwUyMqRSn3oAVGj60RPoMVv/aZo2r/hLrTeRoQzxMiYWe4NjlfZ24Ec/AsbGDNTWAsePGwjQTlAoFGEI9JgtgrVLqTUoOCo0vUxRMpWkvR24fJke7tNPhw75jo0JjI9LpKVJDA5qmJ5WKlCB9PcLDAwI5OaGlvlUPLkEG2AR6AgEzmKeq5P9JK5Lc1GGeBlimibcbvcT7wWbJgt3ensFPB6JnBxg8+bgRqS4WKK0VGJ4WGDtWhNJSY/5ZKOAYSAir39kBDh1Skd/v0BensTzz3uVOpYiLKEMs9frhcfjUYZ5DsoQLyOsHahVFf0kG2ELq8VHiPBGJysLeP55Aw6HF5mZ2rIu9pESuHJFw927GgoKJHbvNhAfH/r4yUmBsTEa4fFxgclJgfR05RVbTE0BTU0abDagutoMOy7zSWUxhjlwgMWTonKnDPEyYW5vcCwYYbebi1RqanTGAmoasHeviZwcgaQk6lWHIyEB0HW5rI0wAIyN0RBLCdy8qaGszERNTehrk58vsWKFic5OgRUrTOTmKiMcyIULOq5e1aBpwJ49SlwlEiI1zHNVv5arYVaGeIkTq73B4+PAG29oGBkBVq2S2L07OgYuNxfYty8ywxEL1+1xEBcHJCUBPT0CKSkI6w0DgN0OHDpkwOnk85bpWnjfjI4CdruE281ogWLxhDLM1mQpILgc53IxzMoQL2HmylTGihEGODqwtRXIzOQEpQ0bJNLSon1WsYNpcgFPSMBjz0cnJQEHDhjo7GSIuaRk4Y2Kpi08BvJJZeNGE06nDrvdxIoVyht+GAQzzJbD4fF4fMcsF8OsDPESJbA3OPCGjRXS0iTS0wVGRoCqKonExGifUWzx4Ycabt7UkZYmcfCggZycxxvuLSiQKChQIeaHQWWlRHGxF5oGNSbzERFuFnMow2yz2WLGMVkIddssMZZKb3BxMXD8uImJCYHiYrkkClge9Dp2dwvU12tIT5fYsCH07OLpaeDePQ26LtHZKdDVJR67IY51pqeBiQmKmyyFeycuLtpn8GQRzjC73W6fczK3+CsW10pAGeIlxVLrDS4uBoClZWDmXk8pgd5eAa+XspKhKq9dLuDdd3X09QloGpCaKlFbG/yzx8WxAMoy2hkZS+saPWocDuCNN3T09WmoqDBx6JCxJIyxInpEaphjdeSjMsRLBNUbHB0aGjScOaPD4wG2bjXw1FPBc4BSsk3KZpMwDAHDEAi1CdE0YN8+A9XV7FcuKlrehnhoCLh6VYem8RouVCvQ3y/Q3q4hL89Ea6uGkRFTiYjMYWICcDoFsrOlCocHIdAwB85idrvdcLlc8wyz9edoravqK4xxVG9wdOnrE3A6OcWnvV0LaYgTEoBduwzcvKkhO1uisjJ80U5CAsK2DC0n6up03L7Ndim7HdizJ/ywisxMqnf192soLTWRlvZkXKdIGRwUeOMNHWNjAitXmti3z1CV7GEIHF4BBDfMv/d7vwebzYYvfelLUTlHZYhjmKUWio4mzc2szrbUsx5WKLOkxERTk4DHI1BbG96AVFdLVFeriUhzsW5ZjrRc2KhmZgLHjnkxMkIRkVBzmZ9U+voEentZV9DaKrBtG3v1FZERzDBPTk4iNzc3auekDHGMYnnBT3ooemAAGBrigpyVFfwYpxN47z0No6MCDQ0SmZkImZ9dLJWVEunpXhiGKqi6X7ZtM2CzsaJ4/frI2nsyM+kZK+aTnS2RnS0xMkKP+EmQY32UCCHgcDhQVVUVtXNQhjjGmNsb/CQb4eFh4NVXNfT3A8XFAs8/b0all5UbgKVtFO7c0dDYyAr2TZvMxxrKzMoCDh5UkYKHRUGBxMmTXjgcAgUFoQsIFZHjdDqRHMUpL8oQxxBWlZ81SizWeoMfN+PjNMZ5efz/xERwUYmkJOCZZ0zU1wtkZ9OLXe5MTwMtLRpsNomqqvCL8dCQwAcfaHC7gY4ODXl5kYl4KGKX7Gx6xoqHw+TkJFKiqFijDHEMEFhq/6SHogMpKGBBU3e3QG0tpyeFoqqKwiFLGY+HhTjJyQurkJ0/T31jXWcF9oYNoUO+QlBe1DAEbDZ/zlbhp6FB4M4dDbm5Etu2qcENTxrKED/hxGpBVm8vc6/FxQtrET8qEhKAY8ckHA6J1NTIRvYtVUwTeO89HfX1GjIyJI4cCa+2NTQExMdLTE8LjI+Hv1+ysoBnnjHQ0qKhsFAu+3apvj6Bnh6BrCyJsrKFP6vDAZw7p8PhANraaIyflIp2BZmcnFSh6SeVQJnKWDHAANDWxoENExPAmjUSR49GbyKRzQZkZETnvR8nk5NAa6tAaqpEb69Af3/44rANG0xcuKAjK0uipmbhAqjaWrlg1fdyYGICOH2awiqZmRInTxoL9iALwd5ur5diLDHyM4wphoYE6uo4HnTbNiNk4eRSxKqaTo1i6bkyxFEg1mUqh4epEZ2VxQk9LpdqIZnL4KDA2BgLZx7GRjopCSgulmhooEe2UIV2ba1EaSn1jZW8op/paU5Aysri7GSnc+HnJCczYtDUpCEzU6KiQnnDc7l8WcPt26xZsds5NGQ54XQ6VWj6SSJWQ9GBFBVJFBUJTExwhOGTYoQ9Hu7809PDG7f+foHXXtMxMiJQVWXi2LEHl2DUdWD/fgNr1phITg7dqhXIk/K9LIbsbIm1a2lU1641Iw7Dl5dLlJcvL+PyMNF1qscJsTwHW6jQ9BPEUukNzs8HXnzRxNQUqzOXOl4vc7DhjKvLBZw6paGlxYaSEuDwYSOkoRsZERgaEsjNlejvF5icfDjh8/h4oLR0eXhjTiejKenpeKz915oG7N5tYts2E3FxKsz8sNi61Zi5njJsYeBSxDAMTE1NKY94uRPYG7xUZCpTUpbH/Nn+fuCddzS4XMCuXaGLcAYHgeZmgbQ0idZWHQMDZkijmJ9vorRUYHhYQ02N+UTMWZ6a4jSkzMyFVcu8XuCtt3RfqPfZZw3k5z/eDUa0CgyXK+npC0uTLlUcDgcAqBzxcsY0TXi93pgORS9n7t0T6OgQiIuTuHxZhDTE6elAbq5ERwcri9PTQxuOjAzg5EkDk5MmMjPlktT5NU1WCyclLRxqHB/nNKSBAQ2VlSYOHgwfip+cZOVyVpbE4KDAyIh47IZ4KWDpmBcVSbVxiCLOmUIC5REvQwJ7g6WUEEIoAxwF2PYk4XKFl0xMSQGOHTPR0+NFTg4W9HITEzkIYiliGGyVamqigTx0yEBiYujj+/sFOjs5DamtTcPYmBk23Jyayp7uhgYNJSUS+fnLK5Q5l6kpYHSU0YJI8/bt7RzcMDkpsGYNRz2q5SE6TE5OIj4+HrYoJr+VIX4EzC3IUkY4PI2NApcucSHbvfvhVCFbrF1Lb8Pj4VCGcGRkAElJ5rJXNBsZEbh3T0NiokRTk4bVq82w1yYri1Xc/f0aystNpKaGv46aBuzda2D9ehaehTPySx2nEzh1Skd3t4biYhNHj4bf1FgMDwuMjfGe7+4WcLtVOH0upgl0dXHdLC5+dJEnh8OB5OTkqK7RyhA/ZGK1NzgadHQAN24IpKYC27cH9xbcbuDcOYHRUaCjQ6CwEFi//uF5mjYbK78VfpKSJDIzJTo7GT5eyPvPygJOnPBidJTDNyIxGLr+eIu0osXQkJiRDTXR2cnZyZFESgoLJQoLJRwOgZUrDWWEg3DtmoZz53QIATz9tIGNGx9NZCXaFdOAMsQPjVjvDX7ceDzA++9r6OsTMAyJjIzgBlbT2IbjdgvY7Q9vfOFywuUCPvxQR18fr+HKlQ+2ICUlAYcOedHXx2Kq3NzIRhOqaUjzycyUKCgw0d2toaTEDFtbEEh+vsTzz3sxPc3NkGI+3d0CgIRp8s8bNz6a97EMsfKIlzhLoTf4cWOpFVm9h6Euh80G7NtnorFRIDkZT4y0YG+vwJUrGuLjgR07jLAV6u3tPDYuTuL8eYHi4gefQpWVBWRlLe/c7eOAtQUGhodNZGcvLq3CzoQn436/H2pqqDInxMJppQdBecTLANM04Xa7lRc8B5sN2LPHxK1bAmlp4ecD5+VhQRnCpUBfn8C1azSuW7eGN67nz2toa9NgmkBqqsT27aGNoq7zv6kpgfR0NfYuGGNjwIULOtxuYOtWE4WFj+9+Sk3FgnlzxeJZudJEbi5/F49SUtPhcES1YhpQhvi+sULRVlV0rBhhtxvo7GS4t6gouudSXMwii6WM2w3U1WkYHBRYuzZ8UdP58xpaWjRIyTzsQsZ1ZtrlgkUoFRUS+/YZGB2lktdyLn4CWAD14Yc6JiaATZtC93MHcueOhps3OY3K6wVeeml59rw+aTwOTWun04mkpKRH/0ZhUIb4PojV3mApgffeE7hxQyApCTh82ERVVbTPamkx93tsbdVQV6dD1yXGx3UUFnoR6jdrPdUKx4dj1y6GlxMSJFavDh8i1jRg3bqlG0ZubRW4elVDejrw1FNGyOtn0dCg4coVDTYbtaOLirwLRgGs8Y6GobS3QzExAVy8qMPlArZsMVVv9wzRHoEIKEO8KGK9N9jrZbl/cjL7GoeHxZKf0fsocDqBvj4WIM2VppSS18v6Xq1ZvpzME76F4umnaVzj4yXWrAlvOHNy5LITzg+Gx8PZyYODAi0t/Nzr1y+88eA1BzQtsslfa9eaME0W/a1Zs7yva1OTwM2bGrKzge3bI6+4vnNHw7VrGjSNkZ4XX1ze1ylSVGh6CREoUwnEZm+w3Q6sXClx9apAQYFc8mHhxWCaQHs7/1xWFjrcS01pgZYWgdxc4MQJM2z4q7JSYvduhoVra82wgg05ORIHD6rFLRBNA2w2CY9H+HLdC7FihQmXC5icFFi92oyofzQxEdixY+lGDSJlaoqzk8fGgLY2jspctSqyz21dR8NY3rO9F4sq1loiBPYGCyFiWvBh+3aJ6mr27C4HreipKS44cXESFRWhDezVqwJnz3Jj9PTTElu3Bt+EjI9zGEFuLnWoh4fDt4/YbAzjPWlMTwMDAywOexAtbV0H9u41UV8PJCdL1NYufC3j44Ft2568ax4J3Nj4ZyfreuSb7TVrTHg8jBqsW6c2jBZOpxOFhYVRPQdliMOwFHuDNQ3IyYn2WTwcpATefVfg1i2B+HiBI0ckVqwIvvD09vpzs729oV8zI4Mj71paBEpKlke1diSMj1OqMitr4RGLHg9w+rSO1lYNOTkSR496H6hoJi9PIi9PLfwPg/h4qpbV12vIyJCorIz8/k1KYm2CYjYqRxzDqN7g6GOaNB5JSZz8Mz4eetGprQV6evx/DoXdDhw5IjE0RE8vysWS943LBTQ3s0q4qsoMO7hhchJ4/XXKMOblSRw/7g07tnF8XKCnR0N2tomeHg1DQ0p0IhimyaiB3R7Z/OiHBeeFq43Nw2JycjKqk5cAZYiDonqDYwNdBzZskLh0SaCsTKK8PJwh9itELTQb2G4HCgrmPx7t73lwUKChgRuPNWvMsCpjFy/quHRJgxDAnj3hw+cTEwIDA5RhHBjQMDYmkJER+lqmpUkUF5toadFQXByZ8tZSp79fYGKCRi7S9rC6Og1XruiIj2fhXbj7UxG7qBxxjBGrvcHRYqE2HCmBu3cF2tpYILV6dWQVroth40bmvO32hUXxFzLAkRCt79swgHff1dDayraduDiEbWsaGmIRlNfL4QHhyMqSqKoy0d6uoaLCXDAcb7cDhw4ZGBoykZYml1StgZScKz05KVBWZkZ0T/T0CLz+uo7xcYGaGhPPPmssWMwkJdDYqMFmkxgZEejtFcoQh8DpZOFdVlZsitGo0HQMoULRs7EmImVkSOzZE1y6r7+fOVyXC2hr44IfzNN8UJaSIbhfTJM9s/HxEm63gMcT/vj1601MTOiw2xfWno6Lo2EdG+PkpEjaXeLj6R0uNVpaBE6ftsHpBCorBZ57zlhw3vLICGcmZ2dL34zghSKVQgAVFSauXtWRlrb8owb9/QKTkxxWEemoRwAYHgZOn7ZhZERgxQoT+/YZMTe/W3nEMYLlBatQNPF4OBFpbMw/EWnDhvkLjZT8z1KJkst7Lbpv+voEGho0pKRIrF0bPORst1Ps4vJlDenp9GDDUVUlUVTkhaZFJmBhtz8Z05CcTsuQSoyPc0OzkCEuKDBRXMyQ/cqVket4P/WUibIyibi45V3019UlcOqUjokJXp8jRyI3pn19Grq62GbV3CywZQuQnv5oz3cxSClVjjjazO0NVkaYaBr7Mvv6BGy20BOR8vOBXbskWluBiorgedelhJTULE5IQNhdv5TAlSsaGhoY6t22zQwZcvN6GXLu7GRhVUICQvZ9VldLVFdHXoSzGM/kSaGszER1tcDoqMCGDZHJgWZlAc8954XTyfBppEuArgMlJcvXAFsMD/N6ZmVJ9PQITE9HXuSYlSWRnc3wfVWV+VBnjT8slMRlFLF6g80Zwd9Y7g1+3Og6JyIVF7NwKNTABiGYw31U48keFkNDwOgoNw7hvJ26OoFLl2xISwMOHjSQnR38uIEBgbo6HUJIXLqko7hYhlyQTRPweNgH7fEIzOz5FHMwDKC+XpsJKXPxvh/S0oCTJw14PIvbqCQlUR9cMR9rdvL4uMCaNYvTOs/PlzhxwsDEBFBQIBeMTkQD5RFHgUCZylgLRU9O0tuKhZxobi6WRd5raAj44Q81DA5yeMLJk8FzpNPTwK1bAoBARwfQ1cX2nWAwSsCFKTkZYaub4+KAnTsNXL3Kvs+FQs6xisvFopv09IWHVJgmcPWqhuZmgcpKic2bF1bHamrS8OabOjweoK3NxIsvLpzbDUWkCl6KyMjJ4ezkqanFRQwCnx+r2gYejwcul0sZ4sdJLBdktbYyhGmawJ498omZy/uoGRkRGBzkqMW+PoGJieCGOC6Om4/btwVSU2XYsXZZWcD+/Qa6ujTk5y8snl9VJVFVFVt9n6OjQH+/hqwsuWDueHQUePNNHaOjAqtWmXj6aTPsYhwYMRgc1FBYKBcs/HK5GMZPTJSYmhIwjIVzu08iU1Os1tZ1oKbGfGwDLpKTqYy23HA4HACgqqYfF4EylbFkgC0aGgSGhpiTvXULqKmJ9hnFJlJyMUpIWNgzAxgaKysTGBigQQzVzqJpwP79JsrLvUhMlCgtDf+6lZUSlZWxZVwjZXISOHXKhq4ugdxciRMnwitndXdraG+n0b53T8OGDWbYqmKbjdKLk5MCycmRhSMrK02sWcNc5ObNZsSDDGIBh4NRgMVIgd7v4IYPP9Rx+bI2M5+as5cV94/T6QQAVTX9qFkqMpXZ2Vy8TJO5zCeN3l6Gh4uLQ4d6vV6OeaQ8pcSBA6ELySxSU4HnnjMxMcFpS+GMQnIyBw4AQEeHhsZGhpM3bgxdjLUUcTg4mSsvT2JwUGB8PLxyVnq6RHq6jHgecnY25yd3dWkoKlq4bxlgOubZZw2YZmQbrFihtVXgvfd0GAanb1n3TzgeZHDD2Bh/Hx4Pv0fFgzE5OYnExEToUf6BL2tDHMuh6Lls3MjFTsrlIwzg8QA3bwo4HJwKlZcX/LimJuCtt1ios3GjxP79wT9/fz9Dx8nJFBJZtUqirGzh81ioCnouTifw3ns6hoYorJ+WtvRSBVLSSwu2vmRlSVRXm2hr01BdvXBovbhY4vhxAxMTAkVF4eU0LWpqJGpqFh8xWEpGGKDM6MgIZS7v3BFYsWLh5zzI4IaNG004nYycRWq8lyKTk0BdHWcnb9z46GYnOxwOJCcnR90uLFtDvNR6g3UdqK4GgKW14IejoUHgzBkBwxDo7ZX4yEeCe5ZWe0RGhkRHh4BhBFfgSU6mh9vXx3yuFU3yepljTEoKrwQWKVJao+IkDEPERH/02Bg1oHNzFxZUmJjgRmJ0VGDLFnPegm23syp8fNxASkr4YjMLq3JWMZucHIbeDUOgoCAywxgfDzzzjIF799gzvpjBDeXl7B8XYnnn0O/c0XDpEmcnO53ASy89mjRQLIh5AMvQEAf2BiuZyuji9dKgxcVJuFyhPbTCQioTTU8DK1aElsFLTweOHjXR389wXnY283NvvikwOCiwZo3Ezp0PJrMpBPOaTz9t4PZtDbm5JioqIl8op6dpyBcK3zocwK1b1IpeuzZ8f+XwMPD66zYMDgpUVlKCMZzxbG3VUF+vISlJoq5OQ2Xl/JyrrjNUr3gw1q2jWplpAmVlkd8nxcUSxcX3Z1wi2TgtdYTwb6of5fJtGeJo24hlZYhN04TX610Soegngepqib4++DyzUAtISQnwkY+YmJ5eeIRjQQH7ES06OwUaGwXS09l+tHbtg83PtQgMrfb3C/T30xsNFyLr6GC+0DSBXbsMVFeHPvbSJRbdSMn5sHv2hF6Uh4aoZVxQwGlI4+Ohe5wBICGBak+TkwJ5eZGFkpc6hsHvKT4+8klIDgdw/ryOiQkOzbiflJCmYVEerSIyVq/meuByCaxf/+hC8MojfogE9gZLKSGEUAZ4AQwD6OqiZ1RU9Gh2ncnJHDkYSbg9LW1xVaf+95BITRUYHaW618NWmxodBU6d0tHfz+Kmkye9IT3Je/c0DAwwf3f7thZWJcvt9u/63e7w55CbK1FczFagqipzwetUXS1x6JABp5N6yNEuNDNNhsuTkiLz5iYmgNu3WRm8Zo0ZkYrT+fMarl/XkZwscfCgEZHiVWOjhhs3NNjt3AyVlHijfq0UJCkJ2L370efAHQ5H1FuXgGVgiOcWZD3pRtg0WSDV1QVUVbFIKhh1dQIXLgjExQH790usWrU0d/WlpcCzz5qYmGAldbC+SsMAxseZX7a8w8lJTt1JSwtdRAZQu9jKzY6NCTidApmZwa9VZqaEpjFfmJMTfhHZtMmEy8U/b9gQ/tiMDODECS8mJjiYYCFjpmmhZTQfN6YJvPuujqYmXsNDh4wFZQ4vXtRx7ZoVLWA1cjg8HqClRUNiIqvA+/pERIbYZuO1cruB+PiHPzks1pieZp1BRkbw30koDAO4dk1DXx8HN4SL9Cw1YkHeEljihjjWe4OjQXc3W3wsj9fKpc6lrU3AbgemplhItWrV4z/Xh0V5ORDK6/Z4gLfeEmhrEygqkjh8mDnoN94QaG4WyMwUOH7cDKmTnZ0tUVBgorubYhbhWnHYX8vK94qK8MYjN1fiuee4eRweZmFbbm7oPueUFCAlZektgCMjQEODhoQEiZYWDT095oIV6C6XP0Ljci38m7bbWcR044aGzMzIJyGtWGHC7WY70cqVcklUbLvdrC1wuXj+kYbhJyeBN97Q0duroazMxKFDkfcut7UJfPABQwUDAwJ5ed4Fp1MtFWJhBCKwRA3xUukNjgZWha+m+acjBWPFCokLFwTS0+Wiikximakp5v2ysvxFYQMDNHLp6RztuH49C2vOntWQlAS4XPR0A/POgdy4oaG/X4PdzpafcN6ozWbpckd+PcfGWIjV18eNwokT3piQOH1YJCcDWVmmTxAkkvTDli00kLq+cLTAYtcuA1VVJhISELFOdVwc32spceeOhjNnWIcwOCh8m7mFGBwUaGujElxrq4aRETPkPR8KIZbHOhGIMsT3yVLqDY4GxcWciNTZSXWuUMVPGzcy72izxXb1rNsNXL/O0XarV0vk5gY/bmQEOHVKw/AwvZv9++VMDzDFUrq6KHOZlsYZyg4HZ9du3y5DLkhS0puz2SQmJlgw9bALc8bHWfGdn29icFDDxIRYkp4vEFxhKiGBs5D7+iQyMmRE4h75+RIvvri4imKbjZXIyx2Ph9c4Lo4bTykjq+/IyGChYW+vhtJSE2lpi2uZevppwxeaXi7eMKAM8X1hmibcbrfygsOgacCWLRJbtoQ/TgiENGqxRH29wLvvCpimwOCgxEsvBR8g0NvLYQ25uUBzs8DWrRLp6ZZiE1uesrMlMjMppFBbC+Tnm9i1Swadjzo5SXWtuDiJ4WENaWnUn75wQYNhsOXoYcxVzc2VqKxkNXRVlXnfU4cWwuOh0U9LWzjHDDAc2dPDcHkkOcG2NlaMe73zFaYyMoCMjKXlecYqtbUmBgcFJieB7dvDa34Hkp4OHD/uxfAwW/8WkxbV9aUXOYiUyclJZEUa33+ELAlDbIWiraroWDLCDgdDnzYbPbHHJcL+pOD10gOw25k7DBVqz8yUyM4WGBpi61FgQVBWFmZJOO7caULXOeJx06b5LyglBTHu3tUQFwds3GhgxQqJpiaB8+d1SMkirsOHH1xkICGB0o6WuMbwMFWawrUnASw+u3mTggfr1oUfZu92c2hDRwclJw8fNsJWlw8PA++8o2N4WMxsQIwFPdmmJs137pEqTD2pSMnCqYSExXcrpKcDx47d332Xnk65UoUf5RFHSKz3Bp87J3DtGqXqXC5g2zZ1oz9MamslBgeBiQmJLVtCi30UFFBTenwcKCxkqNLtpgGfe7sUF4cPY7rdrL5NSfGPOszLk6ivZyWvVWn7sLDbGT7/8EMNly/riI+X2L/fCBsGr6vTcfUqBUG83vB9yIODAi0tGjIzTbS0aBgYMFFaGvq1vV4Bl4tGeHpaRPRZLYUpr5dh9qXG+Dg9v8W0lLa2CoyMCBQWhk5vzMXj4Savo0OgokJi9+77H/eoeHBiYRYxEMOGeKn0Bk9MAHY7B747nU+mEbbacMJVYRoGc7JeL+cCR9rvm5Ji9SIHR0q2a7W3s494zRoJKYGzZyn0UVIisXdvZOFYi7g4hp6vXmU+zSpmW7vWgMPBz7LYqTehNgWBn6OpiUVho6ML56O9Xn9BnscT/r3T0jjqsLtbQ36+XDA/mJMjsWULJRhXrzYikra8X4Wph83YGCMFQrDQKxJnp75ewwcfsJ94714jovPv7RV4800dY2MC+fkSL7wQWSVxb6/A7dtMddy+rWHlysUXTSkeHk6nUwl6hCJQphKI7d7gLVskXC6GpFevXj4/KNPkYIXxcRrOUO097e2coywl8MwzJioqgh93547A228LeDzA5s3AgQMP51r19gLvv08D39kJ32zd69fZI33zpkBNjZxpcYqczZtN37xXa4ORlQUcPx7a85ycpGLW9DT7hPPyJAyDk3ZaWgRKS+kBBdsUCAFUVZm4fFlHWlp4BS+AOTuPh8Z4w4bwocqUFODoUS8GBzllKTExfJGPpgHbtpnYujXyHGSsKExduuSPFJhm+EiBxa1bwtdj29Skoaxs4edMTcHXU+50MoIQboa1RVISN0KDgxSISUyM/jVbCEuQJTl58frWAwPs615IlS5aKEGPEAT2BgshoMV4c19FBVBaygUrxk91UbS0UMPZ5RJobpb46EeDz4i9dYtVv0JwMlIoXebRUaoXJSRI9PcLWC0+UnKqkqY9vOKxhAQq8/T3c6G8X7WtxUas7tzRUFfHvO3UFPDiiwYGBjh31m5nn2tNjRlSbGLbNoaMrQjD2BhCFoTl5EicPBl5rjAjg57xuXMamps1FBdLPPNMeM3qGN37hsWKFJgmIxeRUFAg0dlJj9jayC1EcbHE2rUmuroEVq82wo6RDCQ7Gzh82JiplA9eKBhLeL3AmTM6WlsZgj94MHx9QSBjY35VOt6v4edeP26klEriMhhLbWKSxXKUxfN46L0mJXEYg9cbPPSclWWlERD2R1ZdLdHeLuF2s3XK4sYNgXPnaMj37l28wldBAbB7t0RHB4U98vJoQI4cMdHTw0rp/PzgHqDDwTC0VWAnJXfwpil8rxOKoSGB1laBlBRWslqbsLnPSUiQvvmz6ekSM3PIg6LrbDN59VUdnZ0aCgokjh/3PhTtbIC54ps3mYO+dYubguXSQ26xZYsJw6AxXr8+Mku8fTujF7qOiPWm4+KAAwcMeDxYdIFmUZFEUdHSuO5DQwL37jGU3tioYe3ayDW5nU6BsTEaYUuVLtINy+NC5YiDYBhGzFVFP6lUVEhs3Aj09Qls2iRDFrFs2cJdvZQI2+ZSWAh89KMmvN7ZBTEtLTTyXq9AW9viFb6YC5TYsGH240VF8C12N24IXL9O0Y7du+khX7okcPUqDenhwyays+ndv/eeDVKa2LNHYvXq4Hlgjwd45x0NbW0aEhI4LrGmRs4I1Qu4XH4hCssTLSpi+mJgQGDFitnXyTAY1k5OBsbGBPr6KLzQ0qKjoUHDli2Rh4jDkZAgkZwsfZGChSZELQXGxqi+lZPDvvGcHBk2fRAMux33NW9aiMUb4aVGcrJEVpZEdzevcSThd4ucHM5MbmsTWLkyvCpdtFASl0HQNA0yFoa/KmaEGORMoVzo4+x2ROzFxsfP96rLyym2ER8vUVr6ACccgokJ4OJFGkdqEDOXefMm88rt7UB7Oz3n1lYBt9uEaQq0tACrVwd/Ta+Xk42SkyWmpgTcbobak5MRNCdZXi4xPk5DMfc3T6Ouo72dhWVPP22gvJy54oEBetKaxpz1g5KWRnGN3l5+3sV4JyMjNHi5uaEr1y2kZEXx2JhAcXFkkpODgwLnzrHWYOfOyBbt7m6Bt97SMTkpsH69saAmtWLxcKPqxcAAldEWE1q224H9+zl8JCkpNlN3yiMOwpPuBbtcNErJyUB+fvBjOJmGodx16xbXmH8/POqvZMMGqi0JgZAFYYOD9HwKCvzedHs7xysWF4fvubXbuakYHhZITJSw29lmk50tce8eW5Os32FZmURbm4Bphg/ZJiYyn3v1qoaKChPl5eENwM6dBnJz+b6BQhcAPeSGBg6Ib2jQsGaNiSNHDLjdQHMzBUWamwU2bw77FhFTWMjrfeGChvfe01FeLrFzZ/gWmu5ugdOndTidAuvWmQsWQPF4GyYmgJISieef9y7ofV+/rqGpiYY4IQE4enRhr7a3V/i8++ZmDdu3h5cgfdKZnmb0ZbEp0exsIDv7/jY5moaYlWx1u93weDzKECv8mCbwzjsCd+6ImSpXE2Vl84/78EOBK1doHT0e5keXMprGMHIoBgaAH/6Q0pVVVRInTrCv+NQpDaOjQEmJwIsvmiEX+oQE4MABhsfS01lcp2ms2q6uZrjWqvTesAHIzDRgGAYKC7nI67rf0EvJiU0uF/PCK1cyN9zfzwESubnB+0lTUoCNG4MvZCkpEpmZEr29fH5Kipxpn5IYGmKufqEBEotlYEDg+nXmiq9f11BZaYbtq+7rE76K65YWgR07wodknU4Wq2VkSExM0AAsZIjj4vxiLZEOI8jOpmzm5CQ3CNHox3W7uclLTQ2dvpmLabKVb3paoKwscslIrxe4ckVDfz9DvYsJp3d3C5w5o8PjYcRh7obwSWRychIAVNW0wo/bzR9LaiqVjYaHRVCvbHoa0HUB0+TAguXE9DQX4UAvfGREYHCQRVh9fQLj4xLt7QI9PTTgY2Nc9IMt9ENDQFcXB1vs3Dn7WiUnz283E4Ieo2FIXL2qo65Oh90usW+fgaoqKmu9/bYNU1M0rPv2GRgd5VSbgYH7qwxNS6P3Z1WWWrrfK1aYSE9n+1Mw426aQEcHIyMlJf7JQaOjQGenhtRUDvMIFtGIi5O+kYFZWXJBw8fzosFbu3Zhr7O0VGLlSsqKrl5thpwoFcjmzQbi4/k5Q+Xm51JezglW09P83h53QM3rBd56S0dzs4acHImjR70RfdamJkYMuKETOH7ciChs294ucOGCDiEkhoZ05OdHPgWpqUlDby+7Fm7cUMpnAFuXAKgc8Vye5NB0fDxVpG7cECgsREgRha1bJdxuc6Z/NPYNcUsL+5FzcyknGcxrMU3ggw8owFFUJLFvn984FBRIlJfTGFdX0xheuMC/x8UBe/YEHx04PQ2cPq2howNITxc4ccJEcXHk593YqEEIKmt1dWmoqjIwMiIwMcHiq64uboasecU5OTz2fipDs7NlUI3pcH2XV69qOH+eydpduwxs3sy+4rff1tHaqs1obHuDbuaysoCDBw1ff+dCLTulpRLPP0+DV1CwsMGzQssOB9DVpaGxkeIk4TzW5GRWLy+WaBYAjY1Rjzwz00R3t4aBAc76XYjJSYGpKSA1VWJkRPiqvCPB6o8GFrfxsGYQezwiJoum5tLRwd9ScXFkoiz3g9W6FAstsjFliJ9khACeflpi5UpWs4a6+QoKgJdfjv0fEsBK4Hff1TA6KnDvHg1msHDa0BArm+PimP+uqZGoquK/paVRutLh4JSo73yHlcqlpQIbN5p4+mmGcDs76flWVvJ5bW3A1assEhGCBrO/X+L6dYHERFZ7hwuXVlSYqKvTkZwMFBTQQBQVMb/qcgGrVpkzvc/+ytDVq81HKlpgGP5WuZ4e4Sts7Ovjijw9zbx5ejq93e5uMctbDqS0VM6SuRwfZ8g6K0sGncYVaX+thRDAtWs6Ll/mmz/zjPFQCs5iidRUoLDQRHMzFcsiHdhRVmaiokLA4eA9HGleu7xcYtcu9qbX1i7OQK1ZYyIpScIwxII1DdGmrU3gjTdscDiA6mqBEyeMR9Ii6nA4kJycHBMOoDLEMcTDFLWIFdi/K0MOawAYVk5NBXp6aGznRooSE/2h56oqibo6v9F1uej5dnYCqan0fPPygMuXNTgcnMi0f7+JoiKJU6eouWyabGHaujX0SW3davrGRKanMzeakgK8+KIXbre/Z9qqDJ2aYlSjpUVgaop5Xav/t7NToKODXnNNDT2ZyUng2jUNLpfAhg3hpy55PKye7ujgArxtm4naWksYBaiu5sKakkKpyfPnNQwNAXV1NII7d4ZfeCcnKbzQ2UmDcuKE96EITQwOsrXL42EF9XIjLo5V6Bs2cKxgJGFpgPfOCy+wB3kxLWQPMgVJ1632wtjfxE9MMPKUkSExNETVs0ehuREr8pbAE2qITRO4ckWgqwuorV1e0pSxRHIyZS/v3KFARijVrZQU4NAhE7299MgKCuj9WVOXAtm+XaKkhAYyP585UYeDClQTE8DUlIDXSxGS1aslxseBXbto3E1T+MJ5oTYG1u5Y16meZBg0Ug0NFDU4etSYJ8agafys9fUaTp/W4XYz93fiBMOz77zDHHJyMpCU5EVxMXWGL1zgNt/pRFiVrO5ugevXNSQmMnddWSmxYoWJvDx/rzLPneFd1g/Qm793T8OmTaZPDSnYeMOxMYFr1zhVamRE4OmnxUOZ0rNunQmHQ4fNJmO2OGhqirKNi6m29nopdJGcLJGScn/a2jbb4uUinxSKi02UlXHztmaN+UiMMECPOCkpSXnEc3lcF6SzkzlJgPKK+fmL649TRE51dXihj/FxakVPTAjs2GGivJye1JkzGqamgF27TFRX+4/XNMzK9aanA+vXc/TeypU00klJwM6dElevUjyjqkrOhP5NJCZy/GGozZeUs733qSmGga183siICKmK5HTSQ09OZr7YMOjNulysjg6cZGTJLzLnF/4aJiQAiYkcBpGXJxEXx/cP5YEVFLC4amKCg9ytCudQ4w2npmiAh4c5OSkh4eFsTGtqJIqLvejuZgW6VQy3EN3dAvX1bOlav37h0K1pMmfe2MiZzlu2BJ9ZPZdbtzRcuqQhOZnTrhYaPWm917vv6rh3j321hw55I3qeInIyM+GrSXiUnUWxMgIRiDFD/DjRtMi1aJcaUnKzYZpASUloCc6+PrbesO0m+DGmCdy7JzA6yhxVYeHDPdd79wRu32Z++Px5DeXlJhoa2A6UkCBRV6f5Qq/BEAJ46imJjRtZjGItwKtXUy5TCIa833+fHunBgwxL9/ayXcxu5/PT0yla8e677Jd96ikadbudobKbN9nmY3mhwaioMFFVxdzf5s00IFlZDCfevath9Wq/zvSaNSacThrmhcKN+fkSBw4YGB6m3m9KSvihDeXlVJdyOunVW9ck1HhDXWc7ltvN8Gqk7UOR4HAIvPuujpERbiJeeCG8ZKfbzTGBPT3C14O6kDc9MCBw8aIOTZO4eFGPSELSMJgamJoCBgY0tLbKiHplHQ7MpClYsNffr913j+1SwjQfryBHoPTso8LKEccCT6QhLilhtW13Nz225eYN37ol8O679Mieekpix475i9LoKPD66xr6+oC8PPbiBvOw2to4/GFqSqCpSeIjH5ndszs5ycUpJ+f+NLct4+lyCSQmUsoxKQmw2RhejqQKFUBQIXrL23z/fQ2dnQKGwV7PjRslPvxQoLGR+eLkZPZj370rcPeuBl0HLl6UKCkx0N1NT279enpZjNoEPydrJ28Y/kVECKpibdo0W6YyLY2Vy1LSMzt7VkNZmcSmTSZ0nd/PBx9wktOOHSaqqujZ19dr+Na3dGRkcGhDKI8hmCEKNd7QUvTq7mZUIdJcJ8ANgTWjORhTU6wSzsqSM9XCIuwYRtNk6NduZ245ks0yQ8uMAKSkhK/OttA0ICtLoq9PC1scOZekJHr1DQ1ayGr3R0lrq0BHh4a8PIb7Iw0idnUxvZGaCmzdakScm5aS0YY7dzQUFfE+WS6ynipHHILHFZrWNC7GGzc+lrd77PT10bDFxXEYwo4d84+ZnORiH5hnDbYAezz0nJKTaRgDC0wsYY2xMcpc7tsXvEI3HKtXc2DE9LTEihX0YNesoSfqdjO8GWwMm9fLsHZqqj+/5/Uy/JqaOrsIJjD0a4Wdrc+fnOzfQFibAq/Xb9gTEngeY2MslLJ6XUMxPCwwMMAoQ6C0Y6hbe3hY4MIFDR4P0NPDBba0VOLuXQ1373Ii0MWLQEmJAZcLuHhRw+Qk0NenobSUodtICTXe0GYL3zo0Ps5iMYeDx1k50dFR4P33KTG5fTt7redSWCixZo2Jzk72IC8kd5mQwHasGzcY+q2sXPjzZWez17u7W0NBQWTymEKwkru0VCI+XgY992DYbNxArVnD+cuPMyw9OgpfdIEFjpENjzAM4IMPNPT0aDAMtt9ZWuiRvOflyxpMk+pnpaVm2FTTUkKFpsMghFB60w9IRYVEWxsLjUI17ufl0Xi2twusWiVDSmqWl3OgQm+vwPr1clZYsa9PoLub3nBTk8C2bXLROR27nf3Fcx9bs4aPeTzA6dMCbW0Myx4+TK3jN9/0P3bkCMPS77wj0NAgkJ0NPPusifR0Gp89e0xcu8aq55UrJVpaGM4cH2e+ef16vte6dRKGYWB62sSqVdx49PdTS9rj4YIfF+ffAFjGzDDYU2oYwOuvszArL09i3z4vUlJC53IBQNO4efF4xKzQelwcX9/j8W8KbDbMDG3QEBeH+87lLna/29Cg4dYtvueFC9wUaBp7re/d0xAfz5BwRYV33kbMbueUIrc78pA3vf/F5Y2qqiQmJiTq6nR0d7PNZyHPLTkZWLt28WHlhITQhYePEsMQMxth6ZuOFglCzK5FWMz3z/uMv/Xk5Iebtog2sTKLGIhBQ6x4cKqrqQ1rGAi5Y7fbgcOHJZxOGVaQPT4+9PCHrCyJ7GyBkREauEchUDM4CDQ0UHGssVFg3TqKfTQ1UbKyuVmgr48bhKYmLhbt7dw4WJW/xcWYJeHY10fjunatnCmE8n/WzZtNGIaBzk4dP/qRjvp6XpjKShMDAwKvvKJjbIwtR9u28RqfOUN1JV33F1Q1NWkYHLQhLY0FZ6tWBV/wMzPpmbW3c+xhVhb7lNes4fEeD7ByJf+s68C+fQbKyuRMf7P0CepbmCY3ComJsxdNj4dRhcAIQjhcLmB8nNfQ2iBYxtS6DxISuDlwuQSSknh9bLb5XqIQwRdww+D3ZLc/uDDHyAhw6dJszy1SL3epkJUlsX27ifp6DSUlRlhZ0kCszeitW9zI1dZGvvlITuZGqrOTmt6RvudSwOl0KkOseLREkudbjCB7sF10YaFfbKOwMHiO2OMBOjq4+JeU8HWmp9lbm5goF1S7Sk2lseruZo91WhoX9exsFqTl57NyOiWFRU3NzQI5OUBmZugFIz+fVcXT0/SCAzchVnrkzh0NQ0MCuk4DZrMxpNfWxmre27c5m3Vykrnm5GS/XjS1lSWkFJielqivF2HHO9bUSNTUGGhpEfi3f7NB12mcgxVxZWUBWVkmWlsFvv99/nyffpphYSmBc+cY0s7IkDh0yEBGBo3qm2/q6OrSUFxs4tAhI6xn43RStrOnR0NZmYlnnjGwbx+/t8C8pLVBmJ7mc77/fRvsdom9ew1f+HJ8nN/93Jykw8E+59u3qXm9b59xX6MILeLieF8MDLAqfrnkMQPhyE8z4rByIAUFEgUF91edupTmJy+GyclJ5IcKBT5mYs4QL8XQdG8vq3/T0riwBysWaWujx5aTM3/xX8rk5oYXITl/nkMqmFujctiZM6yUTkoSOHLE9KloBYNSjdQt5ug+Pn7smP+x5GQa5Q0bJNavZwV0ejrlNePiqEltheY6O7lheP55zkbOz+f3NzlJz9n67rKyaNgyMyX27DGwaZOJsTGBoSEN4+MCNTVWWxCrbTs6NOTmShw7ZiAhQaKlRcPZszoMQ6CoKLKF8+ZNDrLwetm+U1wceuGsr9cwMsJCsrt3KcHpcLBvWNeB9nYN3d0SGRkmBgcpZJKVRRWoDRv81dvBGBgQaGvTkJdnorVVw+bNZlBVLLudvcIA8N3v2mZJglZXM89bV8diqAMHDJ/qWHOzwNmzOi5c0FBcLJGUJNDbq6Gm5v7bGFJS+B4dHQzxL8bDDlaDEAkzMwMW3efqcPB+XOzzvF5/VEP1ID84lsRlLKC+zgfEGhLf1cVJPYmJDNMGMjnJvtihIYbuUlJkWOOznOjqYujR6RQYGODn7ulhvnZ0VGB0NHQVsgXHsM0+JiODFdVSAm+9JXDjBl/z4EETOTnAmTMCV68K31zlmhr2FZ89K3xyolu2SLS3s+DM4WDO/OBBvv6mTaZPXaqykq1ImZkSx4554XQKlJSwujkxETh82EBfn/R54UNDLOzKzGShWU4OlbnS0mZ/jt5eTnIqKpIzrU6sxh0fX3gzmpMjce8ei8+sAqjERL5+czPFR6zQPIuKJHp6NBQWyrBVy7y2lPLs69NQUmJGJO5RXm6iv58iIoWFFBW5eZNFaMPDAq2twmeIGxo0jI0JXxRh0yYz4s1KOIqKOMby6lUN7e0Chw6Friq38HpZANXSwnqDgweNoBX4c2lqEvjgAx1CcAZ1pDnjhgbhmzG9d68RsRiI200d8Y4ORjUOHgwf1VAsjCrWWkYYBn8kcXESHg9/2MGO8Xr9x1ii7bHO2BgXnPh4bi5C7cI7OuCrFC4tnf1vq1ezVSg7WyIpSeLWLbay9PZylnCwnJPHw/c1DIqBhFsYvV4a++RkvyhFRYVERweN8MSEwOCgRE0Nw9sAjVdvL/88MsIe6cxMbhDcbuFTWprbvyoEZvSZZ58zPXAT3d0Cp07pGB+nkMbRo4avgKu5WUNmpsSzzxozOWROcpqe5iQnKxRtebqtrRo6O2VIz3XjRhpIKf2FQ1ZF76pV3OxZ4UROePJiaEggPp6ygcDswruREVaG5+czonDsmBfDw9w4Dg7y8XAL/9atlBGl4hnfNz9fYmBAQ3Ly7FRJbq5EQwMjEKtWGdi6NTIxjYWYmGBKQdeBlhYNXV0yZG7eYnhY4N49DSkp3AStXm2isnLh3+bduxrGx/lbrq/XUFERmTd/+zY3fV4vUxplZZE9b3CQx2dmmmhq0rBunTlLK/xRwolvi1Mfs3C5+LxYjACq9qVlREICvasrV6glHKy0Py2Nx9y6xaEN5eWxb4SlBN57T+DuXeZJpWRIfS7Dw9R6Hhzk53/xRXNWX/aGDWzHmZ4G3nxTQ28v85z795soKaEX19AgZmYLUzDk2jWB731Pg9PJ4154gQanuZkFRCUl0hcOp8Gkt5ufT+OjafRuL13iOVnGvrbWb4Bravj/wkKJwkJq265bx4hGpNWo868FlbfofXLCjsfD4rDsbGpDW8IWw8Os2k5P56bBqmjVdaCmxsTQEDcVoQyxzRZ8gEYoAYysLCA+XuLVV6kpXVQkcfw4x+gNDQm8+qqOoSGB6moTzz7L3LLbDZw6ZcPICD38I0dCi+9T8Wz2+Tz9tIGSEiqBBXp+Gzb4vezy8vkbPKtaPT1dztK8Nk1eS10PHnpOSGBUobVVm1EOW/h3lpzMArmuLn5H4cRGAsnNZeRBCCzYkhVIXp5Ee7sGTQtfxzCXlBQ5s4FlUd9CUY2Hxd27Gi5e1JCUJLFvn7mo4R/Xrmm4fp0b0H37Fo5OPG6URxyGWND9XCwstgl/g65aJcMW7MQaUtKbTEigfvPUVPDPR8EGhkQnJ/n3QISgEejrY24sK4ueS1wcq33b29me5HBQOvLll03cuwfcvUuvwWbT8OyzBvr6gDfe0DAxIVBaKvHSS3795B07uAGKj4dvId26VaKiQvragC5c4AJ+8qTpq5S+coVe95EjFOtITwfu3BGYmKCes7Wh6O4WvpGBlmGcmsJMpTSHLtjtllFnnnTVKhNJSbyOZWUS58/rM4MBaCQLC+VMYZfAihVsB0pIYATg0iUu1HZ7ZIve9DQNVEpK+L7WsTGBvj4NhYUm+vo4FSs1VWJ4mBGN/HwTPT0aJiYMZGXRQFutWF1dApOTiNhQAfw8wTYFNlto2VO2q+loaeGM32ef9c93vnpVw4cfckb0M8/MH25vDWHo6qKhiqTCNzkZOHzYi74+baYLILJrvnmziZQUVsmHU36by7Zt7KUWYnEtUFZUY3CQ1+VhDOVYCGryc0NsqY9FaoidTmuoCdvcKivlfbWKPSqklMoQK2IfTeOAhQ8/ZGtKqI1Gfj77cFta2GccqggxN5fHNTYKrFkjUVTEx91uTldJS6PmscvFkGViIg1RTg7D+dPTAk4n85cOB42PZYiDTa0Sgv3NAHuOr1zhBm/3bmDXLonz5wXef5+PbdnCQrL6eoE339ThdAIdHZzBOz5OwzAwQI/p+ecNZGfTsF69SkO8dy9zyvx3r28msdW/mZEhYbNJeL2YGZnHYqkXXvDC4xE+oY6MDInNmw00NXEww/e/b0dfnxdbtvgnOY2PA62tHABRXc1IwTvv6Lhyha7qc895Q4p8ZGVJlJezsKyszD/xydpgDA5STtR6r7w8iYICGpvFjt27X8bHKWySk8PNwtCQf75za6uAEBJOp0BXV/Dh9mlpQFra4hZ8qxJ9sbS2ajMpBA3PPhvZxCq7PXgkIxJYK/H4jFmg+lh8/OKKy+LiWJswNKTNTE+LvSigw+FAaoy46coQK0JSUyNRWUmDEizHIyVQX8+w8tq1LH4SArh6VaC/H7PmCmsaZSS3bZOzelGpDsX87Jo1lFfcvl1ifJx9qVu2UFu5tFRizRoWOK1duziPYGoK0HUxM5WIC4LTyeiLpgFOJx+bnua/JyZKOBz0ll0ugclJhrgdDuHz+EdHmfN3uzmwwiI5meHOQFiYxJGAg4P+Y9PTgclJiddft814tMDTT3vhdvOYS5c0TEzY4HQaOHHCgGmyZ7mxUZvJ13p9LVudnTRgQugoKjKDesYJCcCRIwZGR00MDgKXL/PYqiqOPnQ4aPSsUHF2tsRzz3l9RXU3b9JQWwuytbHwelnQZrUoSckpT9PTAqWlkU3Pcbv9hX2lpazuLiqarU5WWcnNQlKSREmJCSnpyev64hSuLAGWSHuqgzE2RqnJrCxGEQYGHs7Eqlhjzx5/emExilo2G8eDtrdLJCfLiPLujxuVIw7DUgxNL2fC6UcPDgJnz4qZRZRVqxTtFzBNge5uidxc05cbEmK+JnR8PIVFDEP63ispCXjuOQmvl9XE9+7Ro83OZug6PR1oagJu3hTIymJoOj6exVg3b9KgbdnCIi8W1NAYV1WZvjz3unUSo6Osat68mY9VVbG4Z3BQYvt2vnd2NmUkm5sp0WgVIm3caGJqimHShYYSrFxpoq+PGwFLqMPC5YIvIuB0svWmutpEW5uO1FSJnBwTExPCp8FsVRs7HNwgpKRI5OdLfPCBhqIic2bWsQgZYrU2QefP63A4qESWnm7MtIHNf05qKtuNzpzRYRgMgR85wgKj27c13+MbNggcPMjHm5oETp9mIdqqVQLPPmuEVXOSklKZN2+yH3vvXgMbN3LGb+A6uWmTicJC3ie5uRKXL2uoq9N9vcspKSxqysubbcA9Hm4MrNGW776ro7WVkYlDh4z7EqJJS5MoKjJnXufxa04/Lu5XfQxgAWRmZuyEowNRoWlFSKgKJNDWBlRWMpQbbAHr7OQEmOxs5p6DeaumyQV0aoq5qFARmHBTfCJBiNmvYZrWEAAauYVG/FnMNfhC0FuZmgLOnWMxVVeXQFERi47OnqXGdXMzw9K1tRLvvaehu5vDHVJSWCh2+bLAvXvU3S4s9Ier8/KAl182fe8F0OgcP25ietqDyUkd/+//6XC5qKO8fTsX2gsXOBlo3ToTH/uYF0IA7e2c/pOdLbFtmznTrsWcpsslsH69iY98xAsp2bL1/vs6srJo9DMzmW+8e1dDTY2JigqJ6moD5eUGrlzR4fEIbN3KHHJcHI+9coVGpKKCue2TJ2no+vsFqqsZTg6H18uUQFISPfpglf6BOJ18Tny8xNiY//HxceF7fGTE//jEBPPJ6emMAHg84QU2PB7m4a1RkxMTIqj6kxCY9dlYLMWc/J07GoaHBYaGBAoKJE6e9E95unhRw6VLbBlat85AY6OG1FT2evf1RVYlPZe4OFaoX7rEOoTF9PU6ndbn9VeYR4JhMAKQmLj4HLHXy/dNSYnNCubHzfT0NAzDUKFpxXx6ezknWUqO7svPn59zdTqBt9/W0N/PMYGJiRKVlfNfq7FR4NQp5l9XrgROnpxtsKenORqwv19g0ybp03ZeDLm5wDPPSDQ3A6WlFM4wDM4C7ukBVq1i+NXj4eOB3rBloBdaFHSdXtzgIFtpbDYuyLrOYi5Lq3kuVhuux+OPsng8sz9jsA2IEFxU793T0NREHeVLlzRUVhpobBS4fJmPnT/Pfk5d55Sk8XEahpwcidpaiTt3NFy4wN2Fw8GpTFNTDC339rIljN+dxJYtnM4U+Dmqq4HKSoajAxf5tWtN1NRQXOSDD3SYJvDUUyZeeomv39srcPo0NwVbtvhn+d67xwlUlmj/1q0Gmps1JCTQ2/d651c9W9TWSvT2mpieFrPUvmprTfT0MMe9caP/8bIyibIyEw4HowgLqVzFxbFS/MYN3Vf5HgkVFSYGBti7nJbGaumcHOa0nU7/lKe+Pt47bjenP2Vnm+jspADLg1Qfd3ZquHlTh8vF+9PaEIXDMNgP3NjIyu6jRyOTqpSS99mtW2y1OnTIiGi2M8Df+ltvcQNZVcXowf1MSltOOJ1OAFAecSie5NC0lYt1uQTs9uDeML0ZLuJuN4Xgg/UkWxXMKSnslTWM2QarpUXg+nVWRV+4IFBeLhet9APMrwa32TBr7GJvL8VMpqdZJLViBcdPvv8+T2bPHhNFRUB/P1W4NI2G3PJc4+LYwtTYSEGM8nI5M7+YBUZVVQwpj4xQ5Sk1lZ7GypUSQ0OWjKeJggIOl/B6uRjO7Yk1TZ6Dy8VIQ0ICjb3bzfCv9dlsNlaRp6QwRKpp1mxr4SvOsl4PmD332utlKJrf3WxPNNhmwnrtucTHc3SipYMdFwccPUqv+dw5HaOjAk1NDA2uWEEFsnff1TE1xe89I8PAjh0mioslfvhDG1pagKYmiRdf9AaNnOTkSLzwAkc2Bm4K8vMlXnrJO2+TlZ3N49va2A997pyGLVtM3zUfHWVYOy6OG4vERI56tPq/e3oi8/q2bGGo2mbDjGQpi7hWrpzdZrNmjcTYGD3uNWsY8u7vlzNV0uHfIxxOJ41ccjK9csNY2DOemmLkIiODLWyjoyIiQ+xy8btLTJTo62MVf6SGuKfH6kGWuHePPciLabl63IyPM3KUk/No9OsBFmoJIZAY6TzIR0zMGeInmYICYO9eiY4OifJyhk/nkpbGGcM3b/KHGEqZp7xcoqqKId3Nm+W8opS4OAm7XfgqfB+VZF5jo0BHBxeQK1cEVqyQuH6dCyYA3LjBtqXLl7lYSAkkJJg4fNj/uQoK/CHJu3cFzpwRMAz22G7YYOLePb9i1r599EibmoD/9b90tLayvWTrVlYY//u/cxj8zp3cFFg57StXWHSWmwts3sx5v5rGys8NGww0N/P19+41MDoqUFHhL0J65hnO+M3KoiJVfz9Dqw4HvUXKY9JYPfWUiZs3GVouLpYzYjCLv65xcf7rY3131kbAmhEsBI8JFJTxev09y243F/iUFA6aCNc/HcqDstuDFzzpOnDlCr1/KXnfWrnGCxfo2Vnnun07owHDw1SdskRaFvIw5/YuHz5s+IZgBG5gVq40UVjI6IX1nVltZFJS6WtoiAWBgX3bVusNwLz93PqG8nITVVVsvdu0yYzoN5ScDF/EhH3zkeVu4uPZZ3/7NucgL6afNzWVlfuDg2JGUjR2jfDYGPDaayxeLCszZyRjH/77WPnhWHH8lCGOIaxZvGvWhD9u3ToZVFwjkKws4MUXzVmzdQOprKT04/g4+21DqSZNTnIRD/ROXC4utJEsPGlpbEOanoZv8UhOBgyDf7YiQ3FxgGlK359DYXm0rFim59nQQKPi9Qo0N0vU1rKamyMMGa4dHaURamvjpuDSJYHaWo6BvHGDHkZ7OxWgGho0CKFB01gU9e67OgYGNN/0oz17ZqshMRRrYHQUeP11G4aGqEV94ABDgBcuaLh1S0d6OiUUV682MTrKwQoTEwz3WkVczc0Cly5pSE+nIEZKCo3FzZuUbSwvZz+mtfBL6TdwCQncFNy+zd7PsTGBkREWc+3YYaC1VaC83ERCAkdkWhuZri6GrIeGGImJNG3mN+Tzw/xWasAytoFY94+lSmcxPc3v16paN83wxYJzCTfEJFT/c1eXwNtvs2VtblTg8mWmF4SggXj66dlGMyuLKQfmySM7R8qrGli9mkVikTpkQgDbtvG+Y4QncmPKfmwDw8PsFY+RQuGgDA8L9PbyPHt7NYyPm/c97jMcDocDycnJyhCHIlYuzHLACqUGQ9OwYF64o4P5aLebHuS6dXJGK5eDyfftM4N67YFYowY9HvjG0m3b5lcwWrmSfcG5uZx7nJbGIrXpacouZmb6NxKGwUVlwwYamc2bGe7Mz6cwiN3u70/OzQWKiky4XDReq1Yxd2i3s1/Z6vONi5OIj6esZXo6fAIdbW3aTA6aBTJ2u4TLJWbkIYPT3888bF4e85VjY9zN37mjzRR1UXYxM5PVtk1NrBK+ckVDba05IzyiY3iY06ny8yU2bmRo+dw5HYYh0d3N3GZ+vsRTT833psrKJFwuE2+8YUNbG1/n+ecpn7l+PXuOv/tdG0pKJA4cMLBvH8VSvvxlOzo6NKxfb+Lnfs6DlBQaxgsXdAwOMgds9b8aBvDeexrefltHWhrbVLZunX0udjuwe7cxM8eYuteGweu7fTtbj+LjZ1eRV1VxU0AP8/HkMd1u/hcsKjAx4U83jI8H/951fXGbBYC/vfsJidfV6bhxQ4OmaUhIMBY1hYn1JrHrCVvk5LA1ra9PQ3m5iYyMR3POTqcTSY8q7n0fxJwhflwYBqUUh4asftlon1Hs0dIiZsbKUSN67VqGkMfHmedqbBQLTrnRdUpQBpKYCGzc6Feoeu01De3tNKg7djBM+dprAp2dDD8/+yxD52+9JdDezlD288+zCOjSJcpwpqdLPP20RHU132PzZv9s3/JyzAwjYIje7WYleXMzc8K7d8uZfmUJwIAQEvn5BtraKLIhBPDuu6y0raz0L37T0/y/tVHIymLbjBWaTk3lopuTI2cqdeErDkpK4vOcTk5nshbzhAQJl0vz6V1bLGaw+/Q0Q+JWm5PXy+9hYECgoYFjHBsaOMaxpESivl5Hfb2O7GwTN25oM3lWVhVfuUJDev68jpISLxISKKxx6pTNF45PS6OXPjfyUlIikZho4o03dNy7J7B6NTW1CwslXnxxvsZyRgZw/LiBDz5gW9LgoMSuXX6D3NHBgQ5pacD27f62I48HuHFDw+Qk88ORTl4aHGRqpqbG9KmhZWb6/33dOhMjI8L3ZwsrN5yR8XgrkEdGuHGcnhYhNwZLHXYuGBgbM5GVJR/ZOEvlEccIra3sgTUM9rvm5cV2yGaxmCZ1oJOTIw9/zSUnxzIMNGJCsCimo2NxIcxwjI1R/jI/n/8fHqYBamsTyMtja9DgIAuj2PPK/69fT/EPS6ZycpL/t/KilFGc/V667p+MVV8vcPo0DdbatTT2AwPAD3+oz4iRwNf/+vbbOkxTIC7O9BnS9na2IUlJz6+igtOXcnNNDA3pSE5mjlnX6THW1rJP18pB1tSYEEL6qnjv3WMV7d69LEBKTGRer6OD7ThPP80Rf2Vl5kzIfHYYVkpuahISmLusrWUhkBU1AOj1ZWZy4EZenvQVoeXn03gNDGioqvL3SttsclbxoGV0LG82IcEfXQi1YPb2svgqJ4eDLrZsCT8De2BA4NYtHQkJEteva6isZC7dMFg13N/PjUVGhvRVajc2anj/favPGXjpJWPBtMnICPDaa1RMKy6moMnc+7moSOKjH2XbmbUpGhwUeOstFsTFxzNXu2KFidra2X3Lt25R3rG21q+9fvOmhrt3uZHcvt1ctJjIhg0mLlzQZyrzY7M/92GQlIRHnseOpR5i4Ak2xFJaOajF9bsuBUwTePddgfp6gYwM4OjR2Tt9i9FR9ui6XKx0tsK6FqtWsbBjfJy9oLdvC+zYwX5cCk9wIbaKsUpKuMBZ81YzMuBb3AyDGtMpKbPD5VlZLCxraxMoL4evXauwkCIhxcU8xjT5/+5uFrGlpvIcUlL4/ikpclG5pIkJeqOpqfRgDYNVrIODAtnZXvT26nA42D5kiT/092vo7+fAgrt3NV+Y+vZtTt/p7xdobqYQx927OlauZCtOSgoLhgLRNBbtuN0SP/yhjrY2GuJjxwzs3GmitVXgtdd0OJ0CGzaY2LvXwNq1wIcfavjgAzuSkxlaLiigkTp7VkdzMyMIe/dSiWt6mlrB3/qWDatXm1i/noMbrElZ1kSkFSskfuEX3Ojp4fQh6/HKSor1j40JZGay2KegQKK8nBrQZWWcBvTUU+Y8z9AwrO+MkYmREU6kWmhTGB/Pe25wkEWElpfNtjLm+a32NYvAugGvV8zLSQdjfJxDNfLyOI1qclIEHRIx16B3dzNSYxjArVs6Nm0y0N+vIy/PL3F5966Gd95ha1lvr8ALLxgYG+N35/HAN7jBStVESkYGr89ivXCvl/OrXS6mXRbTg2x9BpttcTOeYx3LI44VYs4QP65QQXm5xFNPcQe9Zg0eincXKzgcrFaOj2eet6dHBJ30cuuWwK1b2syiZuKll2Yfo2lARQVw6hSFRnQdOHCAbUAAf6TvvCNw545AcjJDe/X1Gq5d465261bg2DFGGt56i4VSRUUShw/7F9i4OODZZyWGh9muYj1+/LiJoSHm0lwuKmZlZ7NVqrSUHti9exwAUV0tkZnJPubmZp53WZk/bDgywnB0bq7/seJihpGpCiV9E32KimiYV6yg5rJh0GO0hhBY3k1WlvQJmViqSnFx9BJHRni9IyngmZpigUpmpl/MAqBxGBmhMWpvpxcoJfuBNY3Tnbq7aRgHBwVu36b04507GlasMFFWxjaXK1d0xMVJXLzI2cI5OfMrboVgVGDt2tnhYpuNueH6eg3vvcdq5h07mG/euZOe83vv6XjtNQ27d/uHMAwNCbz7roapKYEdOwycPGlgYoIh+g8/1HwypaGmRB08yE1Nbq5fsUrT2Op2+zYr2QM9wupqE4ODTDOtWGEGzdkaBl/DWl7y8yVqatgHXVNjRqyMxYlQEp2dYib1wF72QKwiwvh4hpGl5MYhLo5558UKgFgwbcAb+No1tqxFQn29hjff5PfX3R1Zv7NFXR3FUOLiuCm7X53sWCOW5C2BGDTEAI3xQoPRHxS7nQVIy5GkJBqVxkZKQIYqeGBoTMIwRFijwTAcQ5SWLjPgH/GXmkrvurFRm6lQ5qLX3S1n8nDSF1ZubBTYsEGirGz2ecwVLklN9W+OXnlF4O5dDYDE3r0cgfj666x2ttmAAwc4/erDD1lIpusUGtm4UaKtjeMXXS5OZNqxQ854ihQ7KSvzV6BnZgLPP29ieNiLnBzhW9BzcyUcDhPr1nHBv3FDQ0EBWysA+HKriYkSTz1loKFBQ2mpCY+HefbiYn/olikDRhCSk+nRV1WZaGigRGVurgm3m+1aubkMXa9ebfgqpIuKJG7eZJ7U+l4TE6XPs8/K8veDW61FTic3MffbotbdTYW2uDiJ1laGlwGgqUnD2BjFMu7e9Q9haGwUaGnRkJAgceWKjo99zIucHD5eV6fDZmOUpbDQDLoBLi2VQWftsuBovvHhps/Am2/quHhRx/i4xO7dfmNTX6/h0iXm+595huP4EhJo8M+f1+BwsPYgEi3l8nKJEycMOBzccIyNiXleZm0tddIdDk5bYhscW9/a2rRZozkXQ3y89EXuIq3SBrjZY/eExOSkWJSaXmurBpuNtQa9vRpqaiIz/rGOCk0rHjk2G/Wb6emHnohUViZRUSGQkGBi1y4uDOPjbFnKzfXv2rduNXHuHBfWwFwYq17ZF1xaylCmy8WFm2MB6QXpuj+snJ+/uFF6AHzFRobhF8cI3BxMTvKcenqs4wT6+63H6FmmpkrcuyewfTsFRerrBTIzmYseGpK+6u/kZMzkQ7lStbQIXLrE/KMlQuL18vEXX/QiIwN45RUdTU0a7HYaq6kpgaYmyi/qOuUwDxzgiZ89q+POHYahDxwwUF+voamJRXHj4wJ/+7caystpSF54wQuXS/jEF4Sw8tEmTJOGoL9fYM0ahpx7eyl00tPD/vGyMon9+42ZyVEmhofpvQWuPy4XZuQoZ4d7pYRPoKKkhOpbhjF75F9ursS9e7zeBQX+x5OT+TyXSyAtzfQt+pYAitvN7+NhFjp1d3MSUlYWp2hZFfhuNyUuHQ6gr0/ztWwBbF26eVOHEBLDwzry870RTZiyhDQCfwuBpKUBx44Z8wxeWZlEcbGBCxc0fPvbNtTWmtiyxR/WN03mlvv6BCorzXkbg8B8/+rVkefSLM/f6RTYts1Y1HWvrjZRV8cRnpH2PC8FHA6HMsSKR09SUvhxa1NTrARubwdycgS8XhYrnTqlYXSURU0HD3KxrK7GTJHQ/FaN7dspjJGQYBUKSRw9yoU4O5uFYlevsthn0yZWS6emUphjaorG28pJdnWxGrW01N9LPDlpfQ7O97VarrZtm785WLmSgyg0jfk3KTEz7J257DVrWHCWmkrDMzjIcHa4CJWUXCDtdgmPh95EYqIljCHg8dC7S0mRGBgQ8HhY8HTtmga7ndXT3d3Cp4jGlAGN5a1bGu7e1TA5Cdy4oSMry8ToqAabzcDNmxqee87AXNW0+Hi2gX3wAXtcpWSh2qFDBjIzJV55hQMNUlI4v3blSiqXvfaaDd3dAiUl9OSTk5knP31ax+Agda4t6UOXixuGnh6mG7ZsMZGZyXx5oCLT+vXMl5smq8GvXtWQlOQPD7PKl4VtZWXMLT/zjIG+Pla5OxyMSiQlSV/ueGqKG4Bga2Q4Ty4tjSHjkRGKrVivp+ssUuvv12ZSB8FeN7g63YMS7Fx7egSuXtURHy9x+bKOsjLpy712dbEA0BI0yc72+n4bAH/T27Yt3hhmZADPPWfMaMAv7rmWAS4snL8xWMo4nU5kBF7cKBOThvhxhKYfBS4XfIPoY52JCWBoiIVPg4OsXp6eFujp4WOtrfQ0rdBhqApPqyjLoqBg9r83NlL1CmCIetcuhqlPnaLYRm0t8PzzEi0twOnTVL1av17i0CFuDN54Q8P4OHOYe/b4ZT+DbQ5WreLAA02j8XzlFeErdiospJdfV8fQ+caNJuLjmWMdG2MlNufv8rU8Hi6aCQkUUhgYYIh4YECguZmDHLKzeT4bN5q4elXDqlWshO3p0XzFWYYhUFvL0LKu05u6d49h0vx8E52dAv39bI0SgvrhVnV6ODweXgh6mHzM5WKkIC1NzgxeoIEZHaVIQkEBRRLGxkwkJ7N62gqVNjZq2LjRQFYWe4+tSUhXr7JyOZiSE2sImGf/wQ90NDdzPOPRo8y/WpuC1FTg2We9KC2lN/r++zo+/FDHv/0bpR6rq+nRT0xQPMUwgF27DN8Gy+tloVN7O+coA7xX16/3SzUWFVG04uZNDbrO/HhJiZyZF22gtJRyiYEefUUFq9FbWsRMq9X86+x0hlYPux/sdoaYx8ctRTv/dbWKRm026St2e1gEyq9GytCQwHvvUXRmYECgvNxYNgVbTqcTxcXF0T4NHzFpiJcabK0QaGpi8dDevfMlJQGgrY03d2EhK4/vF9PkBCYAKCm5v17GrCzMSEFSCL6wEBgfl8jJERgetiqm7/8cA7GmMVl7q6kpGo+kJMxo9NKTGR/nwkwPkv/v7ua5NjQIbN06+5yCXWNrU/Dhh8wrx8dLABp27KAU5vvvC0hJsYyPfcyEw8EowMAAkJsr8PzzLC47d07H9evM+x48aODpp00MDwPXrulwu4Hpaf+mYP16E7W1/naUkREaOmpLC4yMAN/9rg1paRy2sGIFe257ezmneM8eA6mpzOGOjwMOB4u3TNP/3TqdvHesHPC6dQYmJ3kdV62iQEZKCs/l1i0az9JSruTZ2RKlpZybW1bG/kzrWmVlMY9fXu5v30tIYCRjbIz36kL5SMPgOScnc5Tj1JTA9DQ3ABkZ/L/DwU2B18tNnqZJtLXpSE420NmpobeXUYLBQYbXb97UUFvLcH53t8Dly2xpevVVG+Lj6eVOTAAvvODPBZsm0NKizQy/oA52Sgrvn6ys+VZN15mLv3lTw+XLGjweMUs1zXo8OVli/35/QZeULJxqaKBYTGB4eSFsNraXSclqdav4D2Df9VNPGejqEvP+zbrOLhe/n8fRv+z1csMX6ZSupYSqml6GDA5SMzk+ntW9NTXUig6kr4/e3ciImBHLNxedK7W4ckXggw/ETCWp9IljLAaryGnrVuYM7XYaxhdeMDExQc9WCIaVBwbYqlRVxcWgqYnebFUVDaM1LYpj6mbvvMvLJXbtAgYGgNWraUSqqiTa22mEt2+nAUpOZoWsx8NNgM3GYqSMDIGxMT53MZqzHNogZww+jablZQR6HE4nZip6rZYmzFSbcwEaGaGaVmWlRFcXlbMyMiTq6zVs2GD6NgaB5xboPSYmSpw6ZcPoKKf1FBRIXyXy++/rvjnDe/caiIsDXn+d+eb2dg2aZmDVKhNTU3y8q0tDYaGJZ581kJ1NOcu33tLxzjs6Vq9mG9G2bZTLjI/3RwqSkpizHB5mrvf737ehupoh5+PHDQwN0ZO+eFFHdbWJoiKJgwe9GBlhq1BHB4vPAtet8XEWgeXksBBtyxaOZywuZhgzOZmqWbdvW73Apu++q6oyceWKjqIi09filJHB+gKbjYt/Xp7fcFoh5YkJfz9zoMCJhcfD/5KTF9bOtujro7eXkyPR0iKwYwffz+sFrl/nsJLBQQ1tbf4K7qEhgQ8/pNJZXx/nEQcrLpvL8DDw6qs6BgfZPZCTM9uy6TpDz9u2zX9ua6vAN79JDWbWD8zWYG5rY+V8VpbE5s0LT7yKhNxcidWrOTZy0yZjUbKasY4q1oqAWFE7iZTERHojfX30WIKFuKam2FaUlSUxOWkNg7+/9+vqgs+wdHcDGzfe3+voOub1F9N74J+bmzkQwTAEurooVtHWJvDmm9wdr1/PMOSNG1b4mRuD9ev9P1i7nUMqAGsh4nG7dlFcwm7n1KXr19nWceCAidpa9jefP0/P8PhxiYoKGvuGBvZGr1snZyYhcZGKj+cxlqeQlyexZYs/V15fzwKmVato7Nevp2EvKGDYu61NYN06TuMZH6exuHFDR16e9BXnpKcz3zw+ztxvJJWrmsaNQG8v1bKsBdIwMCMUIX2tSYEV1ZOTrLoFOD2ru1tDXp6J7m4NIyMmUlK4MWhpoVLW7dvazGQhBI1kJCTwnrl5k1XLdXU6iov52cbGWJDmdjMs/dJLXlRXU3ns9GkbnE5gxQqBY8cMn+Tn6dMUtVi1ysT+/QbWrDFRXm7i7Fkdr75qQ1WVxM6dhk9xK7Bi+6mnTFRVSRgG23vS0rjo5+ZS9KS5WYNhwKesVlAgsW+fFx0dvO8mJymxummTvxBsbIxe8qZNzMkH9kNb0prBsFqkHA4W1VlRDRYYMreckDA7Z61pErrOorzADc9CjI9zU5eXZ2JoSPNFESLh/fc13L6tQ0qJc+d0bNnilxydnmZOf2iINQwZGfP71u+Hnh6B9nbN1361GC98ZIT3mq4zHRFDNg+Aal9alqSlAUeOmOjtZZtIMP3loiIaj85Otu9YY/7uh9pajuwD5qtHPUysKT6W6ImU3Ex4PDQW/OGzRcgyLB0dNNDBuHKFu3YA0HUTR4+ylejuXXr3g4P0snp6JP7hHzjoPTmZHqQQEmfOsD1K16Vvis1bbwm89ho9l5dfNnHiBHPQnNDEFrXBQf9s5poaiRdekL7F04oMuFwMnZ8+raG93Y7SUuC557xITmZb0He+Y0NWFquQLS/u2jUNXi+Lk6xFn0ph9Exycui9PfOMgYwMbhxqarhAVlWZ2LyZaYANG/xGfeNGE3V1GrKyqLA1Ps7IQHExZ+gWF/tDyykpbFsaHbWGOYT/PpnrZP44Lc2fPjEMMTPK0BqtyceZZ2bBztAQRV3i47nh7OlhNXdrq4DTyYK3wUGB+npWhN+6xX7mYDlFKyQ8c5fNepwSmixga2/3D2GoqOBmo7WVr79zp99Da2lhLtPjoUTqM88Yvvv38mUNd+5oKCyU2LPHmOcplpRI36zoggJ/ukEIfm9lZRLx8ZwbbZGVxX+7epWboGA9yOPj84dQ5OczH842IP/3GAnZ2fwdTkywEyJwsxXotzxMH6azk9ECCtRo82Zmh+PiRU7Yspg7MCPaKI94mVJYiLDzQePiOO3I7Y5M6CEcq1f7Bdzn5pEsJiephCWEPyTscDAvmZYWfLMwl/JyerO9vcCqVdxwVFVJtLVJX1+uFY5uaeEiXVER+vXYC8vztgxhXBwXqDt36Bmlp3OxmZ6mh+x0Am43NwIej1W97FdTunuXk5O8XnrRe/ZwYzA5yTBmYyPlKq0pQRMTzEkHejFC0AC0tbG4LD0daG7WZgq6OPhgYgIzoWHOtL18WcOZM6xaHh6mtzg1xYlKnZ0cVXfihIHsbObXuroocJGYyHawhASGo+eyZo2JpCSJGzfY4pKWxlAjp+eYmJzke6SkADt3Gjh6lMpXk5MU7SgsnK3YNDzMsHN+PjcG+/ezzcnjAe7cEaiqAioqTGzcyBTEhg3+PuSSEhOlpRQZqa42faFgawyf5RFbEaCkJG4Ohob4fvczNcfjCT6Ewemkobfm+Fr5a4DDNEZGWOh2757wbQRHRqgsBjDfW14evPI3lJiHFV4PhhDAyIg20zIncPCg/7usr+cMZpuNBru83Or3Zj5/aIifa2oq8iKwvXsNJCaywHLjRqYPLOLjWWdw9y5nDldVzT/nyUn+/haz9mRlMW01NUWBm8V4xJSbtQrQYivCKaXE5OQkUmNIxUkZ4seIEIv7IYQjlAG2qKsTuHiRPwCnk57hG2+w4jc7W+DEiYUnJ9ls/rCyRV4e8JGPmL5h8C0tVOgC2Oe4ejUnIV2+zEKkXbv4Yx4e5ucvLKRgw6ZN9L56ehgpqKlhCLe4mOe7b5+BO3c0VFdLbNzI93r6aYlr1+iJVVZyg5CbKxEXx3RAQQENdFYW+3lNk5uJykqJlStpkLZuDa2LnJbGxaenhyHR1FQa7Ph4awITNwIAjYWlQTw1xec7HAJDQ5yONDjI3HZ2NltRrJYdy7MIFc50uWj4L11i2HnrVo41XLeOHvK//quO3l5KJWZnMxR7547Ad74TB68X2LzZwCc+YSA/X2JoCHj1VY5lLC9nPri6mp7/7/9+HAYHNaxbZ+C//Bc39u2bvynIzmYxVFMTQ9fNzRp27zZQWSlx8qQXnZ0aOjoYpt62zUBursThw2xPcjoFWlvp+QV6b0NDjHoUFMwuaJSS33tRET9TZ+fsIQypqSxuunePnyWwpzUvj5tbj4ftWRbx8dwcdHdzk/cw59qyuJDRip4eMSv8ffu2mClIFGhu1lBezmtrmpzRPDFBFbD8fDlvalUokpOpWR4KaxRnMG7d0lBXpyExka8RGKWYmKD36nLx9xuYB66pkUhO9sLlwqw5zZFgtVnZ7SwsjDWURxwBSy1HHItMTcEnSuFycUgAZQMZ1h4dXXhyUigC2znq6+mdCMEQLnNYDCG73az83LhR4u23NTQ302vZsYML6xtvCNy+TWWuo0dNWN0ESUnApz4lMTZmIDPTn1etrfX3DN++zfCzx8NIQ3ExQ4Svv84w9dq19AxzcrgpkJK5SUv9qbcXvlRCaSkfy8igtzo0ZGDlSr/wxb59NEZUwbJ6limQ4XKxUKmzU/hGKLa2+lt+pqbYipSaSi+9sjK0EQb8lbGsomYYOSeHs4eF4HX3eBj2tNlovOrr2fIzPc1RjC4XFz6r0Cw3lzrZExMm4uMlzp9nuDY+Hrh0if3CodTX4uJYrGUVbrH4isVily9zmpO1ITlwgG1ClNbUYJo8B8vId3fTaFuTjg4eNHytZmfP6mhqope7b5+B3btnh1k1jWIm69bx/oiP5+aup4fh4cOHvbh2jYVQ3d0shrKM1+3bvCeMAHtg9SQPD9Ng5uXNFxjxevm+wTzB4mLmrsfHBdavnz2ysaBAorOTAi+B3rY1dtPtZirmUU0WCsQ0/UVnQ0NiZpiK/5zu3tVw9arm6x9/6SX/RRICszzvxZCbK3H8eOwZYIvJyUmVI1aEhkMGGJotL5e433tl0yaJqSlzps+VOs41NcyfVlT4c3TWon6/s19zcoD6enpZubn+xcYS57fZuKBxWpC/UM3loqeYlkYvaWhIzKo8tQRCQtHdzQXUZqOQw9GjEmfPchFOSKCXsncvpRcvXBDQNIGxMYmyMkpIvvGGht5eICtL4IUXTOTmcizmBx/oACRycvw5vLw8OW/TkpkJnDjBheaDDzSfSMPevQa2bGEe+e23dYyNCaxda+LkSS+mp3mdT5/mYIhNm/y54d5e4Rvc/tRTJhISNKxY4UVZGSc2WX2gzzxjIieH0YMVK2igKyo4JCIujj3TUlJylNW8JgYGuDFITOT3VFDAzcHkJGZ6p8MvtpYxMc3ZFeG67jdogcVYExNipjqduVIL6kFz89PZaYl5MLTPjQGr0VesMGflZC00zV9cODUFvPmmzVfFXlZGTW5Nozf6kY/QyKenM1Te1cVe6v37WQU8OipQXGyiuVmD08n5xzt3+r3TpiZWkSckUIQkO5v5/7ExRmQKC9krffkyx0aOjvpb57ZtY25c1+mpWgjBEDI3BLO9d4vxcXr21rzsuSxGntK6ZhzNyaKzudFY677iAJzIX3cpY4WmlUesCEljo8Abb9DTWrUKOH58/g/S5WLfcm+vwMaN0qc2FUhBAYUy+vrgm1azfz9DwsnJNHJNTcC5cwxZ7dvHBb6pia0QBQXMLQvh96ALC+ePPty0ya+MVV4uZxYbiexscyYnJjE6ygVgbIx/r6xk+5Alnp+f798YhKtwDaS8HGht5evU1PCx9HRuAlwuv8EIXGis62hVsFsV0pakZ1OTNU5QoKPD38caDms6kyXSMDwsUFvL3tTmZgp13LqlYfVqL+LjgX/7Nx3d3fQi2Q9szhSTseq1uFjDyZNUxOru5si9mzcFNm82sG0be1kDe10BaiavWkWjfu+ehldesc1sTjiFaXiYbUT/+q+sZt62zcBP/ZRAZ6eGsjIDV6+ybSnQaPT1MfRaUMCq17Q0CSkFSktNjIwwjL91qzEjYCNnDalfs4Y919PTvGcmJ/lZ8/NZGT0xwbnB1kYrMZHV6JZnHsn66HTSKGZlsep7etrf4xv4e5magm961Pg4i8nq66nI1tRkg83Gc2pq0rB9u+nbXFy+rM98Bg1FRRJCmHj9dRsGBhjV2L+fmuI2G7//tjaJjAx/ODaUCtXIiMDAAHudz53TfZXoAFvm3nlHh8slsGULh2tYOByMGoyPM2qzmMlNO3ZQUCY11Zw3G3zNGnMmLy9mzVwOvM5uN39byyVQ6XQ6IaVUOeKFeJJD04Hj+YaGWFg0V6y/rU3g6lW2Tpw/T08y2D314YcCV67wuIMHTVRV0fgAXGzq6jSMjLBNobiY3uWZMxTyr6/n4hgXB/zoRxqGhoCKCoHnnpvdtsNK4Nk/7txcvxTi+DgFM/r6+GPesYO529dfZ6GL1Z6Umgq8+SY92jVrJLZsoVFvbGQRUVGRvzfb6WQv8IEDEmlp8FWgW73GHg98HlVVlcTu3cDoqMTKlcybDg7ymg0M8L3y8rjZKCxkyDoxcbYov8vFEJ7HQ0H/QIF/TcOMZ6QjM5Oes8Phl22cmODCHReHGUET4dsYWAInExPc6OTksG/Z6WS1eHc3c8tW3/LmzcHD2lYFucPBxTw9nWmCgQGGIU2T55+ayg1CTY2Jn/gJ78ymz4aBAUYnXn7Zi+RkeuevvUZvvrzcxIkTVLmanpZ46y1uJMrLaYzmbgoAGtyTJzmE4cMPmVs+etSL/HyJ55/34upVHe3t3Hw88wzlNg8fNtDYyI1MWxs/f2BueXBQzPS387pmZrLwqaGBm4Pt242Z1kAaFMu4ZWYCa9fSaK5YwTx7YyN8c6AZ3ucEJuvaUgZVoqODhjYxkV57Xx8jFj09GqanKe85MEBPM9L5uQ6HvxJ9eJhFhlaIurubgiapqf7v21oKm5o03L7NDd+FCzrKyrwRDfHg71zH7dsaUlMFCgqMWfd2UhKwa1fwPHVvr8Dbb+uYmqLxt+Y/W9y5w/nKxcXMdT8Mj3pigpvAzEzpW6seNk6nEwCUR6wITXk5w2yTk6xgDfZjs9kk7HYqGKWnBz/GNIHmZlYej45yOEDgLloIeqQdHTTASUkMIXu9lODzeOidjo2xxSY3l+1FDsfiCs4swQwrtGf9vaODXvvoqIBpSnR2ctRiUhJzj1VVbG16802qMmVlSbz8Mr3sU6dYdJaXB5w4MXuoQOCmgKIMXPjWrmWo8JVXuPkoKqJ4SWoq8PbbfL2MDODpp73IzPRCCA3f+54Om40h9atXmYe9eZNCHiUl/nD1li08L5tNoqVFwzvvsNjr4EEObSgrM33f0a5dlGFMTWXP7N27bFWqqWH7G6tTaVQzM5lScDpZtbzQQpeUxEK4+noNeXnStxlin7ucyRdLn4ym1YvOVII/hzo2JjA6yhDy0BDbk+LiuEA2NrIivLFRw/r1Zsiw9uQkK8UzM010dWkYGOCGIi6OG0m2rWkoK2MVek6OxPXr1N6ur+dmyjIQfX0Cr7/OvuWaGhNHj9LD273bgN3OfPd77+k4cMCYV8SoaXwda2CCFYJ1OpnPHxgQOHdOR18fZmRA+Xl27+Z7jIzwe7UmJg0MaDNVyQxNFxUxNRL42/JLVc6/LqWlJsrLWYm+du1s4Q2rSnl6mjn0QH/Ebud5T08LJCZGXsHscmFmZCO/y8FBEfHkp44OMVPoxqjO+vX+9x0eZkrG4+HAjfx86asOv1+mp9kR0NFhdR14FyxKvR8cDgd0XUf8w6qcfQgoQxxj5OSwH5YKQcGPKS6mYWtvZ6tCYiJv4tZWjgWsrJQ+o3TpEneXVrtTIHv2UNrSbmdFqq6zutqa81tSAvT3SyQk0CvdvJlhaMNgyC85eeFwVW4uhy00N9P7LCriIlhQQC+0ooLGxpLu43g8Ltjj41bbEcPNbjeNa08PjXBfHz2VUP2YjY0C773H4Qw9PczJWpXMY2NcLCcm2IdqtwOnTwu0tNiwa5eB4WENbW0sOEpKkj4VrqYm9jcXFEhs2WL4PMjLl/WZTQY94Hv3NKxebc6buVtSIlFSQhnD115jBW1FBdufPB6+/ve+RxnHAwcMX255dFTg3/5NR3k525msBbGtjdKg7C9mYdnq1ey71jTmarOzWc08OEgPOTCVsHUrq5xzc1lkpesU+S8rExge1lBR4T//tDQ5I3LBxTwlJfTCm5oqUVTEOc65uaxAB+BTURscpCcZFzc78qDr/F7cbv+NNTzM3HJOjpyZIsTQuNfL0ZtuN9DWxvBwMClLIeBrsdI0zArBXrvGCND4uMDVq/CNtrSES7q7BUZHNRw/7sWJE15MTLDw79QpG0ZGuDHYuNH/fYyOwqfPvG3b/O8/Oxt4/nljpkVr9nlaVcpuN+YZy5oa1gEMDc32+C2cTvj0qwONe3w814ObN7k5C7YOhCIjg2msqSluBAPfU9fhiybYbA9HcpOa1hpyc1nXMDoa+rf9IFiFWtrj0AmNkJg0xE9yaBqg9xGuorKtTaCvj4vLvXvsd71wgWFoVq+yJWjHDjkjSICgYZ6UFMyTx9ywQWLDBj7mcjH07XBYPZU0iG+9JWa8Nw5i8HophTk+Dp+xlZJ62C6XwM6dPBdLIzcuDjh5krnGvDwuFiUlHN04MsLiJLfbkpnkD37tWonMTLZGpaWxh7W0lMVGVq/p3J5MS8bSUq8qLOSGo6+Pm4LsbC7mBQWcZTw9LZCUxCrb3Fx/L2R1tYnpaYHWVhq29HT2PXd325CcjBnDIOFysY3FCgmHU02amKBXZPXFut00LvX1mu812toEnn6aOeQ336SkYm8vvY+SEubX33jDhokJoLRU4PnnDcTH8/qePm2DwyGwZg11srkBmH0+djuFFjo6BL79bR0DAxo2bGD708mTBtrbTVy6pOPf/92GTZvoVR47ZqC7m8NBzp7VsW6dOcto9PRYPb4mDh0yUF/PlrNTp2xYt87A+vXUbW5tlbOq0AG2z7hcvDZJSSacTnr5+fkmiou5ASor87dD2WyMGvT3az6vf7EkJEifqlmgIp7Lxe81PZ362S4XfwPJyYw49PczTN3Vxd+HtblpadHQ0KAhKUmiro7e81zPONTvO1yVcl8fc/oOB1ugSkq8vhz7xARw6pSOvj5unA4f9guXCMF7U9O4iVqMYaupkUhI8PrmdgeSns4e6dZWGvi5GwePhxuD1NTQ7YJzyciQqKxk10F5eXAxmIdBrI1ABGLUED9uFluJGG38BUgUz2dBFXPB09MCo6O8gTWNIdj7xWp5KiigVvTEBBede/c4y/fOHYG1a2nY3n9fQAjO9v3IR0y0t7MyeWoKWLeORjbwGqenY1auVYjZ811feYVDGwDp08Q+e1bg0iXuwDdvZuHZ0BDwwx9yZ7tnj4nSUi4Ct24xpF5dzYKujRsZwl+zhq9laWLHxQFHjtBTuHCBFas5OcDTTxsoKmKUoKiIqlb5+dJX+ZuZycV7cJAhRa+XXuX69TSG+flynnxoIEVFJioqmBNdtcr05fiLiqhfnJjo3zyFklR0Ohl2z8iwCpa4qaGhpDfR1KT5QuehaGkRuHzZBkBifFzHkSMGcnP5fXd3czG9fZuhyZwcTm26elVHVxenJf3CL3hQXMz74LXXGEIuKxM4eZIiJwMDbGc7f17HoUNePP204asBCKSgQGL7dhOnTun44AMbBgYoZJKVBRw75sWbb7LV6s03dezfz+u8dy/HP7a3c46v1bZkMTxMjzovT86TlPV4WKyUkMDvctUqv/eamcmNwd27NKaBm5icHBMFBRoGBzVUV5uz6jMSE63eckYpHpbTxUEafsEbK4IEcNPG+9NEezuna1lpibExqoux3oJ58nDjUQMRAmE1tKuqJKqq5tcIeDzAW2/paGvTUFDAjUEkA2TsdhYejo6aSE19cOGjUDidTiQ9rIk2D4kn2hA7ncD773Mx3LyZxTyPEikpgDExwdDv/eY/KitZgDQ0JLFqFYtXNm6UPm1mq2LT6eR/WVn3FzrKyKAha2wUKC/nQslCEwoSlJbSY7EKj3Tdn2ccGaHHl55uCR4Ez2UHQ0puKKzWJ8vjbW9nzntykq+XlAScOUPvHKDxLS1li9bbb1Mju6KCuWWXi0VnHR30jE+e9C+gFB4BiotNjIxI5OV5kZ1NTWApgVde0dHQwF7LAwcMHD5s4P33dfzzP9vg9QocO+bFvn1e2O00grduaejvl8jIMHyL/L17lG2sqDCRnU3v98QJY6a4yr8RfOopA0VFzB1ai78lqdjeztxyTw/v2eJiE9XV3BjU1po+NbGsLOmrEraqqcORliaRmCgBWMaKk5IsKUWnk0VbgTnq/n7mgDMyJC5c0PCRjxgYH2d+OTtbYmREg9NpIDWVn7+7mwMrTp2yoaFBwzPPGNi1a76hGh0VvpBkXx9bkSx1p74+TkK6d48jJ8vLpU8tjZO6mNO32pBGR4HXX7fNjERk0Zm1/vb1cRPhclGhbK5xEoK5/40bZ39uj4fXo6zMwOgoNx3WBgBgMd/gIFMMOTn+iWMWTid8+fLAjaiF1xs8t2ypnLW1adi2zZi1qcjK4kayr4+epJUGAKyxi7yuCQkPb5xjOIaHKWSSkcHURH+/iYqKyNZWmw1BR24+TKzQdCxFXmPSED+uC9TcLHDjBm/QCxfYt/sw1Xfm0t7OCmKHAygvF3jxxfubkmKzAdu2zb5ZV63iBBhLxm54mO81Osp/27eP833r6hi+3rGDC8H4uNXPKzF3PCcNDz3PlBT4+hCPHTMxOipm2jqojuVyAenpJnbv5mMeD9taDINeqM1GD1uI0LlvCyEoviEExxCuWsUBBCxW4cJj7dTT0wHTlDMhOD7fKjSLj2co3TS5KPf0MDfd28vrM7fSvKwMM2FxCRojS/FJzLwWQ8h2Oz2Tykr2GhsGq8Snptj24vVyYk95OXt9m5ooZOFyAVVVDCHbbKw6/fBDCuM/8wwrk+Pigre+1NRI1NQY+NGPdNy9y2regweB48dpAM+e1fG97+nIzzd9bUvj4xTj+M53bFi92sT69SwAkpL1BBMTNFCrVlHTuaND+DajXi/fMy6OBWelpf7iodpaE2vXmhgf53Xp69Pg8RgoLOQ1GRxkaNo0gdWraRQTEnifTU4y3XD3LodUzI0aFBaaKClhfnD1av/Ep6QkFkVZIiyBkUVrPJ+UgNfrXzvGxoQvhDwwoGF83PRVNzc0cJJWfDw1w2tqgreqzS2Q++ADHTduaL7iPrebBXdFRYbvXLq6GEa/dElHbq5ETQ3TJ7dvazhzRoPbzWK+Y8e8vpC2pYt9925wXWwKvTD10d9P79iKcmRkAMePezE6ahXj+Z+XlEQtdJeLIzDnerhWGiQhwV878KCkpnJAjBVFSk9/tIZ1sajQdIwRF4eZCT4sBHnUDe1WKDE9nSGj6emHq64TaOB6egQ6OxnebGyktOPFi+yjNE2GfSh7qaGlBcjIEDh+3AxqjLOzqenc28tcUXW131u7dYubmZQUID6eRUzXrwt8+CFbM8rKGAq2Cqc0Ddi710RlJY3j1ats59m8md6YlVv2eoEXX2R+ramJ7U6Tk1ZrjL+1YetWPk8IvtcHHzB/Sa1jgS1bTIyOsv3FqgIuLWVR3OQkNy1zPZDAjaCmsQ+zrk5HcjLnDgN8fVa3C1RUcGqPYfA76OwUM+pPvEbT01QAo6AJF1N+LlaMT0/7+5Yp6EAveO5+1DTZ/pKQwOdYAiFut5ipNOXiNzhIQYzJSQ7ZiIujDnVJCQu6OjvFTA7Zn1s+edLA4KBl0G2+XllWws5eSOPjgR//cS+cToG7dylmceMGQ+AnThi4dk3DlSsafvADG/bsMbBunYmyMhMXLuj4/vcpubht2+xw5cCA8BWTPfecF04nw8NC8Huy24EjR1hYlp09e9DC9u2UXLVmGbtcPEdKobJqOzvbnGUQrPnPbjejSJHg8bBugbOm2U6VkcGIgoV/ZrA1w5fRhVu3NPzoRzquXdOxYoUBu51RDUvRbGQEuHrVr4tdUWHO0QznpqKkhEMjRkfNmSgGYapn/ucYGeEGYGREQEoNQ0P+anop2ct88yYjDYcPG7P08icmgPPndTgcjA5EWhWdlMTvamDAnInORPS0x0asTV4CYtgQCyF8AwIeFdXVEocOAQ4H2w8eddimrIyax4ODzK0+yn7yjAyJrCwukrW1DDFaFakA/zw1xR9qVhb/PzHBRWMu3d3AO++wmKmlhZWp1o9L17lYer2suL1+XeB732PBTk0NF0VKI9IjNgyBhgbO9714UeD6dc33Pe/bxyIohpXpte/cSYNiVcqappjVsxkfz8I0gDnr8+cFdJ2hzRdeMOFwsGVpYIDe8PHjJgoLOT/61i0ed+gQvwunk49PT+tYs8ZAejotYX4+B7Zb7SUAq1qff96L6Wm/ZGBCAiUVrcXamkZUXGxi5UpGEdavp1BHXByrlvv6WD1cVCTR1ERlL7ebfZubNs2uuNU0imjU1emIi2Ob0717zMMVFpro6KA3ZRkpu50Gf3KSnpJ1f09NCV8h0vi48Bmu8XGOvcvJ4SjCzZvNkAMRkpIYLhVCwONh77P1ntZQCbebwzNqaxlKtYZFcIqT/3xGRjhveWCAG7mTJ72+jda9exrOn9cQF8d88Nq186uiLaWrlhYN585xCtPu3Szq2rfPwCuvAMPDGt59lzlIux1Yu5YKa7duseo6UBkLoPHv6WHawDJcdjunZl2/rmPtWhO1tXzf6mr/OSUlMTR+7Ro391bVubXpy82V6O6mwEtgCDYujs/t6aHk69zIXE4OVdJ6ejgbOtLNg9vN7yYjgzUGLlfgvzEqmJjInvq+PjHLEDc2arh5U5uRVRUoLfVGnOIKtTGIBRwOhzLEsYSu+xfxx0FyMnDiBEOfoULgUgKXLokZKUpWG0vJH4xhsEAikiKG4mLmQR0OFmzpOgc4JCYy57VxIxfCuDigoYHh66Ii6StAio/3F1MZBr2BhAR/f7FFdbXEM88A4+OUSjx7VkNKCj0Hj0diwwYel5/P+caa5vdmrZBi4Karr4+LR3w8q4IB9idWV2PGkAWf98zX8atoWQvG2BglNPPyGIZPScFMPzAroJuaBFasYPj8+nV67V4v+3iPHDExNcWK1M5OGrxnnzV8GyhuRmbfPykpEklJzFtfv65DCOYjX37Zi8RE4P33dZw5o88UGnnxwgtemCYXvXfesWFkhEaivp6DHhoaWPBWWcnNT3W1REWFF+fOaTh9mm1OW7cKHD1qYHDQREaGvyippETiwAF6ul6vQF2djtJSE8XFJmprrZ5SambHxdFzyc7molxWNtvjCsbGjSampnTY7bPbdIqKWDylaZg1nEHXLYUmfxQDoJdvaZ+PjDB8bXmZN24wijQ0JNDU5A8Bz2VsTPjqFEZH/aGE0VGBwUG2xDQ3c+BGfj694YkJgZEReqZWuxjAe/3NN3W0tDAHfuyY4Wv72brVRF8fjRbb/ub3d69Y4dc09z8m0dtrznxeq6jS/zlTUoBNmwxMTdmQmTnf0CYmclxmdbVEbW3wkZfBik5zcyU2bTLQ1MRCrcC+77g4FmPduuUf2xmI1ZbkdrPNLIZSqg9ErMlbAk+4IY4GmhZeQ9nK4wrB/5eUsG/z/fdpiLdtA/bujWzzkJ/P/ywyM+l1Wty4ITA4yB9kcjJzphcvCly+zLz5wYMmysroUblc3NU/+ywN6cgIw4k5OdKXr56YoAG329lDeeyY6ZOf3LKFzxOCClmXLrEdyOuVWL+eeejeXr6HYTBXunIl86+GARw9KiGEDFt9WV3NIraREYnVq7lhKSxkrrOnhx56djZ8w9NbWviZrTYjy1tguJd/Hh0V6O7mQt7drWF4eHYxzFzef1/HnTvMzXu9AgUFpq9gRwjmSRMS6ImOjtJzvnxZw+XLOhIT6UEODUmsXWuisVHDG28w59zRwRCypjG/+6Mf2dDWpqG62kBfH72puS0mQnA4RXq6wA9+oGN6mhXSL77o9bUhvfOOjlu3/EIZx48b6O3leXz/+zZs2GDO8kI7Omi8ioooVVpSQi9JCHqVycnApk3+qt3AtpaVK1k0197OojJLVzovj+IYXV28n4TwPyc3l9fMysuHYtUq06cmlpoqZ0ZmMmyck8MWp4V6ny2sgqqsLEY1rDGSgNVbrCElxa9SFm78qf9zSLz0koEf/AAzLU8C9+5psyYmNTVpM3rWGu7ckbMkLi9fZj2B3c71I3DjQ3EN1iDs2DE7D6xp9NAt+c5ALO1ra0LW3OhHTo6JzExWXO/cac4zxEyvPZ603sNEGeJF8DhC07GIzUbDODIikJJCr3VsjCFdu53tOg8LTqTxh60Mg2IemgbfFJuMDIlz54Sv+jc9nZXTr7+uobMTKCyk7GV6Oo3awYPsS83OBmpr/e9lt/tVr0ZGqJ5l9RSvWGENQ+AgBs5XNVFby5B4YyNbio4e5eLT08PcdGoqc8uWfKQlhbltm98jTkykXrfDQS/MWjAOHeLEpJQU5lu/9S0qjFVWSpimiQ0bKMoxNQWfrGFxMT1Oy7OeG6ZjNIGhPo+HU4+ysyVWrTJ9Ie1Vq0xcucLey8xMiXfeYZtHezu90O3bDezf78Xq1fRUDIOSm1ZueWhI4N/+jbKU1nSmQJ3nYBgGZqQUJQxD+NreHA6/DGZPDz1PesTUyU5IkLh0ifnK5GR69m+8oftmAT//PCUxTZMiFvyeJA4dMoK2vSQk0Nu/d8+Gjg4NjY2MUqxfb+LIEQPvvKOhvl7Hq6/acPAg89NPPWX4pDk5K1rMylWOj7MiOy2Nm5d33tFx9ao+I07Dtq1jx7wYHmZ4PjAiuXmzAYeDle6Wmpzdzvu4uprXPz19tkhIYqKcp1IWKbrOmeVWtGBuT6/H4+88MOY4/hTr4e+0u1vM8rjr6zXcu8cQcl0dUFo6P2oQylDa7cFblEwT+PBDTrOy2eATsbGw2sgcDgqM7N5tLBmPeXJyEtmPSj/zPolZQ7wUaWtjiIwj+e7vNbKygAMHaCQKCqwZuxK9vRSlsMQ2OPJufj/uYqipkejuNuF0CuzYwcKosjKJK1cYMsvNlTP5X+58LWnEsTH4cq4DA/y7dQ4lJQvPLo2Lo4Hs6aEhjI+nnOXEBL32iQkeMzbGQrPERE6k6u1lfvjddznxBpAzgxOYWz5zhuHmnTtZIGZht2NewUhGBvPoLhfwrW+x8GZ6WuDIERMrVlAP+exZHVJynurOnV4kJkqcP8/+2YoKTlqyqsHv3KHnsGIFByxk/v/svVlsXFmaHvideyOCDC7Bfd83kSIlat+llJSSMlMpKZeqatQMPAYMGBjAT+6HngfDLwb8YBjwQ9sP9vihAWN6gJ7q6uqsqqzKPVPK1L6TEkWK+74H9wiSsdxz5uGLEwsZpCglpaSy9AOFLJGMiBt3Of/5//9bMiSOH5dh3WIde/ZIlJURLR8IsArPzZWQUmDPHlYzAwPckGzfbqGmhujmmhoLPT0G7t4lInd+nhuDDz8Mrsv1BLj4Hzxoob+fCkm6BZmTI1FQQCBPTU2EzuVwcAPo9RLIpMFsXi/byBkZ3AAsL7Oin50lCjkhQaGvz8DoqIzhhEeHnh3bbArNzWao42DhnXes0LxchSlBZWXsagiBkL8zZV0DAQtOJ+em33zDjUx6ugpzu51Oztvdbm4aGhtXz9sB3hNaHeruXROpqQjLOO7ZY6G/H5ifN3DvnomzZ62QrSFlSq9eNcNgr+jxhGURDGcY7Aas3Kzt3s22s2FgFaXn0CEZrnhra2OPt6pKYXTUgM3GWXF0JCRwUxgIYEN83Y2ENj9JSCDoTHeIdIyPEzyWlUXVvAMHNs9r/WWH1+tFmRau3yLxJhFvUgwNsUqcnycS9cMPV89xgkECirxeAqjWStYVFYixgSsuBn75SxlW/wkEKMfY3c3K8/x5ftaNG1ys9u6lwQOl/7iTLitbXcFlZAAffKCgVGTBOHqUM1mHg23dtjYCvmZm6PtbXs6k6PMBXV1ELefmcmMwM8P3fBYFLDmZFengoEBmJr+fUtxkdHZS9Uqjt7Oz+XmZmazG/X5+L9PkedDgs+HhiC3iwACwb1/sZ3Z1CQwPc3YezRk1DC4gExPsOEQARNrKj5VjUZHEwADbiRkZbKvW13Pm9uCBiXv3mIgPHJD41a84/L56lYYH2dkK77wTDPOFo4039u+naMT27RKHDln48ksT3d1GCIFN8wSPB/jiCxuGhwWGhigmUl8vUV9vwesV+Md/tKGuju1HPSPv6iLKvKyMSOl9+yT27UNILpMbkaws4OLFILxetmH1PVBervD22xYmJlgJXb5sYvdu6irX1sqQxKgMu2olJQEZGQSLPcs9KT2d7dMffmDiq6mxMDJCEYryconmZhPp6bG2k3pWGQggJPNoQ2IisG9fEDMzPPaZGYHKSgseD/WP09KoH56SQg3r0lJSmBwO3t+GwfPv9UaoacvLkeOcnqa0ZW6uRH+/gZmZiNLT/DwlMRcW6F4W7eHb1GTg9m1iA44ds2K6FcPDAjdvknp2/Phqxa3CQrXmDJztdr0xjk3+lZUSLS0GlpbEKklNgNfb42HnY6MsDdMk53142ERRUSwgDWDnRG/I6utfjIb5U8VW8yIGtnAi3kpk643E4qIICfWzXba0tDohdXYKfPstKQ3DwwoffbRxx5Lo3ebCAh/qrCxyYqemKHzQ3Ew0rt9PZOWNG5S9dDgE3n6bc9OVoQFOOmw2IHqz+OiRQHIyH8zERH6v69eNMHp5+3btpkTP15IShXff5QP/8CGpRNXVBIMBPDdTU5z9HTyoYo7j2DFWsroKAtiOHhujMEgwCPz+93SCSkkhIIY6ulwUhWD1VlXFjYKWHpyeZot7YUGgs5OuUrm5fH9Kgkp0dYlQRSjw+9/bIETEE1ZrE6ekKKSnqzC6ly1oJjedxHw+JqapKWBggKIGw8OURFw54xSCgKfGxsj8TdOghOC1EIKV+vQ0275LS+xalJYquFwS339vQ0qKwuPHnLempyPMW15eBioqBD74gMb1U1PAd9/ZMD/PFvHhw2yZr5ybGgZb6F6vgfv32UZdXAQ+/tjCuXMWWlsFbtywYWCAalunTlHkpLdXob2dibuxUcZoOrvdIswB3rGDSfeLL0yMjREEl5SkcOiQQnk5751o4NC2bRLLy6RI9fcbYX6630/ec1sb58JlZQr79wdDPG6BsTHKfGZnS9y5Y6K93Qg5kVnYto3nfP9+C3fvmkhKovGGDu2kNTHBJB5NUYp+XlYuU8PDAkKQ3jQ+HvvLhw8NjIxQv5x4jWfbbALsRPz2tza0tZkoKOD5r62N/L6728DUFMFqT54YqKiIvK/bTcMM3fU4e9aKWXM6O0VYh/rAgUhCnZoi4l8bg6ycEpaUKFy6ROW0/PxYIJffT8qUz0fO+cswbvgx8WZG/DOO4mKFbdtYWe3YEZ8cr00LEhK4oL6oGbfLxQehu1ugqAhhMXxWiUTAGgZbv4mJ3CRMT7/YvD03V2F4mO+Znh5pp6amRqhJbjcr77w8/ndqigvljRt8OsfG+D42G+UoR0epynXhglzVStObF79fK2lREEEIalyPjoqQGw5Bay0t9G8OBllRnD1LRPqnnzJhV1dTMc3vB3w+hf5+miycPh0BmJgmW38pKcBvfyswM2PAsgTefptAFn1MmZnAu+/SPCE5WeH6dTOscFVRwZZmWZnEo0cG7HaF3Fzq5ublMfkvLHC2vHLxjv73oUMWUlJ4rnbuZGLIyCBStreX9Ke33yYHV/OV9ThEL6LLy1obmbPlYJDfcWTEwOAg5/4//GDD0lIQ1dVqzda2Pi6lIhsNw2DL0uMhEGpkROtvc7M4NkYRlgcPDFRUcLa8sEBXHZ2IL1ywkJWlcP68heZmdhe++MKGEyesuFrLDgcX+7t3RchH28ChQxZKSxXy8yXm5kx0dRm4fJkt5JISnu8TJ4K4c4cevr29VCWjxjfv44EBPjO/+EUwTMPTQeGaYBjNHb2p3r6dwLLeXoK29GwZIDpan5OiotgqUjuc0YRi48/j8DCNKQCFkRETaWmxCTyakqiZCDrcbraQc3PJQvB4ImMkr5c8Yq8XGBqivrquqL1eVv7Z2TxnS0siZjMCrK2A1d5u4PvvzbD4yMWLW2t+/IZH/DOOpCRSk5aX10b2VlVRhrKlhahiy+LD09/PBFpaujFlL5uN2s27dhGAlJoaSYweD5WoTJMJ+84dIjY1onZqKuJ+tBHe9JEj2qFJoaJCC1woPHlC5GxJCRNzQQH5xsXF3O0PDfFzdCUvBCvTsTF+9vg4W2Zrnavr10Wowhc4c4bJVFNfgsHIzHdpie1FnncCaLq6BPr7WXV3dQns2kUji9/8hm3BJ0/IY66qoljI5ctsZ+7ezQQYCDDZJyauvh65uayU2toIkElO5kz3V7+iCP+f/sR2tNMJnDgRxO7d5PvevMmqhC1oVmOLi1SYMgzOBJ1OhKwY2faNvt6nTlnYu5dtfX3diosVzp5lspieBn7/extKShQaGjhb1gm6p4dVp8tFlaOhIVKXABNDQ1TVWqnDDDDh+HycB1oW8MMPJvbupZ9tbi7vt7q6iEylni3rObI+zsVFHov2W/Z42BZPTiYKeXERIQ/stelJSvF/paUShYVUkioq4oZteprdhulpEfaaFgIwDLaQ7XZ2LVJSeM5KSylwcv8+QV1vvWXFVO+PHpE/m51NxbOVdDm7nSpXUgJPnpgoKoroVJeUSCQnExXd2cnqVL9+714r5OYUQepHx/Q0KVUUo4n8PCmJsrUcF1k4dCg2wdfVyVCy5AgiOnJy2EIeGaGhR3QhaBgIz7lNk9RCHfn5Krzh0DaVGw2/n5sDYj/EltPyf1MR/8zDMNYHS2iTgbo6oi77+vjzb78lGKKxkXPYjYTDgRgVLLudFCEds7NMdvn5TCpSMjl+/bWBhQUCnE6fVnC7SVmy2YADBwh48fs5c6XzTaStrCPaoUkfy/nzEtPTnOkuLwP37/NzDAM4cYKgqpYWzscHBxF2P9IKYzk5kapLKSJZExOZZGdmVPhzk5PZKtMykBUVCouLNHFPSpIYHiYIKyuL1o0VFXxNZSUpUktLCHnvssIYGmLL2ulUGBgQOHnSQlubFXKCWfta6CS9sCBiwFdzc5xLejxEJ5eVSbS1GWFOamsrZ8suF+Uw797ll/Z6KUIB8Nw1N5OP/fbbFnJy2OGI12UpL1eYmAAuX7YhMVFhepqt1Pff56L/9dcmHj40UFxs4OLFIM6ft9DUJPCHP3Aj4fHIsJY3wI5GBHCocOSIxGefsa3b1QWYpsLx4wSJ+f2IaTtWVBAx3dPDc//ddyYOH7aQnU3keG8vE/TSEsJVZFYW576GgVUVV3QUFSkcPszvxCo+cu9VVko8fkw5yWibP9PkeVteFqiq4qaFCnDADz+wa+HzUatbh8dDqlAgQLOKsjK1CjilFI/f4SA6PhrhrGfLJSVUOZuZifCx3W5SvwxD4f59E2VlwXBidLtpmDE9TUDdO+9Y4Y0MZ8fUEt++fXUXiWyF+BuYYJBJUQi6gUV34LSQzPg4PzP6fnc4uPkbGmIl/Dydu5oa+jx7PMRAbCG3QSil4PV6kfoy1ZReILZsIn7dZsQbCa0DPTUlQspCnDcuLbHVOTZGytZmfXXtpQtoeg95w9nZXHB9PoV79wTa2vikJCRIvPWWwg8/sGpPSaGoxUYAhi5XROv5yRMCo6qqmDSLijg7ZMJnZXT2LLWvv/mGFKE9e6iiFQhw1u3xsKWZn8/WqVYBKy+PrRYSE/k5lZWsIufnqVr2/vsSc3OskG/cIHBHSra0CwsJ/Lpzh9aNCQmsssvLacTR2GghPZ0V1VpRXq5w5kwQHg9pR3Y7E8vu3RLNzXTCKSvjAp6aqsLWjRUVrIb9flbEGjSklan8/ggCe3iYc3fNyY0XSvF8tbZSIWrPHhlG0S4v83xkZfGzFxe58E5NiZBaEjnfesEfHuZsmf7GCh98EAzT1rq72bJPTFQ4eFDGVYXTlf3TpyZmZw243UyuR49KvPWWhaQkcmG//tqGmRmaPuzfT3pSU5OB1lYjJDYTmZkvLrJtmphIH+a9e2M/07JIU6quJvo+erNSWalw5IiFu3c5r9SGFAA3gjduEKC10iQhuu0f7Zesw+HgCOHPf7aFXhP5m4wM+jlH0910RARnOEeOfs6npiJUsrEx7arF342Pi9BGU6Gjw8T27Rv3FR4dJQ86K4vKYwcORExARkcJPrTZuDbMzcVurO7cMfDokYmkJIL3nsWG0OFy0dd5q1XCOhYXF99UxH/JQaAIDb5dLqKjk5IUurtJ39m5M0IXGhriolBY+GI3c3o6K9H2dr5HSQkXlZwcPuQNDQRFBQIIt8q0is7QEIFL09MECW1UY1ZHWppCerrAzAzR4U4nW+J0bkJogSMdSTvRdHQI7N9PKsS1a6wmMzIULlzgwvHZZwZGRjgbf++9SDJOTmbF3tZGhygtIJGbixDYhraNyclc7M6do871H/+oFyGFPXs4hzYM4JNPDCws2LF7txWmQI2MCPT2cmHWJvBCsM25vBy7+Dc2UmXKbo/M/4uLFd55x4LHw83PH/5gC3VGJBYW+H65uUxGWVlcZJ8+NeBy6Tnv2kYZS0uc/dbXE4UerZ5UWEi068QEXZh0O18jz5eWREgqkz9fXGRbOT2d82wNOKyqYpu5tJRV2fi4WJcylZgYmYXquTUBX6weHQ7OUfXfJifTxlHPlsvLCTqTku3wjg7KgJ45Ewx3QpaXKZ4yMSHQ0ECXpJVhmmxH+/3kyN+4YaKggJuLujqJnh5WqA8fEglfUcFn4uRJC998Y2Jmhs9AeXls0qSoR6TleueOiaIicqpTUpiEZmaosxxdvZaX83o0NxsoLY1FMOfkSOTmGhgcNFBfb8VsdEyTyd7rFauq2mdFRoYKWSeuRjdLuZpfrtHYwSBFXRISIvKXG03EOrZiEgbeoKbfBBDiBkdu6IIC4Be/YHtQV5R37kR8d99+m/Ohe/dIXamtpRIVreX494WF8W0Oa2tVDLqysBD46CMarufmsg3ndrMqTE5mlRAMMmF2dAhs20bZSinZ5rbZ2EJ+VhQXAxcvSng8nCN3dlLXWe/Mjx4lWlzb9Wk6l2GQl7y0hJBpAv87Ps52dl4eATZTUxF6kxCkXO3YwYS/kkaRkhKZWWdnI2wssbiozRPY2isuppIZAW4ST54QLBUMGvjiCxO3bhkIBAR++csgLlywMDUl8N13JhYW+HcHDzIRKBWhV0UvmExcCr/7HcFDPp9AYaHAL35hYWYG+NOfbGFjinPngqispBby48cGbtwgSEsrLQUC5O1aFqUv8/KYyHbskKirk2Ht6KQkJgVtJagXRiEis+7hYYF/+icb9uyhoUVtLSUc9VzRNCmJWVcncesWW6ft7esn4kOHLLhcTN7Rs9fKSvLj6QMceX1CQkTruqAgkqA0+lkn6mgt9MFBdgGigWHx5tzar1troQ8MUHo0IYGVZ2amCs3YRbg1a1k8FoeDLeSSkgidanhY4KuvTPT1UTqzvt4KjTr43Ny+zXtizx65avMUDJIWl5RERH1PT6TtnZpKAJdSHGtoQwmA16q0VOLhQxNlZWqV/KUGRSUkrLZWLStTYV9o7Zamo7CQgikDA1RWi1bWstnIP79710RW1vPNiLdySCnfzIifJ36Orem1wulEDCBkYECEXaHGx7kw3bnDn83Osm04OMjKESDtZ/fu+A+K10sQSFYWF2YKWfB3k5Oshg8dUpiZ4QLf3a0VlpgoCwo4Q757V4TmRqweh4fZgna52FZOSNCWavyc/HxAL5odHdx9l5Wx6tCt7spKIDmZ1JTCQoTpVouLAoWFtFScnwdaWwlEGR4GysuZWKenEZ6bCrG2qElSEilQOrlkZ/PnBw9K3L1L1KvmFaelKSQlqVC7OQiPJ4iZGQMjI2zX2mz0Gj55krOzoSFWj+3tBnbtYrVx44aB9nYjZCZhrWrhZmWx42Ca7IbMzfE6e71Mwnq2XF1N/mt/vxFWltIm9o8fG7h2jajU3bsFTp2yUFNDwM7duyZu3QKOHrVQXk7w2cpjSE8nTYgSo8QnPHxohGeT7e0CV6/a0NsLVFUJXLhAi8b2dlbN//zPNqSmBnHwYKSFPDUFTEwYYW/cI0ciCZgzStKuPvooCMuKvV7FxQpvvx1Ec7OJqSlWuseOWaHNoURTE1vTwWAEoexw8H8LC7GI8ZVB724Ls7Ok79y6ZWBiAvD5WAUHAmwHR8tUsgLlZi0lhRXoxITAnTtEnesukVKco2vnsOZmzvZtNs6lCwuDcb2FhYiAz3TMzzOxl5dLjI8bcLsjzkzz88DoKIGBg4MGBgZi57k3b9KaMTl5dQt5cZE69T6fQGqqDDuCAdpERK7i3OvXzc5yppqSolbJeE5NAW1tJpxO0tE2Q8zD7aY2QkoKOxYvQzbT6/UCwJsZ8Zt4dtTVKdy+zcRRWspK0TRZRTmdXBiGhiK0haEhYPfu1e/j9QKff25geJgV3/nzsUCP7GwCvsbGmCTT0+mZbBiskPXmoLubiWNhgfzn8nLg2jUjRNMg7aehQeHaNc6WU1OZ/JiM+Rn9/QiZAMQeo9bCXl4mwjkpiQmxsZFJ95NPDPT1cXa+c6fC8eNMIDduaEvFiN/rkyecg9bUqHDlrjm51dWx7lpVVQhTjgAuOOXlFs6fJ4DHZjPx2Wc2LC0ppKVJuFwSdrtCSorEw4fUw3a52MqtrWVHY2oKYa/gvj4DIyOrgT6HD9NAIBCg7vPDhzaUlhKhOjDANque/yUns8r3eAQqK7lh0W5KusU7NxdpH1MilNfqyRMD5eXxATw0DgmGOKSUKdSAM8MgkI1jBFaLPp8WBuEGsLiYm4G6OkqbejzA11/bMDqq6UkR96SBAYHr141wyzeeiI0Q7Bjcvs3k1NpKXeiGBok9e1jh37lj4uZNGwIBzpZLSxVOn47Qk5qbDezfH1m8lWL1SjW6iHjGo0d8jgyD1n6FhZwtR1fT5NRauHzZDM3ZeV27ugx4PNy4TE4K7Nlj4cMPrfA9ROQxQjaXq1W1EhIo8vHkCTcBlZWRe8PlIiCrr89AYWGszePKcxUdWuREOyjRKjHy2tZWCowAvE6XLm2Muzw5KTA8zE7D9DQ11nUnTylulnp6jDDfPd5o4HkiGAS+/54bT423iCdO8mNjcXERAN60pn/O0d3NyiIzU+HIkbVdgp4Vu3YpFBezmklP541/+jRlLsvLSeNJT6drkmEABw7wdV4vOb2ZmQjNeFlF5uXxv9PTsahul4tc3pkZJmVqAbNdu7xMehTAhfvuXYomFBUh5P3KBzspice3vMyEnZRE6c2xsYg27Z49KiTmzw1BvEhIYKustVWEVJ9UyOidD7qUbKcnJ7PC9vnYbuztVaiupjAB7RMFRkcplqIUuce9vWx5njsXe030QimlhJQSSnFOl5BAU3e3W8DlEsjKkvi//i8/xsdJbbl9m1Xqvn3LcLm4GP3hD3b4fDwPfj+RpsGgwsOH/NuqKn5/LV/Y3i7Q12eGJAINfPxxEEeOsLLTi21lpcK771L5amiIGtO5uQo7d0qMj/P7Z2VxtlxURLERw4hogi8vr61yVlREt63iYlbhJSWR+WFxsUR5OdHTDQ3cvFVWEnWslA12O5Ho+ji9XhE2pZ+aYgtZJ5LPPzdx+7YZUikDPvggfiKgYAwFNChkwtdrQROAyW1sTIR/npbGz7bZqG5WUqLCPOT2dgNXrtAwY+9eC0ePclHXmshEdrMlu3JNJvUpUrXevMnrJCU3RxkZPGfj4wY6OyObrW3bOHduazPCTmXRlWIgwHNw7Ji1qoNjtwNnz9JBKy0t1iLV5WJb/8oVE4WFsapjdjs7CrdumUhNlauAfdGGI/I58ppWNxsbIwJ8JaJdf5dAADGo+xcNy2JnyOkk5WmlpOZmhdfrhd1uR8IW0+Pcson4dWtN+/1sS87OEpGcm/viFotCINxC1f+ur1eor4/8bH4eyM0VoSSosLjI6pdGDMD773MB9XqBH34Q2LuX8yOlWLlRdB4hZaXI+yYnr3Z32r8/sjHIzQVu3SIQy+0GDh9mBTo2RjOGqSmB7dsjvrNTU9wUPAt5LQTb3to7WVfKR45IPHjAKnvbNh5XURFnxjabQl4eNwSjo7wGSUkRsZTpaVbZKSn8744dCpWVkc9Uiu1Fy7IgJXD3rg0dHVQZKi5WSE5mhV1VBdTV2ZCVRURzZqaC18vzWVISwNWrNoyNSSQmks+6d6+E0ynw4AF3+ElJgM0WRHk5hUU0AMntZsVWUqJCmturz0lFBY0+bt7kXLOnh5Xoxx/T9/ibb6iUVVys8N57QaSmkhI2MCDw29/awspd/L78+eIiE29Kipb7jFQ6QnCTd/GiBb8/AhITglrIOTkB9Pcb6O0FPv3UhsOHac6wbRvpSbqK9njYKZmcJJeXYhRrP9N2O3DqlMTdu0yidKOyUFHBynF4ePVs2W4n4l1TxqLbwJOTrOSdToXhYQMAz4HLxeStlMDjx0Twx9Ohttm0jCoBbQcOEN1tmryX7HYmjrGxiMqVUuxeJCcD3d0mKivJxQaYaK5c4XVPT1d4910rZu46Ps6Zd2pqbKIFmOiGhw2kpbGF3dtrxMzeDUOtybYoKpKw2+lxHc/LWfPwMzJiQWBpaRQ0mZnhOYrewAtBpPq9e1w7VnZ9+OwRg7HRUWxCArEFDx6YyMigQM7LCO1FvNXyy5ZNxK9baISo30+e4Mu2BbPZEHZ+oQcrk1FeHv87PY2QGg8BVgkJrI5aWgRu3WJr7uRJFaO7vFYYBme4Onp6BHJy2LrWoJ2rV1lJpqayhVxQQD3sri5Kcb77LlG7IyN8fUYGsH17pH2njR4qKmI/u7R0tb3f3r1crKhQBPzxjzRJkJLf9cABif5+ga4uJueJCf7c5eJ5oukEE7B2+JqfN/D4Mauxjg4D1dUWLlxgW1R/x+xs2lC2t5Nf2t2diJYWhcRECw4Hd/FFRUFkZhLAMz+fiJQUiaUl6gDrZNTaaoSR5YcPW6ivX80NjY6kJFa71JmOuEgFApzlaZSzZXFRfPyY6NuUFIXmZkpfJiayFf7NNzYsLgLV1QLvv2+FkfI3blD5qr6eiVu3B6NDCLbAx8YU5udN+HysxquqLJw6ZSEzU+DmTRuuXDExMiLw3nsWDh60MDPD6nNykt2EAwciIwFy1kXIslKFOyxzc+w+VFQw0Wdl0bc5uoWclaVw8qSFH36gWMqjRwaOH7eQmEiEd2+vbtXKkKeuvp9ViEe+trJddbUMCeQQiZ6ZiXBV7XQauHOH17C0NJIwdCWtxyHRrWmvl5ug9HQVtmvUidiy+PwMDlLcxemMTZr6vXRFG51DgkECv/LzKWgyMRELpOvsNMPV5eAg72sds7PAN9+YmJ42UFMjcfKkFXPM2hglXhQXKxQXx+9u3L5toKXFREoKZ9YbpVrV1ChUVwdfKtpaJ+KtFm8SMVjZ+XwEGL1oArXbgZMnJTo6WL2tleAoVqH5tS/+eQcPss1qmqQ92WxMGIODAiUlTBq6faytFZViW9fv506/r0+F/YKfJ2pqiOJOT1cxkoR2ewQMNj+PME1raIhgF6dT4fJlzjEdDipXVVUBTU1EiScnk96ldaCjY3qaNKKMDLbHdYXd1iYwMsJK3efjHDwQAH7/+wjK9vBhKnP19xMM5nQqnDplISdHAuDsb3qaFfb0dMS4QPus6sWJ2sTksj54YODKFQMOB5CXJ3DpkkIgIOF2m/j0UzsSEiQKCgIYHzeRnx/E8rLC7dsmkpO5WZmaIiCtrk4+c4ThdAJnzwYxNmbEGCKUlLAtqulJGoTndEZmy1lZRMk7HPy3nv1OT3PjkJiIEJKY7dR79wyUlcl1Hb1SUrgJ6Okx4PcrzM3pVmuElzs9zQr25EkJh4Pz1vx8iaYmE+XlER7sjRsmWlo4Qz59OojUVBUGO42OCvzpTwTurPU86ZZxairFUsrK6PxUVkYQ0ZUrJjo7DSQnI5xoTpyQ+O478pMnJsSqFv7iItHN27bF3yDt3ClDzkoqxtXL4aB29R/+YAsJaUSOOTmZ1+vBAyaoaOSzUpzL22wII7Cjw2bTxg40ysjIkDG/Ky8nsC8zU61qTetNAbC6NT0+bmBoyAg7KO3ZE1805nnC5yOi32aj7O7oqNhwIgZePuVJy1u+qYg3GK/qRPX1Ad9+S1GJ3bsJBnrRWElNihdPnwpcucKW5KFDCgcOkAPb18fqr6FhY4IeaWlYdazvvacwPc3FwelkVaG1hvPyWH36fAJNTfT3ffttvm5uDmFK00Y2Bvv2UWRDKyMBXNxaW+mmpLmehYWUm8zNJQKbyZScyECAM85gUOHxYx7j4KDAwIBY1ZpbXAS++opt94wMgQsXIkCwrCyF3FxKPNbUUOO6q4ut85QULtIVFTwnX3xBPunQkMLAgEJenoHOTiMkKkJHoTNnLGRmchPzzTcmMjIUTp6MFbCgNKAKOQKxpVxZqSClwL17NpimgNutUF8vcPp0ECMjCl98YQ8JlEgcOhSAz8cT/fXXNlgWUc5lZVwQ5+YEhCAHVDsFZWTELsAAk8c777CFHN3W1vPc6WkKmXzyiQ01NZS+LC1lq5jcbSM8G3Y4eK9sZNFsaCCSeWrKCFXFJk6etFBaKlFayg1QQ0MESVtfL9HdLcLAr7Y2GoYkJXFz5XSynT07K7BrF5NfXx87B/39AtPT3MzEa3M6HAi/T3Jy7HnQWuhOJ5OCbr2npfFaOZ1EoxcUKNTXRzSWv/zSxMgIBTnefdcKJ2MpCdpyuwXKyyVKS1cfj88XQcTfv2+isjKIhAQ+V0VFCs3NlAYdGIhgKAh2svDHP5JfHu1/rEMDGQ0D6OkxY6RAjxyxUFnJ870S5FVUJHH7Njs90dUwwPvL4SCla8eO1bPyFwmHQ2M92DFYSbX6qWMrcoiBLZyIX1WMj5OOkJGh0NsrcOTIy20rj45yt5+QwAegrEzh6lURMjlgFaaTzPMGJesi/56cFKiro5m4EGzRzs5GfFAzMxVGRyOylw0NCidPEuTT0kJkbn19BFG6vMyFLCEBq46xvHy1v+rZs2xTu1x83Vdf0YghGATeeYeI8JYWgcFBhFWfXC5WW/PzbEOSRsLjzsqiulaIgQCAm4dLl2T477/5xkB/P2dfWVkIt8nJnZV4/JiAm/R0gYkJbgyWl0WIZ8sEIiXw/fcmlpbYQiwr4/eIju3bFYJBGdZbFoKLbWEhNxZpaUB2toGkJDuEIE0oPV3C5zORnR1Eerofly/bMDwsYbdzXhkIUJKypcUI2ULSLUejRzs7Rajy4TxtYoIbmJWte8NgR6azExgfN5GZSYpVQ4OFS5csdHWRntTdDZSVUZT/9GkrNOc38Oc/21aJZMzNcf6fnc1rVFysMD3N3+tKKzOTYKzo2TKvEVuUn39u4s4dzuGHhiz8H/9HELW1Eg8emOGZq9/P82m3C3R1GWGRibExdldWbtKcTuD06YgUY3Rblhsb3s/19RGqldZYDgRE+N86ZmYERkZofzg8TIlKrU43NCTw/fdm2JDkww+Dq6hhWshleZmuT/q9p6YoXbq8zE1xf78R5p4DpCXa7ayOHz82Y9q+4+MCzc1GKAFLnDwZew5GRnifxttEdXRQ91wpXlut9gbwOWLFzOu6chTR2UlAGk1NNpZQhQBOnLBQVSVDWI+tlYg9Hs+W4xADWzwRCyHCM7yXFfn5pAosLXFxfdmz3bIyhd5eCmfU1KgwMjMet/DHRn09aVBOJ9HWhsGFIiWFGwHT1AbfTFo9PQKHDik0N0c4ygsLwLlzCj09tD8UAnjrrfjVwMpwOpmgASLKx8aAnTuZZPfsURgfB65do7EDoHDihERJCSvX4WGaYJw9S1BUYaHC/fucf0VToKRkOy0jgxsNt5ubhIkJtkWrqiKgrKNHLZSUCDidrL6uXDHCAK+UFMpTdnZyYxYMqrAGtdPJRcvhiMxNExLYpl4Zx4/LsAyn5l6WlCg0NgqMjJior5fIzbUD4PcyDFbpSUlB9Pdzrs8EwTbywgLfd3k5IhYxNEQQ2cAANZH37JE4cWL1vC4tjdWf2639g1mJCkFetsulMD/PFnJtrYQQBpqbIwpXlZXsBMzPA19+SXpSYaHC+fNB7NnDz5uaoonB7dsGdu9mVRbPTKSiIqLLvLws8PQpTRP27pUwTYWrV224f9/A3Bxw/jw50EePWmhuNtDWJvD4sR1VVexY1NTwvM7M8L1yc+NLPhYWkrdMf+LIz+124PhxC599ZmJ8XKCvT6C8nBvZjAzSiDo6TKSnR3SigUjbODGRoLuVLWSALeSTJ3ndamqY3Lxe4Ntvbejs5FgmOVni4MHVDkra5WplC3l4WIMVZRh1r8PtFqE5L1Hrly4FY9rlphnrzhT7vtzo5ORQF1sD2gCuCz/8YGJhgTiPtLTghu0MExKw4cT9qmMrOi8BWzwRv4ooKwM+/JCVjUbqvsyoqmKL0bIiyOhjxxR6e5m08vNZzd24Qfm9PXuYTIJBJhctyrGR2LkzgnbWO/e33mJbtriYnyUlDRIWFpi4ExP5OVNTrOp8Pj5QLS1MUFIC7e1iVRWmY2GB4iPLy2xh68o5J4cymxMTrJzT0zm/lpILW0YGfz85SRpUdjb/u3s3E9biogiD4dxuhdJSUrKuX6c+8YkTBNRUVrKzUVHBz9aoaKX43bZt46bn4UNSnZTi4vn22+TxfvEFdYlpo2chI4PV+LVrJlwuhdOnI1KRIyNUJdOVPKBNCGLPjcPB2beUuvpimbRvH5CeznPV18dZ5vw8HXbY4rOwvKzw4IFAYSHfZ3mZs8S5OSbjlBS2XeNFbq7Ce++xWnzyxMDnn9tQUiJx7JiF6mpez+iWpMOhwiIZeXkqrMg1N0eJw7w8iYkJA/PzTMhvvWXhn/+ZvsQDA7zHdIs3XtTWWmhpiWweIvxbVvZpaZyd+/3cxNXUEHg2Pc12d2KiwOiogZoafqfvvjPh9VJ17PhxVuIjI3z93BwrzPr6+C1XbkhYsXV0UMykpoa0rJ07yeddWBC4fdvEO+/Qw5czeQu3bpkoKlJx6UBeL1BeHqvytbQkwoIiyckCb71lreLd1tZK3LtHyc79+2Pvn4wMbhSDQbVKsWt5mc9GVpbC4iKFOzQKHmDnhI5datW1ycuTSEnha1Zyzml3SlUzv58dnej3fV3jDVhrC0c8kYGXGSt3ljt3KuzcGfl3dzfnuA4HsLRkoLhY4sYNykSmphKBnJtLGcrZWVbZK4UydETvjoHVspdFRcAHH0h4vaQ9TU1xVjs5yR1/Q4MKCe8LtLYixFfla+fnuYuPrjaePCEgyjAEAgGJjz7iw6s5y/PzPN/ULgYOH2Z7vLY2opKVk8PquaiIi3tfH+lKOTlM3hqB/PAhK2elODt++22FM2cUZmfJw6SGrgUpJQzDiMEdlJYqDA8z8eh5NzmRAk4nwvKMpgn85jcmAgHykauqOPcaHhb4/HMu1hUVEhcuEGk8NQXcu8cMs3+/jLm3Vgo82O0UbxkfB27csId1xc+fD6CgIIiBAeD7721YWqLgxsGDPvT3m1BKoKvLRH+/QGkpqzsg4lpFL1x2QPLz2ZqdnRXIz5cYGTFgWXRn0mAtHWVlNLIYHOR3/fOfSX/avl2ivJyt2uRkon5TUiKcbF3FPaubc/q0RHFxAErFVnVFRZwtz83RXUi/r2kivIlcWOAMuLCQr9PI46wsCrwcPMjN0pMnBnp6OGrQ89J49CSHg+3zwUEB0xQx1SKTGcIGDMvLEfvJpKTI5uTePSZpHR0dRnhjePy4Fd6QZWRQY/r2bRPZ2RLV1XIVDmR6mj8oKZHo7DTQ2BhJ5nQ/UpCSmxgKhvB3+fkKGRkS7e0mGhqsVWCtrCzg4EE6Oa1U+aqpUXC5iPBfiW1JSWG3rrdX4PTp1RKX2kQjPX1tVbOtGFtR3hLY4on4VbSmt2JoDqPfT3Tx8jIfCPIy2TZaWlL49ls6N3V3K/ziF89G364VWVmRzYgG1Jw8qeDxcBFsb2fll5nJZNnYqNDdTSs5KQkaq61lu66/nxSKrKzVrbDk5NjZoWkS/R0daWlEPk9NsdXW28s2udtNw4S9e4kMvXOHcngLCwT9JCUh1PbU32V1Eg4GETaA37VLIS9PQohI1V5ertDYKDE5GbFclJILaVeXCCtdjY5yo7CwwIXI7War124HmpoMtLRoAQoDZ86sz4ecmeE5U4rXtaBAobDQQEaGAyMjAsGgAZfLwuKiQEaGRGGhhZs3bZidNVBaaiE/X4WpLk+eUPpSSip4aW1qza2+fdvE/v1WWPhjpdiHEFycFxcFmpoItnnyxEBDA6UvW1spHHH5MrWWL1ywcPSohUePiD5+9IjdBHow8z2lZPs0IYFCNNH8Vx2ZmVR80rrfOpKSiHQ2TYXWVnLT9f2Tk6OQmakwPm6gpMSCx8NNSFKSwuysAYeDFetawhBJSQQ5jY/b4PHw3BUWWuGRQnEx+cl1dbHIaaVEeIS0siJ++pT3gWUJdHcbqKxkkjZNorq1cUNrqxGmQunQiXJxUYSR4zoIihPYts3CxISBhQUrvMGmqxbn4x6PCPN+dTx+bODhQ1LZSDGLPea1ZrgdHRzb5OZGXMJ0LC0BX39NQFtxscS5c9amSFy+ingD1voLielphNvcL+rDWV2tQnMmhW3b2PYsLaXqVHY2FyGPh1UrQJnDQAAvnIijIz9foayM711VxcXz+nURog4RDGa3E8U5P0/O9NOnrGjv3xfo7eWDmpxMdbHpabbZAwGixKPBZGtFZiaBZABw/ToTLHmLdF5qahL44QcBv5+L1unTBH599hk3ATU1EocPWwDI4R0ZIc94cJDJ5a23WG1EU68AJqa3345dIA2DlVxVFdHR3d0EESUlKWRlSfj9AjU1pEYFAlyIAQ0CUjHJf2UEg8Dly/QqNk0KgTQ2Rlrf5eUKdXUKMzMmdu0SSE93QCmdYFiJuFxBjI1ZyMgQGBmxhxSPyDnWloEDA0bI7zdiprFepKayFerx8Fza7TwPCQnc6KSlKczMiDDH2jQl/vhHG4JBmgQUFqpwhXXrloHHj2mld+aMFT7nUgJdXQa8Xi2fudqwA+B1dzqZMDwegfZ2AwUFFkpKOEP+4gu2q7//nu/z9KmJ3bsllKJCk9vNsUt0gpeS3RwpeW2qqiz09xtwuyWKi4kZuXgxiMVFmkJEX7vGRgudnSJ87IuLEbW6ggKFri4j1NKPvbfm5kRYQnR2dvXNQMlOmolUVKyUopXIzzcwPc0WevR30ewDl4st5GiVK1qKcnPkdhsYGFBxEdnxQvPLdVEQHW63QH8/AW39/QampuSqZ2mrxuLiInI24lzziuNNIt7E6O8nFWp5mWCkI0fW5hIDa3PmbDa+PjpOnmTVmZzMRNXVpTA/TwH79HRNBSEnNykJOHCAf7sSgfysSEmhc5J2fxkf5/eiBF3EBjAvD+jsZFIoKODvOzrYNq6oYBLPzqaq19OnRsiNSOKDD57vga2o4CwYYLI3DCYwgAtgcTGr264ugc5OAZdLoqWF5yo9nTKHT58aaG8XIZs7gnu0nnJDg4xp609NcfGy2znHTEnhIt7QoDA7y8SZlkaDg3PnSNkZGBD49lszhGCWOHBAhmkzv/mNifR0AtF0q9HjYSvS6SRYyuVidZ2dLWMqlpQUKqQFg/raGWhtZbUlBOd6Cws2/P73NlRWWigsDKC/nwnG4aCucnl5RCY0IyM2qURm1ivPOVW6lpYohqH/prhYorJy9WzZZuMM0uOhmpLPx59rrrHDQR1kDfYCCAz85htqOZeXC3zwgRXXIAHgeKW3V4SqeM7E09JUWIYyL0/B7TZw4kQA27dTO/r6dRNtbUzc6ekqXIFKyRZ2Zyc7HC4Xq+qCAtoF0rOb90g8xyHtqlVWRoDTwIBCXV1E4vLePQPz8zSHaGyMdIC2b5dobTUwNSXC9prRQRU1ibq61etCZiZw4UIQCwvsEkWfp5wcqrI9fEjjkejWtGmyrd3bayI1VSE5eePPXiDAjZjDocLqYDrS0giOGx01UFhISc7XJTweDyqj5fW2SGzpRLzVSNfPirExLlJpaUwMhw6tFn4fGaEUJkCE7UapSnY7wUw6aKNH2UshNMCLC4BlcUa6Y4fC119Tp7i4mFrLDgdnrouLBFzFMyHRtnT8HISoNFzEdaJobKTaE12VgAcPBPr7BQYGOIduaKA045Mn/FlBQUTCcXmZCWAjs6X6+ohIgd7IskoElpYU9u/ncSUnE3gyNcUqym4X6OkhDzUjg7xR7S07NsaKRgi2MX/xi0iyuX3bwNOnlEC02RDjIpSSornRBnJyFIQgBW10lG1vpxOhVj2T529+Q0OFsTGe/127aPn4xRcGhodJC6mpkejqMlBVxQR26xYpJnpzIETsBqqjgyCz1FRgednA9LSJ7GyF/n4T+/YF8PHHFrq7gXv3SIOqrJQ4ccKPuTk7PB5aOf7TP5kIBtli1UpaS0sItb+JpicYL3aB5ZzfCs9M9eOZm0vgVmurgYEBA99/b2LfPomGBomSEoXHj42waYjeFGo94ZQUJnCtXRwvDh60wsIdvb0CDx6YyMuTIe61hNvNSjEjAzBNHrPe7FpWZOMGEHjX0UGf3fFxA8ePB0NUM3LQv/zSxOQkOb4XLgRXWSva7bzObrdAYiJxCDo8Hl6b+nq2kGdmZDj5mSbv95QUhc5OA9u3RzoflkVhk95esgKOH7dirrnfT1pVcvLqZ2Zqiq3pujp6RU9MiJjq1DT5/elUFns9abTCG7+6WoZHFT4ff15WRkcvjycWqOVyAe++GwzT2aI7vZbFjezoKAVRNMJ9q8Qb1PRfQOTkMDlpKlS8aqO5WWBwUIT4guKZAiBrRVGRQnk5wVr19XwYdIUAcJGcnGTloalJk5Nc7L/6ygh5AAMXL65P2SopYcU5NEROsk7EhhGhJgFUz8rK4gK9fTtRzZ9+GhGnyMsjMKuzk85JdONhwpGSYCyl+Hkrj2dlJ4kLQbQykUJuroWzZ9klyM8Hbt0y0d7O5KsR0Pn5nNF5vdzxJybGLtimGaGSxQMf2WzAmTMSO3cqBAIK165x0U5NVSgupsnEgQMRt6zUVIXxcS7YQrC74PWylZqfz8ruyBGFffssjIwQsb20hJAJRPyZf1ERMDREcBn1eCkwUVamkJZmIiHBDOluG3C5JObnWaWePu1DS4uJy5ftmJ9nwjx0iBVcWprE3bs2TE+zFX3qVETq0O0WaGsj6re4mPPoeFiXmhqC5Lq7uSl89IjJ5uhRzqSvXTPQ1EQFs/fft1BeLrFtmwg5+FBYY/duuSoBBQK8pxoaqCB2/bqJzExWo0tLBJ15PBbS02Pvm4MHJWZmWBH39AgsLZnweLjByMiQ6O42QhVjRAVvcJDfMzeXrXePR6wyO3A4yFvu6+NmKJo7n5nJ+0DPTvV4BUBIaQvhFjIlNvn7iQmBlhaOO1pbKTepHZSkpDZ5Wxt1qM+ds1BUFHlfm42jCA1miz4HHg+Lg5oaGar0jZCaHOPhw4gz0/x8RMLTbmf3pLOTOunxKmlNjVsZQ0MCt26ZUEphYsJETk7wR6t1bWa8AWv9BURlJZCaSirUWihmpxMhviiQnS3CYu1zc3yoNrpZS08n2pl8UC70x45JuFxsTW/fTvWq7GyCiwoK+Hft7axc09O1DOH6iZhi/ApSxt9Y6KitZVvX6WRbGCACOSGBc8SGBs6bv/qKMzu3m/zEggIKYFy9ys3JkSOscoNBUqbm52n2sFbnIGLaIFFaaoTP5eAgVb58Pp6XXbsUbt408OSJgWCQ1UFpKY/1u+/I72xoYFvZZqNEX06OxNRULKqeOsaUEqXxBnWe33qLc9FoS7wI35odkuvXDeTlKeTnS4yNsXJxu1ntSMnzlZLCY15r5r93r0RuLtu0RUUK27dbIUR0pONQXg5UVwNzcyZ27xZwuRywLOphG4YIXUuJ8XGJykp2LoaGIuC4ffu40C4sEJTz7bcUN6mvZ/t45874c8bUVJ6fhQWCprTIRFKSCjtFTU0Z8Hpph3jmjIXpaW6Wbt404XJF0NRTUzRJWFig2taePWyBFhRI9PRwdKD1o+OxHrKyuCnOzlYYGCA/uq6Oln7HjwfDQj7375vIzWVVnJtLdPP9+yZcLhmXnkSEfvy2tdMJvPeehZkZifT0WKevwkLyk69dM0I+0SrqdWwb9/Vx7hrNXfb5yCN2uUjtmpoSMYk4K4vdiJERAwUFMgZ8RZQ5E2pWlorZGAC8TrqrwaqXQR16or61BsGLxFZsaL5JxC8Qr1trGlhdva2MwkJqLDud3IVOTRHteecOk9bbb0sUFW3ss7Q0oY68vFgUpNNJBLLbzRZSaqrWfQZGR1nhJiay3TkwwGqrrk6FK0K61/C9ngU8q6+PJCK9Az58mApJiYncGABcOAYHaV3nchHs0tSkXWsURkb42u5uge+/J39xdJSo8JUz7ugkPDVFcYK8PLaQS0oUOjqo51xZye+5uKhnfATBnT5NAY8nT6g+9OABTQbefZeygN98YyIxkWAtvRgND1MAJSOD52poiG5TubmrNyoEnUn09Qlcvcp29ugo0cYOh8DQEBW8gkFWfDt3MkHn5Sl8/z2P6dChCDhHKd4zeXkq3EbMycEqygrdk2RUMjdgGAbq65ngR0aA5mYFr9dAamogVLXQlCEjQ4WcrSL8V6eTFdez7Om2bZOw2RSuXCEf9s9/NnHunIWCAhVuIVdXy5gKyTC4YFsWwrNlgMC6/n4DLlcEuZ2QAJw7Z+FPf+Jm8upVG2y24Jo61C5XRGs5KYksBF3dCUELxPFxIzxOolSpRFubAb9f4MYNEx9+GAxvcGZmOF/2egV27LBgWaQ91dTw2GZmODLScrLRIQRBVZWV9Lvu6jLCgjAUpKESmt+vbR95nFTLU2Eeezyf4upqtUq+EuC9fvq0he3bJVJT1aoNS0YGqXNOJ1BVFbvroGMaRyzPswyXlKgQGl2gqkpuqWoYeIOafhOhSE7mTNXvZ8tQCFZ+gQCRlf39sTveHxvUKOb7BYNMeAcOsBouLlaYnCSgyuslDSo9nQny8mXyNOvrFQ4e5HG63RQs0MjplbGSGlFYiBiUrNfLijc/nwt9cbHCV18RZDUxAezYQcGNsTHOnEdGeC58vkirmApkKoQeJjq2q8vE1atMaEeOsPo9fVpixw7yXTXPec8ehaUlcoM15YfzcBUW5ggGmaiePhWw2ahZPTrK2fLUFOVANZiH9B0uZOttVDIyWF1PTLBlmZtLSlFPj4FgkACyhQXgV79iFfbJJ3TiocgF3aQA7WrDVviZMzIsCLO0xA5AcjLC9w5blrHHYbfTPerxY4HOTqKb5+YcyMigWlZnp4HmZgNffsnZ8rvvBrF9O7C4aIOUEomJsZWcjuVlhBHBRUUqVKXyHpuZ4dzz/fcteL00h9DnKiGB3ry3bpno6aFtJEVXJFJSCEDUilHauCIxkfdxRgbpRTMzawtN7N9vIS1NhVXr3G7aP5aWKvT2EvFbUhILcFKKydXp5IgpGIzgJbq7qU3udCr89re2sAuWlq28fNnE4qJAY6O1ip4kBIFm8/NGDA8YQPjZr6xkO31sLLIG6CRot5PXOzkZuz54vaSleb0EF+qWto7ExNXSs/oze3oM5OZGvICjz+PwsMCVK5TzPHhQxrVQjBeGwePYiqGUgtfrRWo8YMxPHG8S8SuOwkLgxAmF0VGF8nK21QoLKZKgFaYAtlfHxthC3izFL5uNlenDh0wsxcUEwBCVq8JzrMFBEXaRevyYFd/8PGfLWpP6zJmNmVMAXKi++46gpupqhRMnWDFMTjLJbd/ORYrykMA//7OBvj4KKZgmcPQoK+U7dygocfSohdRUPuwLC6xovV4Rphft2sVksHJDU1io8Mtfxi5wJSVMarOzApmZEleuGBgf52fb7dyUpKZSE3tqSoQESdiO9vvFqgolGOR1S0hQ4e5IWhrRz9PTBJ5pakp1NeeJfj8NRwCEZUgtS8EwKLU5Pc1k0N7OVuLQkIHhYbZHpQSuXDHQ3s4Z4zvvyGe2EtPS+J1mZwW2bVNITbUjPZ0VXSBgID2dLePlZQtHjljIzQ3gu+8ckNLA/fvk7epN14MHBlpa6Pxz6hRVnKqqJFpb6TKkxT5Wdm90lJUpTE5KDA8TQf3wIavmqiqFQCCIb74x4XYLfPWVDe+9R/BUXZ3EnTusWqemBDwexJ1bJyau3UY/e9bC9DTb3dEtZJo5GLh5kwlvejpSRWu3s8lJA8vLrDAti3P/8XEmycxMbrAOHpQxyVYIbjAePuRxT09HTCgIxCSoTbfTo2NhgRsPv1/EtJABAs+am2nq4PMBv/iF9czulT4ew1AARJieFh29veSGJyVFOhI/h1hcXHzTmn7eeB1b088KIYhm3rEj8rOjRyk5abcT5LS0BHz5pREygaDbUHIygV5+P5W49EKouX4b5Szv26dQVaXCykJ6LtvVxdkiqUgKyckCc3NUv0pIIFq1s5P/HhykuMZKQYi1YniYSSQ9HWhtFSEkNFtyJSVURtq2je99967A48dMdmVlNI6orFT47W/JBdaCHfv3A8PDJi5fJjLa52OiLS/n3HVigu34lZaKK28pLWIBcD46OEgg1dQU0c+FhSok0kEurqbN7NihMDAA3L1roKZGhVvvN24YuHePc/rz5yXKyvjzeN6u+fmc82sjDR1Hj0qkpxsIBHhMLS0Gtm3jAt3RQdCO10u/5dxcbuJSUxFyMHr29XC5VKiC5fnSGIGiIt4Ds7M21NfzHpPSQlKSCukgEzE9NxdEWhq7KI8e0T2qs5PI7+3bJY4cYav2zh0DV68ywcbT5daRlBSR70xPjyDYCcASKC2VGBszMDPDWemePTJkoiDQ1maEJEQjrdn2dgOPHnEuevSoFXOfRtP54gElExPZ6s/L4zxdbzwAzq+5ITORkcHnrqiIymNLS6yie3oM7NxpxcVdaHORrCyJoSHes/rYjh6lg5L+/OiorJS4d4/65CvvIe1LrTetG10ybTbtmMb7obo69vpkZfH59vkECgpeTRL2eBDqRry8z3jTmn4Ta4bDEetf7PFwdpyby3bw/DwrvWvXBIQQ8Hgk3n+fJghPnrB1d+qUwnrm8jporxf77127FHbtivyspAR45x1SF4qLVQgFS4vCqSngr/6K89q2NrZUKyrUurPxlBQufG43F3t9nHY7XZimplh5dndzVu73C4yMKJw/TxtAzcml+5NEYqKA10sU7vg4bRalVPjgA9JFPvvMwOiogdxchYsXLayU+VwrMjJUWE+5rEyiro5zw+lpLphLSxTY2LuXs9xPPyWfd2JCIS/PgstFHnd7uwGPhzP7sjIu4pZFLIDdrkIa32w1d3cT8XzkSKSCys4m0Ku1VaCpie5JXV2cLW/bpjA0RAWvQMDAnj08zsePuYCPjxOVvmNHrN6xVoMyDFJT3G5KeT55ItDQELFavHSJSSUtDRDCgGkaqKgAjhwBbt40MDoKfPMNsHt3EPX1QSQlGRgYMGGarNy1wMXyMgVOEhNVuMpda15YWytht3N2SiQ4IzNTobRUYnCQLWRdKQoBOBzsgBgGnxcdi4s8r4uLwMiIgcLCCM/X5wO+/dYMU8fOnImvCOV0qjBfPbp4MgyqZpWVSczNCezda+HgQRn+29RUhYkJcpr7+mIdi4aH2bmZnaXRR2OjjPlspbgxiDfy8XhYKZsmVdiiN/GZmaRdzc6KcBs+OqanEVapW3n+8/MV8vPjOFeA1yQpiYDPlbryXi/vP5+P3yMecO15o7OTgD2bDXjrLWtVi30zwrIsLC0tvamI38TGIjOTVVpPD7WNCwo4N9VWe5bFdlVTkwh5pApUVSGMVo4Oy2I16/czYW5kt0lxAUDPjHp6uIidOsVqs6FBoa8P+OYbAnh6exU+/pjAjps32Xbbu5dmFQArmyNHJAIBtvuiN6QORwRh7vdzQSot5SbkzBkt2qBw5EgQWVmA00nQ06efGujoECHFIkpf2mzcnPT3GyguZuvV4xEb9kRNT6ce9uwsq09drezZo3DnDgFZ1dUynAA0qM00eX7m51lpzMwQ4ETlM8bt2wbu3xdh8FdKigrpiQs0NQEVFWLV4qNBPKTUSAwPi5BOtwgD6UZGgF//WqK2lovj/fssJxcXgbNnmYDcbuDaNSosHTmiQrNedl5sNv4+OzuinrUyOVGVS2BykuIogYCBxEQbGhp8OH3aQlubwv37Bm7fZov23Xct5OcDqam07/N6Cfr63/63YIxNoQ4CnlbzljU4a3ZWwuWKvXcbGiRGR4GWFgM2Gzc/tbWc/ycmch7MSjHynm436VJZWURe79ol4+IxduyQYe1xbUHZ38/Zrd2OMLgrGqDHe5fz8Pl5dgv09wkGEaa6JSSwXX7ihBVOmv39pGXZbNSoXqlSZbNFRDxWJuqJCb7ntm0ccwQCEVDj3Bxds/TM+cKF4IZZGYaBcDdnZbS1Gbhzx4QQTMqXLsVP5s8TLS2kVPr9Ap2dRowN5GaFJ7RjezMj/guI7m4+WIWFTIwv0l03TeDttxX27aPUIA0IVOhGJb0nIYHIxoEB7toTE/nQ0O8YoVY3k/R33zERNzbS0vB5IzeXyXF8nG3x7GxKXGpBBg1qiTaruHGDVcziIj2CZ2Y4n17PYKO2li3hhQWE1KlIm5JSIi1N4tAhck5bW8nFraxkBXLmjERBgcLnn5sYHmZ7NilJU2EUvvmGIKC9eyPSgXo2vnJuGY8fWVurUFbGdqNe5IqKqJY1NsZE/8MPBubmRNhOUQiqi3V18Xz09tI9aGEBIS1udjDcblYq0cIQOmg5SNnDhw8JnklNZWs2J4fUs4YG3mORaofJYWmJi2RyMlu13d0CdrvA/fsSly5JAPQz7u0FPvnERH09Z/Rr3a9TU/yF06kwMWHgxAkLSUl2pKYCHo/CgwcmcnOtUAs5gNJSCydPBnDjhhMej4m7d03U1spwm9frBe7cMbG4SHCPTj7DwwRtUUyF/OB4esjZ2RwHjIzwebl710BFhQzx0y38/vcmRkcNPHpkIj+fHPLUVG6wurqISI+Wg4yOhAR6QUe+O3D5somZGQLlTpwIoqAg1hs5KYnJ8I9/tEEp8szDVyT0f7XcaV5ebOWrHaYsC3j6lJrX0dHYyOsSCBCtHR1paVwjvF4C0aLn0nNzVAnLzydifX5ePJe61loRza+PR/F6kcjNVRgc5HWPhwzfjFhcXASANxXx88brNiOeniZwZn5eoKOD8nkb0VaOF7pVqCMtjW3c6DhzRmJwkHOz0lJuAr791ghJUbJdPTSEkBsN25aat/w8kZLCSnFuDmFN4PJyzrknJ2lVmJQUMUXXZhWGwZlwSws3Bk+fEki11oaUzlKsjDQqWoae9Gj3JM5+WSnu2CGxfbvCxAQrAPJpBc6dk6itZeXc10cBBacT2LePTlPff0+5wYYGib17eV6JrOX3WNnGWzkPNwyqizU20r95aIjUn2CQFYLdzg3Zn/9sIiFBhfnGmZmspJ8+5UaioQFxZ9k6CgqIsL51y0B6OsKSmB9/bIVR1ToaGyUWF+np63YDv/2ticZGop0NI+LcMzZG6pqUwMOHJrKyuGHYu3dtHrvWvXa5mHBOnZLhOWhenkBZGTA+bkNFBf2WTZNOQLm5CouLEoYhYLMFYVkSQgi0t9vQ1ERRjaUlgoyEYPv7zh0aCrS1GfjX/zoQ8x2jw+nkvTg5SS9djd7WHN7yclL3xsbIs3a5gEOHghgetsPnA27eNJGVFQzfj5bFymx+ntQm7ScdCLDz43KxfZ6dHZuEdaSlsYORmKjw5ImJ7duDSEzk/bR9u8TjxzYAKqaVDvBei+jFr37fpCTS2OJFZaWCwxHE8jLxFtHPdmYmZ/t37vA+iJfgfD7EBWutF9u3U8WLIMPNycQHDshwh+FFecvPCq/Xi4SEBNjWknD7CWPrHdFrHFpOLzFRhRe9lxnZ2YiZz7jdNGJISyNXNxBQGBsjOnliQoQf5kePBLq7WeXu2bO+UIcOpzMWRJGUxKQZLfRRXa1w6lTErKK/n4YR3d2sUk+dknA4WE0HAmyVxwN8RXsIA0zCCwtsiZkmZRkvXLDg9ZJGZJrk09bXE/hVXy9RXR0BIekdvJScJ7a2spWZkkI5vpoaC6mp9Ci+d89AQgKPda3W3MrIyGBlMj8vUFsr0dDA192/z8prYYFo+WPHLCwtkTs8NcXN0aVLFgoKuAjfvWtgeJj85J07Y6ut6mqOA7ZtI9o9XsLMzCQ6u7mZOs4uF6utjz+2YLdTvau3V+CTTwR27FCoqaHIg54vdnZyXh1vpl5crMLJf+UmJTWVnzs3RyCdw2ECMOFwAL/+NfDVVxLT0wLDwwaamyV27AiGOh3cIC0uEqWuJUJHRgxISSlSGnXEX+yrqiT27ePcd2aG/sTvv08v5+Jion0zMmKFLEyTHYr8fH5vr5dVLsAN6w8/mCEKm8BHH5FDnJurUFdn4auvbEhK4vWMFzabCtGriAWIfq6CQSZGl4sV+b59kRZyYaGEEJQf1eIu0a/t76cvshDAgQNWTKISAnHb/QDXAz17BiI0M4DPxIMHBlpbOep56y1rQxgTgBvzU6c2d3FzOPDS5TC1F/FWLPDeJOJNjOzsiIxjaalaU5gjEKCwhtOJDWtNbySKikiPWVqKzItHRjivTEwUKChgpXTzpgjzZfPyiNh+0YheMGy2CA0HIFLaNLno2+1EQHd2Cly+zES8axfnwIEANwceD6utnJyIfaF2Mrp718CDB0bYFebIkVgJQZuNydPr5YKjF53DhyWcTgOJiVwEP/mEEpAeDzdKpaXkqE5MsK0OCExPs0W6XiJWKuJAVVREP2KvN+IDDHDDcP++EXK0Ig1tYgJhuz9t6r60xKRz/z5bc3fuKBQXE2Tm8QDffcfqvbyczlHrKaEBXCiTkijCUV3N1mVjowpXfFpU5dgxSkR2dBhoaqJxRXm5xAcfRJJEeztBesXFKiz2En0OgIhgRryFfO9ewGbjxkApgZYWE9XVPtTWSiwuBnDrlomxMYE//Ung3Lkgjh9X6O4mdcblYpcpEIjPWzdNbkRTUghUm5w04PGQWnX8uIWqKo4iolHIeXkKlZUyBAxS4WoZIBCLM39Wrbrtahh8tjlOULh3z0RFRXDVLL2igglNV9TRYw+Xi5unxcXVLWSvl92aoiLKeC4vR86l2y3wT/9kw+3bJpxOaqz/7/97cM2uUnQoxQ1APCfZ+XluQpUiBaqyUoXn4T/X2KqIaWCLJ+JXtXPRVn3BIK361pKnfFZEEMjr7+yuXhV4/JgUlzNnyJ3t6qIGckXFanTjRqO4GPj4Y0psZmVx0ff7uUO3LIR5nRQhYPtYqxpNTLD9ulGE8UaioIBIUr8f2L+fC+b8PCkRTid9fAEm5x9+4CI4PAx89JGEaRq4dYtC+Nu2cT5ut6tVCkzRIQSrmjt3jJAmME0H8vO5wFy9SrQwpRg5401PV7h8mShrj4eSfi4Xz1VzswjxP1dX7kNDAt9+S4BJQQG1oVfeN7t3K5SXW2GqGMDKfd8+hY4OGmEQJW6gpETBMGjdl5TEuWQwSGBQdzdRs93dAnv2sCINBqmI5vdzFh29MFdWKrz3HufzpaWRjUFenrbQZGJ2OPizqSmFQICuUnNzAouLCDlM0XNaA/IyMqzwxrGvjwj3pCTSvNa7ZzWGweslUColxRHCPUg8fUqBjMFBAyMjCjU1Afyf/6eFq1ftePzYRFOTCdOkTKkO2vDxOubmSpSUUFmtulqG29gOR3ywUUICsQNtbeSk379PhHxGBlvZJSVU1MrL4zHp5KR50BMTBhIS4m+GbDa6k8ULUgaDWF5mIo5e2vRG4OFDouCj77WlpYgLUjDIf290LpuUxGdldJQUrOh7RGNMBgd5HuO1xH9uoRPxm4r4BUIIEW5Rvqx4/DjWqu/SpZf3eayGuYDNzoowSOPLL4mEraoCPvhgff3n9SKasiIEK+60NCaStDQm6JMnFfr6WLEXFnIT0tREZaYzZyRKSuhSMzpKINKLVu01NaxCAwGEZ+WVlQoDA6Qi6Q2LZZG7bLMp+P0KAAUqbt4USE0VuHePbd1gkNconrm8jrY2tjunptjSi27bZWXRIi8Q4KzaZmPrtq/PQFkZ5f6OHWPrt7OTbWoiQ2XYhamjg612Loqs2paWuOHRaOro879yYyMEObX79rHKb28XSEoSGBlhRe92szPwzTcm7HaKV6Sm0oQgL4+Wi3NznClevsw26uioxPnzMuYzoqkzABfvtDS2wn0+ETPjLCkhGnx0lJvBP/2Jnr7a8UiLRWiVK8MA7twRGB8nEjsnZ+0ZJsCZ35kzMmRMIDE7y9ekpRkoKKAfc16eRF6eHaYZhMslkZZmwekUME1KbmqsQDBo4PJlEwMDfIbee48KZx4PxTlaWgwMD5NtoHWrV0ZCAkKa3gQv6WctMZHAxKIiznmbm8lvB9gGLywUGB42MT/PzVH0+/v9QF+fAcNQqKhY/fwKEd/RCtBOZCpsSqJ1yAFW8Lm5Ei0tNqSnS7z1loyZmSvFZzV6s6djcpKV9sGDFvx+AuQ0Tone21YYY7ISsT85SS34lBTOhLfgWPW5401FvMWDLSYVI2f3ssJuZ4XV1ERN2oICirn7fHyQ5ueppvSiiTg6cnNpRtDXR1lNrdBVU6NQU8P/HwgQ7ZyYyIdvfJxCGF99RUGRzEyBixcpy9jbixBvV2Gjlp4rVcHy81m1WxZ37EopVFRY2LWLtJ89exTa2w18+y3BOhTpIP9YJ4aVUprRUVTESs7pXK1QtH27QmoqNZi9XoQkCakaNjPD86L5nU1NIuTGxGrc52Pyu37dCNnd0ZNVSi7St26x2m5slDHz3bVCCFbdiYlsRRK4xYX6N78hMG1hgd2M995j8mprY/vY6SS4S2tJDw3RPjElhe3jlYvm8jJBhKOjTFDHjsVWdKmpBOM9eCBw9aqJhQXOt//qrywcOSJDKHWBH34wMDqqcOoUBWb8fib46Wmev7W6KYbBUcmjR3QSMgzypGtrFc6dkxgfpxdwVpYBgP3cmhqF/n4mA59PoblZob7ewtKSgMdjIjmZFbb2QE5MpDLVP/+zDU4nleuys2VclH5RkcLJk0SNl5fH8q3T0lSIuhS7WdE+xBUVEn4/rUVrayOv4+iEc9zjx60YENPyMpHrgQCr8ZVtZaWYGDUlLrruYCcIOHs2CJ8vMs/W8eiRgXv3jBAtLpb6lJVFbeqZGRHiBcd+rv79yggG2Qnp76e5hsOBNTc1r1N4PJ4tiZgG3iRiAGzTkayPMNDmZcbBg1S3SkhAWEKxpgYhkQC15mZgcRFRgJhnf44QTD7bt6/9N3Y7W3jNzZTny85m4pme5lxsepqbA8OgS9HMjAjpUUe0juOFthWMF/r7aVBWQgJBXobBmdU//IOBpCQuhIWF1I0eHha4ds2AlJwP791LROjAAGUnS0rY0j90iNxQu321xGU0sKW5mXPq1FTOCN9914o5r42NCvPzMuzj+tvfmlhaIiArIYFV4oEDdMqZmhK4dYuWcffu0ThiI897XZ2Cw8FRQnQFW1kJ3L2rwv7HxcVMvA8eEGA2NydQW2uhooJAp4UFgevXEXKNslBXx/eamGC7c2aGc968PFK/6uqwCqVtmgjRqAhGkpIbtJoaIuI//ZSt3K4ugV272I7OygLu3RNobeUm5Px5K3xPUMuYYCEie0nhkpLt9IEBgdpazk0rK1c/c2VlAkeOCExPGwAUPv3UhBB+NDQEsWuXH5cv20Ka5EwmKSk01mhrY6tbSrnmCMMwWOXp50JLTQKc6zudKizcER0VFQqtrSampgh0jAZVud2s3jXgKjpaWqgwxupV4OzZWKBTdrbC0aMS3d1sW2u0NsBnJTmZ3SntbqVDKaC1lc/ExATtVaMTcUGB7hYgxhnsWWFZHF1RREesSfN63WJxcRFJG0WkveJ4k4jByuzgwVc3IzGMWJcmlwu4dEkhGFRrJtiFBRrKj4+z1ffOO6yaBwb4+9LStRPfs+LYMRV2KMrJ4YNYW8tFl4IiCrOz3NmnpdGEwefj383Ps6LSVZhSXJyfPiXA59ix+N8pmp4UTU0SgsmnuZkiBKdOUTv5q68MBIOsUgcHuWEZHBT48ksDCwtUZLp0iSCjxESF3l7SeNbyha6qUhgbk5iZ4cx25Xy3qEjhV7/iPfH55+R5SsnNSm4ukbhPnhAJTPoHZ69FRbT/m5yMGCCsFYaBuM5B+/ZJFBVxYdcdBYeDIhaPHhnIzlYYHhaw2fi3Dx4Q1La0xOuh+cO3btGLd25OhDislCtcqztXVaVw5oyFJ08EenoEvv7axOioxO7dBMa53ZSb5MyXwLpHj8yQiw/HLLoL0dRk4MYNnviDB9naLytTGBlR8HjIb+3u5v21VqSlMRE9fGjC5wOuX09AXp6JvXtliBcNuN0Gnj61UFUVRDBooKEhiPv3TUxNkQZ17pwV8321Xnh+PrEL16/TMGH/fhluKfOarD6uigqJ1FTSr4aHDQwMRHS9t2+XaGqyw+2mGE70RnR5mRsSy8Iq6pKO6I1BdCQlsYU8NMQNcPTmUgg+jw8e0CUs3nVl1bvmKY4bCQlsZzc1mcjIkDFqZ69zbFULROA1SMSvYka8FYJzorV/PzkJDA6ytdvfLzAzQwu+GzeYwI4epQDIi4TNRllLHabJOfLevayGhNAiIawId+zgw/3NNwJ9fUyYZ88ykQ8NAd9+y9nS9DSRxyvb2NH2hdFJWMfRo3SRSUhAeHZVXq4wOMhWsE5eHg+BLORhssXLljP9hR0OAadTxq24UlKAd9+VMdXQytALaWYm0NXFv2toUDh4kBX6vXvklE5M0DM3OZlSm19/TYDTzp0Sp09zEVteZoVoGEx48VDAOgwDq9SVAGDvXoVt2yw0NRlhQFpLi8TBg2wrBwICjx4ZaGsjuEm3OVNSiMjNz1eor49PfdKfS4MPgf5+tr0nJ6nmdf68hbk5dg90VeZy8bq0t3MTcPcuE05tLdG9+j0nJngcBIhJfP21gZERgcuXDaSkWGuamhQW8lwPDtLQ3rIElpYMmKZAXh4Bdg6HREYGwVV1dRYeP2aHZ+dOC729JsbHFSoreYHHxwW+/NLE7Cwt+rKzFZ4+NZCQoHD3rgmlOD8vKZFrdjRSUwGfj+3eaEvI1FRyiHNzFYaHDYyPR0RKamosfP+9EXITE2EfZR0alJecHP/a5OWpuKImQMRQwzDUqg6A1wvcv0/RlN27ZVxt7bWC46vghv/+dYg3rem/sJiaWi3I8WMjM5NJWFfEaWnA/fuRedL4+OZ9FoCQwQH//61bAnfvipAOLGeZIyPUh01PJ+JbK25dvmzgyRMmnH37VNinVZswZGTIuJVwdKzU3gY4V8/KsqBUxAi+pIRG7tPT3Bx0dFCVqa1NoKSEFYgW+VcKcYUhVn78wgIrycVFHn9xscK+fURXCxE5rvR0gmuGh2nIvn8/F++7d8l5drlIgdKV0Z07lJ80DODECSssIjI9TcOExEQmyfUStBBc8F0uVvkaV7Btm0J1NdHfjx+TAvXkicDRo6Ruud2cv8/NCaSlyZjZ59gYKTX0yebPyssl+vooDNPYyPZ8bu5qEQubjcj0tDTOlmdnDdy8qVBYaGH7doXJScq0BoMCX31l4ORJGQLMsdKbn2erdq0kIwRZDEpZaG8XyMmJSFIePizDHPLqagM2mwPnzrF6v3LFQEuLDVIqDA1JFBZaME0Bt9uGyUkm7bExdjcoTyqwsKDw1Vc2LC8D1dUC77+/2sVIi5k8fmyDadJGsLraCm+itaNVenpsJ0RKPielpbxXx8cjIEIpOTfv6KCD1ZkzweeqYAMBVveBwGo2wdOnnB+bJsdaH39srbnpjI6FBeDBA1og7tmzOVrSWyHegLX+gqKlReDmTSaiU6ciess/NrQO8swM28dsDXIhBRBGd8aL5WUmpRe9BwcGmISXlwXcbj6ULhcT4vAwF+nUVOD2bVJaqqvJYd23jwjPP/3JwNAQF/Lz5ylbuFYSXi9WLlCpqcDFi1RUUopKUgBnuFIq7N5NutMnn5iQklXitm08fq+XySkrK1bDuKODzj02G+D3S/zyl0wc9fWxi1FyMrWcOzsVSktVuIIqKlLIzSU3OCtL4Q9/YOU6O8vEFQxysV5c5Pteu0aPW8Ogu9FGgF719QpCWPD7BWpqtPIYBSNsNl7r3FzeJ2fPamtHAnq6ugiIA9ji/+orAp7q6iTOnWPSzcvjDHh4WDxzEbbb+VmJiSo8OjAMbS9pYX7ehM0m0NYmUFlJbMS+fQo3bzIJ37hhQIjIdQEIApua4j2WnKw9piOAJoDV+ko8h81moKAAOHWKoiA+n0JLiwMlJUEUFweRnR1ETo7Agwcm0tKIJ3j7bT4ffj8VqJKT2YL3+1erqQHczBUXk68/OkqqFx2VaAM5MUFsQ/R5Y6Wr8OiRgcxM0vB0eDycnaekcNwwMUGK10Zj/34CHxMSEDa30CFERA/9eZSznjyJbBp9PuDixY2Ld0jJDVZycnzu908Zi4uLKHhRbupLji2fiLci52u9aG/nQx0IUMUo3gzM6+UimJSkUFKycesy6iBH/l1drcJVSjTyMzpGRoiY9fkoNrJ9O9u7U1Pcxa8lHxgdtbUKt29zp6938rq1q3WTtUOTx0OwyrvvSuzdy2p4chLIybHCyl/kwYpNeVBNkw89gVdE2paVkUerZ8tzc0wQ7e3kJOt5+9gY9bDfe4/cTctiZ2F2llWn3b72tbEsArM6O8mxfecdclELCxU++oh0katXDQwOGggGKZqSkaHCs+R//EcTOTmcvSckINRWF5ieJo95LbrI1BSrboBgsViJS4XUVAtSxoK/CgoUOjp4jWZnBT7/3MCuXSqEdub1GxuLCEnMz2uUNR2s9u2TGBkRSEtjhbTyupWWkpPtdnMTpjd8Wrd7ZIRoX6eTCeHAAYm5OQMtLQSbtbaKcCIOBCjT2tNDqtR77xHVrDE2U1McR1DKNP45cjrZjVpeNmBZBgxDwOEwkJfHrkN/v0JKisK9ewIff7yM5GQDc3O8lg8fmigs5PlYKbW4tMR7LDdXYW6Om5do7E9FhVpFGwP4bKana0cnhYEBI8xtT0riObp+3YaUFBWTpDcSJSUUf4l3n27fzk3q0hLHJCv/ZnAwIkizkgeu//Z5ll8paW7R2ckN3JkzGwMtvqp4MyP+C4qSElaJ5AWu/r2UwHffCXR0CKSkCLzzjgw5Hb1YrJWAdfT0kHqSmKjw6JHA9u1cgB48IGVJ84bXi8ZGtmg1slZHZibC6lYDA1xkd+/mw3/6tAwZqStUVVno7SU6Ni1N4OuvqZzU0CCxZ09EVETzHJ9n967DbgfefltiYICJTIs55OQwCUkpwoCs6WmBkREuzMPDAjMzFB9pbhbo7KQNY2bm+iYI8/MUtUhNZfU1Pq7CLk+anqKNBQxDICNDhivWO3cI8OrsNLB7t8TEBHmafX3Ao0cmysuJFNcJz+MBFhaYMB8+NNDayoOy2YywwxKAKKBRbNTWKqSlWXj8WKC52YTXK7CwIHHypERhIdulwSDwhz8Y2LuX3G/dMp6cFPjqKwGAFVJqasR7OfpzyQnnz5XitXQ6eX8NDzPZRAONcnJ4LsbH6fvb2UmE9twcMRDp6cDwsIGJCR4PwO6PnvFu2ybxzjvxhTW021dbG81XKGrCmyozUyAz00QwqJCQYMFmM6CUQmpqEEVFNE1xOul1HJ2IBwfZfpcS2LnTQk4OwpxqgO3cQIAbgHj3jN3OSpr3eeQPbDbeLykpCg4HRx3V1ZEK1OsFbt824fFwExRPznKte9TpJN4iXgwNCXz1FTnRZWUCFy9a4Xb6jh10SvP71xYoiRezs+woJSQQLDk6Kl+6bOXzxJtE/BcU+/YRWB1YjJwAAHQuSURBVGEYiCsd6fOR6uBykYq0sEB1KaW4445uv21GZGRwU+D3szUsJStDwyAQZ2RErKlVq0OI1W3hlVFUxHnewIAI6SETlGUYFk6dkti/34DLRTRuaytpOE1NXHQcDso4joywffnWWzLcYp2eZnLeiH1j9MZAx65dnEvTXpG/y8pSKCykc1JJCSu2GzcEBgaMcFu1oEAhM3Pttl5KCivN7m6imFd+LsBkkJEBBAJEoD9+bCIlRUEIhakpqmXV1qqQwIrAH/5ghtyBBBobiQmYnQW+/JL0IA3ykpIrr9/PDkBOzrO9qPPzCZrid+HmJzsb+PBDiaYmgVu3qNd85w41pevqqOS1vAz09ZlwOnn+onGTCwvsqkRXpqyKDHR1MZG//bZEXt7qxXzHDoVg0MLXX3NjcOWKAZeLsp4FBQqtrUZYFzwnh5iIqSmirXNyeM0WF7GKk6uDtL3IHFaLsGgO8eysQE2NgMuVACkllFLhJDowQJCf1+tHQoIBwzDQ3m4PU5QGBw2kp1O+NCeHlfmVK0R2798v4yavXbuodGazrRaksdki9+1KffrOTvpu2+1cO4qKVs+uXyS4GWOXa2aGYDudiFNSiGN43khOBjIzJQYGjBDF8ccf52bGm0T8I+J1a02bJsUz1go923r0iI41xcVMjtevsyrIz1d4++34ZggvEtu3q5AJBXf4hsEFtamJQv/rzQCjtYSfFabJRHzokF78IqAsh8NAVhYVowyDYhtzc0yCDgfdgDo7KdD/9KlAfT3njt9/T8/h7GwKP2ykjb4y4rm5pKTQpGB2VkAI2if6/TSmSEkhrzM7m/Nd7eEbLZeoF60zZyR27GDFFk9kxOUidWdykgpeWVn83idOSNhskaQDICRowQo0I0OiqYmblZQUhZERtoj7+wXefZdm9h4Pq7fOThNlZZH2+npBqVCJhQXaWeq2fm4uk+nSEr93QgI7GoWFnCHX1ir09FDuUY9aHj4UaGoykJTEZKvpeNPT7CxwFGCgrk7FHc+YJpNieroCIDA5KTA8zPnquXNU4errYyJyuYi3oACORGsrFawePzZw6NDqqnjl5qmtjQjtYJDodiLZI8ekq+W9e4GWFm5IZmeBp0/taGwMIhgMIjVVYWHBgakpAzabwsSEibk5qlIVFPC6paQQha1tC6OjuFjhl78k2HDl8e7ebYUT8O7dsQnQNBHSTxfPTUNaL4qKJKqquLFpaJCbkjQTEoAzZyyMjVGgZS0Q3k8VbxLxm4iJAweogKRN2N1uolwdDlartbVq00BepMsA0QvP0aNMLAkJWFNXu7+fZvZOp8Lx4xFHHr+fO/i1duVKqTA9iZ9PUNbjx5SMdDoVdu+WcDgEiouZPFJTuSBr71SKVrCKSU4GBgaM8MO9VszPk8KUna02VD0nJxNEs7DAtuHCAjsGp06ROtXSwjmlw0EP37IyFeJIszWcmcn2sU7ywSDCwJ2V5yYriwCr7m7OFevrV2+0MjNJEZqeFmhp4dxUKTpJ5eZSSzk1VaGpyQghcBWePjXD7fXZ2WcbiCQmIizVGR2VlQQaeTzkY+uWuK5E3W6KWyQnc+aflUWRimCQIhJDQypsrLC8zOs2Osp5cVLS2tcsN5fz4q+/NjA7S1EUp5O2lvn55CZHR3Y2W60jI5QFvX8fKCmJdHQWFyN64rt2cZMEcC6uJUg1uDFe0P5Sobyc+t8+nwMOhwEpJRoaJG7d4iZmdJRdjYICzl9TUhT8foGWFgO7djGpxpvxd3cTKJaRoXDsWITfnJUFvPNO/Ao0LY2Kf7r1vdJDe2KCkphZWWqVgM16kZLC+215mc/CZtU7xAVsTd7xG9T0m4gJIWJnu0lJ/PfICOdbycl84B494gJbW7u2k9OLhN0OlJev/zd371ISMRAgbeTwYYWWFs6W09IUTp9e3XpaaV8ohIAQNHN49MiA309no6oqYO/eyMOalQW8+66FqSmCetxuLm65uazEiGxWuHaNIh27dsVq487OAp99ZsDtNlBeLvHuu3LDUqWpqcDJkxK9vWx5agGQpCTOFX2+SPvT4yEqXkoRFjupr6d703ffkbtcVbXaIYmUJYn9+1ePHgIBLtq6VZydzYStF8aUFCbPmRmF69cF+vsN9PQAR45YKC6WGB8nSvzbbw3k5BAZHr3WSBlBz64V1O9eLWKRnQ2cO0dbxeZmgYcPBcbGaHBBDi5b162tBhITJerqVEjUA8jJkUhKEut2MTTFra9PYWKC99rICHEM+/ZpepvCnj2Re0XrpU9MkHY1NMQRkBCc2be2GqEZr4HKSlr7VVYqPHnCzW5xsYHOTrXm7HLvXoUbN6hJXlvLYzAMWmNmZRlwOBSWlgQKCmgJWVcXxI4dQTQ1JcLl4v3Z2yti3n90lM5ad++ayMqSGB2ldOt6muk6lpd5DvPzJXw+aoHrRLywQAvI0VFuDC9etJ6LamSzYUuBqV5mUKrWi9SN2Fb9BLHlE/Hr1pp+kUhK4oIXbbLQ0SFw9SoNDMbGFH75y40nl805Js6VNUfS5yOARVsGlpcjxmUqWqRDCBFu9wFaSUyFReg1+CY6tDnFZ58RaZyfTzCRbv2OjdFVyTSBhQWJX/2KCfP+fQO3bgn09RnYu5fV0vw8k8hGb52yMrXKqaehQcFm42KrF1U61rBFnJLCNvPVq5yvdXaSB9reLrBjR6xyGhCxCoycLx57WxtnqW+9FWkt799Pf1qbTWHnTiJaXS6F+/cFpFQQQoTb6263CEmPGhgbo/iDvi79/QK3bjFRnzgRq7ssJeK2SVdGURElTzs6mOB8Pm4eTp5kMv7+ewLvvv+evsEZGeS1TkxQP/3uXXrvrrfg19QoTE1xTKHn+BkZBN+tjIwM6lT/0z9xY/fgAcU+qqvZ4bHbqbjGmTLPeUGBQn29gNvNf9+/zw1TvK5ORQVRyNqlTAe7CQoPHwpkZgLHjtGFSUpgcdFEWprCwgKvx9xcEMGgBohRYWxgwMDQkIDXS4ORjUjUAkBWlsT8vInHj21oaLBWODORG65HHl4v1pWd3arh9RIv4vNRq/1l8ZbfSFy+iWeGRmHqoCMRF5ZAIL71md9PsY2JCQpqaA/izYhjxxRycpiEt2/nPDEtjclUCzLoeJZSFsBEUFrKxXItn9/ZWc6L8/JUyNknMl8cH9eC+AQaTU/TNYtmB6wOBgaI8J6bE7hyJWLR9yKzZYcDqzi9ei48OBjZBExPCwQCRABPTVFCklxknrd4Cln6uzY1sf3c2ipQURGp0nJygPfeW33B6+slkpMJDtu2jeeyqEghNVVhagoAaA8oBJPb3bvkpfr9Crm5RhhBOzXFFu7SEuf68ZTHoqO0lNXb+DhpMLoTUlGh0NQUEU4JBvm3Fy5IfP65gYkJtvLt9gh6V0pet6EhAvO2b1fYuVMhP9+CaT4bFAgQTFdYyKS8sCDCspEVFQqNjeT3Li1Re/rDD9khSE/nyKK/H1DKwMLC2vfFWrS6bdt4jSK3twHTpH1kbS2lOAGFoSETDQ1+mCYTtZQJmJ/nPHn7donDhyWqqjbWvvX5mPiLiwNYXKQvte4GZWUpNDRI9PQIbN8eq1ENIKxB7XDExzBslWhrM3D7Ns1AvF7g0qXnB4ptJN5UxG/iuaOyUmH/fs6PGxvjo4b7+wXu3+dsmXxAtWblsZ6UY7xIS+MsOzpOnaITUlISwglyZRIeGTHw9CnRmI2NEaUopxNhM4K1IiuLwKq+PsoMRm9MamoUPB7O6GpqFH74wcCTJ5zjVlZy7vzWW6yM/vhHI2zRl5fHCnOzIiODfODpaeDWLX4vu13g4EErvCG4dcuEUgqTk8Avf8lzMDdHAwalSEPhZiaWY7tWKEXXp7Y2jgUOHox0R0yTFWJBgYH+flbmXV3AzAxdfvr6AIBz3IcPiWjv7DTQ3S2QkCBw7x41lte7NxITKQwSDMa21bOyKIrR3k4lMz2jLCjgjFdXaX19AjU13GCMjNC8AxAYHVXIzaXZRm4u5/z/63+Z6OkROHJE4uzZ1ZxlgBuixkYC2rKyVLiKJlOBBhkpKdS01jNQosAlxsZMzM1xzHHhQqxDUlsbxw51dWvrca91nlwugfJyAqrm5x1QSsBm45imrMzCjRsmpJRwuQKoqZGhzSpPptbpzsuTqxJmSgrn72NjBvLzVYz7kmnS6Wnfvvhsi9u3DTQ3m0hKUjh92nomO+Kniui1aaNey88bgUAAPp/vDVjrReMvoTUdLxISKCe5XhiGgs0m4POJsOxhvGhvZ8LOzFQ4cWJtreFnRXo6ze4BbdoQC8ry+wW+/55VGG3+LNTWEkz05AkpWzoJxQuHgy366WluBKKTU0ICZQ0BVpOzswZKSlTIw1nh8GEmYaUihuhUeeJs2+8XqKxc38D+eSIjg0motZVJaM8eJtwnT0TIw5fylhp5/uCBEU7ESrHteuaMREsLOZ3d3RxLxLs2i4tUxHI4gKEhWhFG29exmyLh87E9bZqcne7bp5Cezvl3f7+BwUFgepqtP5vNCAt8cJ66OglEx+iowLVrfBaPHydSWAh2IBobV9+nBw5IBAIG7t9nIv7iCxMXLljheXUgwM/u7eXmwmajtOiXXxqwLHZ5tm2Lj7gGOBapqbFChht8P+24tX07qWkNDRGQoc1GT+ycHHaYBgZIZ9KgKm1SoRQ3BFojHOC91NZGqc54NoaAdskiEr++XiElxYAQfCCTk4HSUgGXy8L8vAGvNxC+ztPTJj7/3I6ZGQPFxQYuXgzGdJtcLuCdd4Jwu9kJWVnFrxx56LAsSnAmJKiwvelWTcTbt0ssLnKU8Ty85ecJT6ht8qYifhObHhUVNGeYnuaCFe+B9PkoPbmwgJDo/OqW6/NGtHMSEAFlKUWOq2lyIZCSC+TVqwT5KMUZ63pWkw7Hs9G/aWmc4T59Sj3l06cjFYwQBCxRBpSJ+dtvTQQCFFq5eJHUkpERtkczM3nunne/JwTP48pzWVWlsH8/pUhpchBz5gAgzI9NTeX/n5mhixBN3FcvRDSsV+E59Foa5nV1EpOT1JYeHxf4+msmo4ICaoPbbGzjvvUW598dHQJdXQauXBEYHAQ++CACMuvv5+Kdl8f5+aNHpBcBwKNHWNUGXRk5OdyoDA+bcLlUyPVIoLSUQinffkszgps3TRgGtbdtNm6e5ueZIOfm1r8GSUkcWVy9yvni0aOs7s+do+f0yjlsdTXNMR4+NBAIKNy7Z4Q3d0tLvK8XFgSGh2Nf9/ixgR9+oN3gzAw3iysjKwu4dIlc4czM2Mq5uJiUxrk5W3hzICW7SAsLHLM4HFYI3yBD1W1kVy0lkdELC6yQN4IVIY1Sy2quT1P8qSMlBTh58uW0o3UsLi4CwBvU9JvY/DAMxK1GokMILvaDg+RoOhycLT95wh1obe3aC3u8WA+UlZjIJPj4MedaevaoW0+6GvyxIQSr48ZGfuZKwFFCAsX509MRWnRZXXs8CIFriDKemKAfcVISnXL8fuDpUxHWcH6R2XJiIufhK2P3bgkpeSyTk8AXX5iruhjT07wuubkqBuxlmqyg6+qoWbzWRqWgAPjFLyjQceUK339gQODMGQtTU0w+e/eycm9oIC2mp4fnZmyMYitlZQrz80SBT09zo/LBB2y7S8l7ZmSEc97a2vVBR1lZVPrq66PbkRa6aWxU6O2VsNsNWBZC/r3aaYnc5cxMinpUVVnh6yAlK1mfj7Nop5MgssFBAZuNiH7dZo93XBkZpJF5PApOp0B7u8Lhw/zdjh0Sd+/aMDxMalRHR0R20+ejdrnXKzAysvb3TUqKX51mZjJJ00YUEIKzZQAoLpaQ0sT9+wKlpRYsy0IwqFvtBpQy8OWXdgwNUStct+U3EocPW6ioYAdqKyfiVxFerxdOpxPmi3rFvuR4k4h/5tHVxZ20zxdZGB8/FvjuO87DJiclLl3a2EO6EVBWPL3d48cVWlqY2OJJMAJMQvRcjSBn1wsh4ptYjI0xiSwuCuzerVBdLTEywtntgQMEnfn9rIBcLiKetWtNa6vA5csmLIv0mPff39zZ8pkzEvPzNKdIT6eM5KFDFrxegWCQtpZPnnAWeOmSFQZFjY4yWeXnPxt0Y7OxPZuXx4RaX0+Vs6IiuQolXVmpUFcn0dfHavWzz0xs3y7R0EBKVno6gV1dXWzJpqQo3LplYHxc4JtvTASDVthAIl7Y7ZHvnJISC4JqaFCYneX10CC1lJTI36el0VJzdFSE+eOdnQLffssRSEMDTSpSUiI0s+VltrpLS9WaaPDiYoXbt+mZXV5uoLubHZGcHLojuVwGlpbYDdCJuK5O4ocfbBgYEEhOpvVntEiMlNzI2GycT8eLxMT4JhJCGMjOFjhyBPB4TMzOJqKgIBBW+2puVrh2jZrc5eUKweDG78neXoG2NiPEB1/f2evnHh6PB8nJyVt21LnlE/GrOnHz8+SIak7lFu1gPHe43WxJbtumwtWjz8fK1OEgF1MphbExzuwKClTcOepGkvBaUVKi1p1PLS8DX39tYGjIgMul8P77tLtbXORikpDApLERab+REQLG0tOBtjZg1y66VkkZ6y+8b5/E48esvDQozOfjfDchgejNkRGCfYqK4rcDR0e5AGdnY8Pzt9RUJke6EcmQUQMpN93drIZnZ2ls4HIpTExQX5loWYlLlyJGA5OTRGrn5sYm6IICIk+XlsiN1pfK749NxKmp3Gw8fMgNiMtFxPGxY9QAb2nhebh+3cTwsMT770t0dVG8YmmJesKlpda6SGfTjG8HWl2tUFBgrZpx5uYSEX79uon5eYUbNwwkJ1NjeX6eG6eEBIpjvPUWn9WEBAtNTRx//OlPJo4di9hMroyKClpnLi0R7fzkScSYZds2hbt3ef9H89TT0ngPZGfzepC+F/n9vXsG7t3jDP/UKbnmZjNeJCayzd/ZyRlwVpaAPZQxpZTo6TFQXq7Q1aWQkRFERYU/RCs0wv+LFx4P2/4eD9Dfz2T8PMf1c4utLOYBvAaJGEBo/vhyb6LbtylaoBTnm0eP/jxuWqKQ2XbVVn51dUT0Li5yjjc+Dnz+uYHpaaCsTODSpQinVStlPctD+MfE8jJpKBkZEaQtwNlfa6sRMnSwVlkRxou0NCY2r5dtVi2WEZ2AhCC1qL+fiefbbw28+67Etm08F0tLnFP/+c+srOvrieAVgslsZISUpVu3TIyPk8d54YK1ZjUUHbqtvmMHF2FdpeTlkX42OMiWr94ceDwirBg2MyPQ00PQEcD29uSkQGEhE3T0OpOejpB8JDde339PgZZt2xQOHZLhTY0QTDL5+ZSV3LGDWIOjRyVycwX+9CcTubnkcc/NAfv3K1y/TopWRwewsGDinXdiqTPT09zUaL/gtSLeuuhwsA0/OEgO/cwMZ9MlJQqlpRJZWbToS0tj5+PsWRlWLZue5rXr7RVhM5F4UVamMDjIzWg073bPHoWiIgLAojc2NhsT+O9+x8TW2Wlh9+5I+7unhwC5qSl6UD9Pwltv7GAYBkpLDUxNGTh4UOHkSQGXyww/k8FgMDTuEbDbjZhRkRAIuT1RV/55HtmZGVpCBgLELKz0oX4dQyfiNxXxFg/uMpmIA4HX/8bTUVrKuWEwGHFOSksDLl5UYU5uZycVvLKzuYguLjJJrARlKWWgr88IGyisZdX3vKHBV7QplGH97akpOkQtLpKKslL5KV5UVipcvCixtMSqZq3nbmpKYGiIGs4DA6SPFBYqXLrEFm5zs8DcnIGMDLZH3W5u0B4/NtDWRmvDpSW+ZmFBYGqK1XNm5toUMh1CrDYrcDhIEfJ6maB0oiwoYHt9bIwo7O+/N5GSwupteprJbmpKoLeX1zqeZvDwMFuUqakcS9TUxCagvDwCtZaWIkIodBJSKCmRYUtAbSCSmanwj/9Ij+qJCW4OcnKYsAYHubHxeomwP3Ys0krV9ptO5/qKTnY7sQtNTaR26flmXh6tPMfHqazW18fkm5fHzWVXFytly6Kk6kr8RAivs6ZdpBB8r3hRWcnNSno6MD1Nty3dBSkrA/6//49AuKKiWDS2Dp+P1zje/eh0Yk10+MGDxC8QES4ghCN0LiXm5y388IOJ6Wlg9+4gamuDAJjAnU4DJ05Y6O6mhvtKvfX14skTE0+eGOEEfuHCywVSvYp4UxG/JrFvH+cvNtuPRxVvtVhr0dOLQmGhQmUlNYVra9maWylXaRgGmpsFrl83oJTAoUMyLsL3RUKIiPl7QkKket2zR+LuXXJFKyrif5Z2s0pNpeSmrvCeFRkZCnl5lBssLpbhOaSm1xQW0qHJ4yFy+PPPTczP07GqtFSFxDtUSMubMpDj4waKiiTOn1+bh7pe0GYw9mdOJ32fFxaATz81EQgIuN3UIuf8m7Sa77834XIxmUdXp7OzBBolJ6vQZkPG5SynpkY+e3QU+OEHA4GAwN69EseOkdoU7c5TWcmk7naTrzo/r3DmDP2p3W5WlE+fCuzZE2k937pl4PFjqpKdPSvXTHoA74eyMvrzRuuh5+WRJjQxYaC0NAKoq6mh6MjysoGMDIFHjwzs3Bnx6e3u5r0rBHnXNTXcgH32mYHUVI4q1jOzT00lX1l7NKekRM5xUZFCbq5ETQ2R3pOTInwNpOT37uzkpu3kSblhVS2AxxPP49gwDAwOmujqMpGYKNHcbKKy0geHI2K2UlAQRFGREWY1aN7ys8I0uYHVY5qfQ3g8ni3LIQZek0T8KlrT+fnAhx/+vBLwRiM5GbhwQWFxUSE1FRBi9TzY46ECjs/Hme34+PrvOT4OWBYBRhu1bVuJON2+XaG83ILNFn+BDAbZnuzqYnv43XcjMo5TU6tbj9FB0XuJ6Wlyclcmzrw8WgQuL5OP2d7OjoIQTP6FhTQ+z8xkVfj735vIz2ere3ycgibp6ZtjaWmzcc6qlaz0DPPwYQqLfP65iWCQlKXR0UgSePyYsqAOh56lsrpKTmYHyLLiC8W0t9OS0m4XaG8X+Pjj2OdCCCLD09MFvvnGQG4uuyp1dZxJZ2URga0U8OmnBk6fphpXZyfnqKOjBgYG1nfnsdkioD12qbgRyMjgXHtmhlrk0QCo0lKFlhaFBw94TK2tIkyVa2tji1/bgBYXK9y4ITA5aWB8HLh7l4jrEyfiq6G5XKQtTUywQo+ee6ekKJSU8D7Iy4s1upiaoma8w8Hnp6bm+arT9UKjqBcXDeTmSiQlOWCzsVrWz6/uagEIt65Xsh1WRmOjDLW1V1s2vq6xleUtgdckEb+Jlx92O1vEevYERJyT5uaAL77gTHBujm3k9VSyOjroLxsIUELxxyhbrac4tbDAVmhmJjA2ZsDtZlJtb6e8IUA61Uojex0uV3zdax10aAIWFhTS0ohcPXFCorFRu0bx77Ky2MIdGuKGgLxtWgAePx6Zx5IGszFv5Xhx5IhERYVAQkKE3pSTQ6DYkyf0gI0W+njyhEYKc3Oci+7bxxbn6Chnxn4/OxsrpVFJqzLCRvfxwmZjO7WtTaGvj/iCb74xcPy4xMWLFv7xH0m9GRoS6OmhXWFBAXmtIyOsTg1DYu/e9Tncy8sI61nX1fFe0upmK2PbNs79JycV8vIoolJdbYXoO0BTE/nRtENkEgsEFCYmSKMaHQVaW7GmLGlODjcEd+6Q833oEMU9MjOBc+csuN0cFUTT3vRG4fZtA0lJgNe7eZv9qipuBr1egfJyGW6HR4O4dDLWiVkL8Kz8O/1fpeh2trREx60XofBtxdjKFojAm0T8UkJzLVNSVov/b9WIBmUppWJAWVNTAiMj9KUdH6dcXjybRqWI5G1vp9ZvYiLQ00OpTi3OsJkPdmoqk1BXF+0T9Syxp0dgeZmay93dYs1EvNEoLyedyOdjtRldnc/PcxPz7rtUVRofB777zkRWlkJHBxf8tDQCvK5c4fzyyJFYZK1lRcA164XNFovmBfi648fpE5yQEAv2KSpiZ8LvV3jwgDPxY8cICBsZEUhMJEBx27bYZNjYqJCURDu/tWaXgFZ9krh2je5awSBVun79awvbtgEtLUBCgoDLRaDbyZMUDFlcNJCcTD/j6uoIT3hsjG1cm42AtuxsUtra2qgn3twMVFevvTkQgteqqIjz++LiCI5h3z6JlhbO8ZWijePx4xI5OTSr6OsTaGsTIQW3+OMcpajtPjDAxK39pgEi1eOJnKSmItzKTk5WGBoy0NAQ2ZguLZHrvrTE6nO9dv3KMAyE7u21r5FOsJo/u7Ja1ptuXSWPjBj4/nsTPh83LRkZwU1To/sp400i/gsLKYHLl0VIF5gL9GZaGL6MWAnKWomMzs7mvHRigrrOJSXx3+fhQ4G7d+ktKwSQkEDKRGen1hdmS3OzaBQ2GxGnjY2RGTHAmV1vL1W11psXLy8ziW6E488FMva9Hj2ix3JiosLbb+vZrAhpUdPbV3fDOjrYsnY4BB49iiBrBwcFbtwgbe7EiedbiHU4HPGNNA4fZiv6/n2qiE1NGWhqkqisVHA4DMzPE63+j/9o4MCBiPmDzfZsXXAd2dlMBkNDpDoVFhIpfewYKWgOR0TYJSGBs9zOTm4Glpd5X7z1FivLBw8M9PWxfZyczJZ2YiI1ufv6NAjLwJEj8TWoAYRkTqlwVVYWQW3b7fwd700Bp5Oc39xc2lP+3/+3iWCQNobt7XSM0jE1BTx5QitEKQHLogOWzbbxc2SawPi4gdHR2O5QWxuNS4RQmJ838NFHctO8gePFymo5+n+WZcHnU/D7g7Db2RGxngOnNTdHgRW7nQYlzzMLf9nxJhFvQmxVyHm8WFoiSlWLIUxNibjJwO/njZuWFl8F6FVFPFDWynC5yMXVlmtrHW9npwDAqqKqSuLAAYncXLa1vV7ODDs6yNtcWODC/GPBINqBKDp27FDIyiL6ea02Iz122c49dUrGoI03YpBBFyECmmZm2M7Lz2cyPn/ewvy8CKNdAbZSpTTg98fOrR8+JMjLshTa2gzk5W3eTM5uZ0U7O0t+dSDA+62+XiEx0cKjRwKdnQbcboFbt2QYCS8lz8/gYMRzeb3zQUEOC4uLnGNr68x4dLOSEgK1PvnEQEKCCH1nGnMkJpJuMzrK819WxrntW29J/PM/m5CS1WNu7tqjEcPAmi5k+/fLMCJ9+/bIeU5M5HHPzXGD0NkJ7N4d2aBdv06wlRACu3eTppaQoDZEpwNYKWsN9IUFcvv1PaCU1iZ/eYYHa0W8FnZZmcT+/RLDwwpVVRZSUiwEAhubLV+/buLpU6KttbnJVgmv14vMLWxB9Vok4tcptDNRW5tYs11FAQtWKcXFCufOqbiqOy87nocfnJKCGKRovCgrAyYnyUPdti3SJs3PV+jp4WKen69w/76BR4+Inj1zRm7I+u55wjDWr4SXlijy7/cLdHVxsd+5kwIi168bmJqiQbxWVlrrM/LyFNxueixr1DVA4F9+fuxrfT4NjlKor48sUKmpnDsKITA4qPCb3xioqGDSiLfmeb1sA0vJVuZGWv2NjUy8lsWkqdWs/H6qVy0v85rpzxsdFbh5kw5J4+N0SNIjlulp4OlTA04nNcMdjtjkFwwScd3fz6o/mrMMMMFWVdFOsLub39s0+doDB6iqxY0J5/zZ2RbKy4lYHhsTYfWxkhLruZHpKSn8jJUhBM/3vXsEqI2MGOjpidhSBoOA1yswO0uHpY8/fr6qNTk5gny22WJlXuvqJDweUqt27179vuPjHGtkZGDTQF7xIrqFfeKErpaNkI1j/NnyyqS8tISwhK7f/9IO9YXiTUX8FxZElHK3nJQUf9bkdlN0IDub/52cXLvd+7LixyhlrRUHDkgUF3NhjZ5V7tqlkJnJBTA3V+G3vzUgJSuuwcFYgNGrCALTKAKRlBRBTPf0CLS0sAV5+7ZCaam17gbp+PGIx/J6spxeL1ubGRkU6BgfF+F59sGDEhkZrFpbWgzY7QJ37yoUFbGTwnkmZ7oVFUz8TJJc+M6efXbVobWlV8a2bbwHFheprR0t8mEYXEwnJ9k+3r2baN9r11gdciG2sGtX7PuOjnLunJQk0NxMY5KV2tgadZ2Vxba+nuGnpvJeGRri30nJpKX1u3/3O4pMdHVxBHLqVOS7Ly7S5SkxkQnredHqmZnAtm0E5q1sye7cqXDjBvnsQ0NEpkd3WubmIl2weB2Y/HyFI0ckBgY42onuiCQnc3YeL7xeaqKPjBhISyM//llmG5sVawG+osVEgFgk9oEDAnfu8Hpt27Z1qmFga3sRA69JIn6dWtMAW1rrqSylpfH3IyMEebxqMET0XGgzlbJMczWYSP9c7+al5My5o0MgOVnFFaDQMTUF3LxpIBjkvPNZrkwbDZuNUoQVFRTf0NWK3c7fLS1R2epZs2MuOM9eGB0OJv7eXn7n6EouOZnCF243FZrm5/nzH34QcLmoKHX9OoFQQ0Oa8sNEMzjIGXVe3voSomuF3a5NQ2JfW1BAIY6HD2lEPzBAnnBmpoXlZcDhYDv+8WMDSUmc+etbKCGBG9DZWSactTYyWVkRc4y+PhE2CtmzR+LQIYmxMVbZuuIvK1MhizyKr7S0COzcyfdRKqLC5nCw9R3dng4EKEXqdKo16WxaTezxY26Qo7m7WVkq9H5Ezi8vR17n9xMt3t/PZHn+vFyVjA2D4xKfjxW9yxV/pr8ylpe5cdMbOC1I8qpjLcCX7qjpajk/P4gPP6ShxXot7J8iFhcX3wh6vInYSE0F3ntPYmqKC8l6G7XpaT7Im5Gs9W422kP4VW9yDINJUNs2xksg09NM3o8fG2hvF6GZo7GpJgzREpA6qqsVAgELHg91oOMBgqameFwJCfRO3Qg10W6nv211NRN/vEU4O5uV0dCQwMAAK2Dqf3PzoududXUSNhvb5243/Z+zswU++MB6Lhet9UJbPKakSMzPmzAMhL2VDx+mxOXoKIFVCwsGHA4Z/k7Z2Uygk5MCu3Y92//Z5wOuXTMwMyPQ3c1Zerz2MQDs3CnR1WWivZ3gtsuXDXz4ISv5yUliE4aGyH2uruZGSim2yltbqSx27pxcc2xRXR1fjzkjg/KXT58SeBb9+sVFGnIIwQ7L5GREgjQ6ursFbt+moMjUlEJe3vrdFv25jY0KHR0ExG1EqOZVxHr0KKVk2JhCry/Pmi2/ingj6PEm4gYTwfp/09YmcP26CFE/fpxo+0ZAWa8qkpPXRuW2tIgwhYXPjTZiWP+7z8ywskpO5oL6Il9PG36sRwe5dcvA06cEpdlskZnj6CiFKjIz4ws2rMV9jY6qKjoBXb1qYGKC87m8PBrdDw2JUKKgotbQkMAnn0RAgffv02t627ZnV/IbjZIS8nZHR3m99OYlI0NheZkc5ZUV4tOnbE0HgwJZWSKMmAZYmbrdxAbozSfb4AqWJZ5J4crNJRrb4xEIBNju37mT1equXRK//S21v1tbDRQX0/LR52NyTk5mR6KnB8/NYtAz5N27V0tXulx8jq9d4z3b2Smwc2fs/Tc/Tzcvy9oYQl8HLSMlTFNsKQRydDyLHvUsMREpga4uAwsL3KC+LLvGNxKXmxCvW2t6s6Kjg+0pyxLo7uYiHC80+GOt0/SyTRs2M9rbucB7vaSWnDihYFmI4V7q0ChTUsYM9PQQRGQYm0eRWhnBIBdTy+L/B4iE/fZbE2NjVNS6eNH6UW30PXtkuJrbuZOI7r17Ca7S1XF+vsLu3ZrWAzx4YKK1FQCs8Mw1EKB/r93OpPq8l13zeVdGaiqPsaXFQFmZipmPT08L+HzcpDx8KFBZyVm3vkadnaR3aRU0h4ObzLY2Vs/r8ZYBtoyLiyW++85EaqrCzZsEdO3cqfD0qURmJlG7bje1yRMS+Jo//IGazA8fGqisXF0VLy6yc7GeVWA8bXXD4MaopoaqYl4v/ZK1aIvbDXz1lYHJSRESQZHYuXPj4Mw7d2hyIQSwvMy2/VaO5xUT6e838e23JpaWeI9+8EFw02U1lVJvZsRv4sWjqAgYGABstrXN4EdHEVIpYrWwkof6MkBZLzOKi4HRUdJ+SktVqEJdHaOjAteu8bscOEBTiNRUolsXFihv6PNxYV9vDv28cegQDe0TElR4c7C8TGBNRgYX4qWljRlUrBUpKZxXRkdLi8DDh7SJPHWKaOkTJyQOHAB+9zvqYHu9iKlOb9408PChAbtd4fTpWIWxmRluJLTJw/PG7t0KO3ZYMM3Y11dUkMPd1GTA4RD47DNKQ2ZmUts5LQ3o7TXQ2qpw9Cir96Kijbddk5Ppbz0+LkPXm05PADcmi4vccGjEsxAExD16JFBRwRZ2R0cspbC5meIiKSk8T8/LcikpoTHHwgK12qOV0yYnBUZHOcdfXqbS2vOI2ni9mtqkwq5kG42JCZ6b/Pyfxot4I2IiHo/C4iI7WbrT8TL0rd9IXL6JF449e1TYT7a4OP7faL6nlEBqqsC5c5EF5mWBsl5m7N8vkZ/PuXA84JeOR49ojycE0N7OCq2pyUBREVGvV68SYTs8LHHhwuaJJOTnY9WsOiuLs7yuLkoNxksqShFc5fdz4X6excbnYyW3uCjCXrgarZyYyHN29y6/ezTIaGSEv/d6CXDSm4Pe3ogE6eHDcpVL0UYjXoVYVMSOwOIifbBnZujsVVLC3z14QNnLmzcNSEmOcPS1WV7m+67n7JWfr7BnD7sBjY0qbNNXU6OQn0+jh+hxYEICZ96//72JqSkgPV2gpobUQZ+PdLDlZd5P5eV0l3qeyMqK6JKvTLLZ2QTYzcwIVFfLuCyKhQV+33jSp7t3K3i9nINH096eFQMD1AH3ejluOX36p6+k44mJlJdL1NdbmJwUaGiw4HBYCAbX91p+kXhTEW9CvA4J5GWEaZKbu144nUAwqGIM1uOBsnp7qRpUWKheSL3pVQW/87MXwpQUQEreF6mp5AHX1bFCe/iQwhlJScD8vEBnp4DbTXnKeE42PzYMgzrQ+/axtRnvdu3ooD1gICDQ2ChjFsapKf53LT613c7vODFBnemVC3ZtLcUXDIPHEggAzc0GPB62+HNyYufW/f00QHA6gQcP2FLNy9scgwqA8/C9exWam7np0FKTb78tQ64+NGXo7RU4eDCSgJ4+JS3J6WTVvxbCWauQHT5Mo4UvvzTCHOF4a62uipuaBCorWSVOTDAR2+2ce9+7Z2B2FsjKMlBbaz3TynJlJCbGR4jn5AAXLxIAGA+J39pKEFdCgsLp02oVPamoSOFXv9K4jo0fj9tNZHtGBmfkgcD6bfdXHTrRpqfTfEWrlUlprEmPetHE7Pf7EQgE3iTiN/HyYv/+iP9tfb1aBcqiUISB3/+eu/7ycomPPtoY2ncrx759MiwwoqkqeqGprJQYHGQlWFEh8cMPBhYWOL91uaxNFxDRsR6gZmZGYGmJG4jRURFW7yIgLyL/GU8VyjCIui4vJ9I83vw7uoKMSIoqZGRIXLoUi17Oz1dITGRiDwQMfPKJwO7dKqYdLiWrU6eTx+l2Ey3ucFB44lm4l/37aQsYnaB0ZTo2Rg/n+noZ/p2UlLj0eARGRoDsbAMnT0aq5adPuaEqKmILWm86rl9n69eySBHbvTv+RsvpZIfp0SOqw+XkRJLbnj2kahUVcbQwPCxirkN7u8CTJwJ5eUzoz5vQ4iH0dTx6RKnP2VnS1+LxhF8k/+TnK+TkcCNWV/fTtKY3GqZphDYo69OjgLXFRNYLb6in/wY1/SZeWiQn00sZiD8PlpL0jdu3aRCenEyU6+ueiBMTsUpMQkdGBo3upaQ14IMHTIA+H6vF9cLjof7yelKeLxJlZVSSWl6mIpZOMD09BDcpRYrLWvKMaWlYM8msDC2EYbMRbbvyWtfWKrhcEg8fCrS2kvZz/75Abi69lqUErlwxMDpKpPaxYxK3bhno6BCQkuCvZ3lRCxGfFaBb10tLnF3q82AYQGamQk+PQF+fgWCQfOsDBySmp4mDWF4W6O9XyM6mkIpGWUupQhXT+ufl6FGJqioBv1+FLBH5fXNy2PYdGOAMPrpwWljgrH1xUWBggII0ev68GZGXR/UsWjxu3vtmZtLD2+d7/fzV1xMTidbE32i17PF4AODNjPjHxl9qa/p5Yi1QFhMLBTWGhwUKCuSm8U23cuiKKT+fNJbeXs4QVwqt+HyspA2DnN0vvyTCtaqKwhCbVUkUFCh8/LEK6z3rKC5W6OtT687ELYugnZSUjVVH1dUKMzMSs7OcXa/cUAjBEUUgwNbuwAArp88+M7FjB4VO2tuZlJ48EairizhEzc8DN24I+P1GWB/6eYMt59Xf9cQJmjV4vRE/4R07IkpfMzPA0BCFMz74gGIfx49LPHliIDl5fUlSgF2D3FyFTz810NdHcNZ77zGpnz1LfeW0tFh1LN1Kbm3lOaqqEjECJj82jh4lpsBu39hIZqPR3Gzg7l0DSgGGIfH22z/9jPhFYqNiItF85ZVJWVOXfmou83rxWiTiVxWTk2wVOp1cwF4Geu9lxHqgrORkoo+XlwW2bZOrwDE6xsaAu3fpnHLo0M8nWZsm57eHD6+e3T56ROOHtDTOJCcnBYaHiXAdGBCYn197bvsiEW9DvnMnDSqA+PKIPh9pP0NDAmVlPM5nbQ60JOSzoqyM1em9ewZaWihLOTIiUFcn4XLRQaqggGOMQ4ckTNPAnTuA3y9w546Ay6VeGOgVL5KTOVt2u4mCr6nhJsLpZML9f/9fE2lp9J5ubeV1pa63xPg4W+cul1pl6xgdPh8wN0f09tycQKhYWrN9rHXTHzygUEdfn8D0dOS+UIpt8/FxXp/nxSAkJGxMne15Y2kJEELBNJ9fkcvjIbYiO3tzu0KbEevRo+I5yAkh4PF4kJycvKULutcmEQshwnPPlxFSUiavtzfCP9zMReZlxEaUskwTOHNGor6enqhr+SPfv2+guztiQbeRhfx1ipXPoPaBXV4WmJykjnNRkUJ+voTbbaCiQj6T9jQyQrtLl4tz0xepnp+FDp+YEOjo4Fiho0Ngxw6CzrRDUl8fRTMaG1+sSsvJYct7akpgcZHiGIWFpBxNT7OST05mkjx/XmJx0cDwML/7F1+YmJ6WOHp08yzvysooE+nxEOilK9KaGoWDByXa2ymmEn2ul5eB774zMDIi4HQKJCbKmOpycZE0ImIEqLv95AlClp7PfsbLygg4e/yYVpL9/TKsjz46KvD997yP+voUMjKsLeHfW18vMTPDFv+ePRtfx2Zm2BVyu9kVOndOrotg/yljo2Iis7OzsG/lITleo0T8KiIQYPsqEIiINWzViDcvWWvHp23e1gubjcIh/P9r/+3sLJNDZubaur2vQ9jtgMul3ZMIgsrM1HaPpMToZ1cpznJnZggWKihgW/eHHwgUMgw6U0XzdDcrkpOpZDUxweo0OZmfMT5OBTLtkJSX9+IiIgUFCh99ZMHn4zmYmUFIPSxWgpRoZYWbN7VCFlugpaURL+PFRaCtjapg27fHp+usF0LElz0F2MZNT6ee9I4dkY2i3w8sL3Pm29oqkJWFsISkz0dBjf5+Azk5EufPSxw8KNHQwGp0I0mmsJCo89FRznQ7OwX27uUxBoNcL5xOHsdWWTdyc4GPPpKh1vTGXzc5SfepvDxaQs7P47l51T9VxKuW/X4//vZv/xZzc3M/8dGtH28ScSg0BeXBA5LLX0a7aLMiuh2zWTquhw5x0TRNyurFC6+Xu+XhYXrCXriwefrGrzpsNiKRKypUjE1dWlqspSHAqufbbynDl5cn8NFHFhwOblxsNi6+nZ2UdszP5320WWONzEzgnXcsuN0CubkRcRK2HSPI5h97C9Dmkv//wQMDzc1MxIZhxMwXCwoU3nmH6OLJSbZuo6vhpiYj7A7l9SLGIcnj4SYuI0O90H2TkUHRmpXhchH5/L/+lwnLIr+4vV1g1y6FuTkaPiQlKTx6ZKKigtfnedQOhWCFOTlJ841onEFRkcKBAwqDg+wmrBxl+P2krgWDrOpfpcqiEM8v1pKVpZCXJzE1ZaCqKj4d7HUIwzBgWRb++q//GuPj42hvb3/Tmt6MeNmtaQAoLV3fzm4rxMtSykpPj7/IRQdNzUXYh3d+Xmwq0vNVR3r6xpDIy8usuFwuWuH5fExax47RrSchASGpSYHxcepDFxQQfbsZus95eQi5LsX+7K23qDldUrIahAaQn6xtHXftknEFI+IFk7oILeSrz09KCscdAwPsjBQWEgioQWWGwTb50lLkNcvLrEwHBliZvv/+5uIQGhsVDh+WIS/jiOxrRgbP3WefUeDl4UOxypoxGGSnJzV1bVWn+noFp5PfOTGRtodFRdwMHT5MDEK8ePxY4OpVE5YFTE9vfdBUVhZw8aLE/DwpXlu8o7tmSCnxb//tv8XNmzdx+fJlFMZz4thC8dok4jfx08tVZmURkdvfT3cirWgUe4xc2NraWJWUlJCCsllGBD9FFBcr7NwpMTwsUFenwq268nK2LJeWALfbwNgYE+/t21StKi2lotHLALwIQX7oWuYZACk/nZ0cWdhs5PYCxEMMDDBxlpauXmz37o0A+vbsiZ84CgtVGFzW1sY5aSDATlJFBX2Uo187N8d2elaWwpMnJjIyuJHYLGqnYQBvvaXQ1MT31B0tu50VcFcXDTI8HoGFBVKnAN6r331HbEheHmei8apWw6CoSm+vgZkZdkA++ODZ8+DFRQEpFRwOgS3eHQ1HvK7Q6xRSSvzN3/wNLl++jMuXL6PkVZu9v0C8ScQvKTo7BYaGEHbE+TGhQVl67vFTyVXa7ayE5udZPaxcwH0+At46OymKUFwMjI0pFBaKLd9pWC8cDrax13LPcTqBU6cU+vpY+T1+zDllR4fAzp0iLhr6VYRlIdw6l1H59MkTJk4pBQ4ckDhyJDbZpqXFtpSfFePjFKVITAQWFhR+9avVr83M5Mbl5k0DExNsYRsG7UB1BIMUDklOjliD8nwyydfXr2+rGL05iI7cXODQIYXOToGqqli/4Olp8rdNE7h/3wwD3+KFzydCmuKrdb3XitpaVuler0J9/ev7DDwrlOIIx+9HmI71U4SUEv/u3/07/PnPf8aVK1dQXl7+0xzIc8Zrk4i3cn9/ZUxMAFeuCHg8Al1dCunp8VuHG4nnAWW9irDZ1gZvDA4KPHnC+eDIiAgBjTYGiHkdYr2qXieBuTnaIY6PG8jPj6h/rRWBAMJo9aqqzaXMHT5M+klCAq0UdbjdtCl0OGga8mOjrIxcaF0Rxwu7HTh7lsfQ3EwRk8uXKXG4fz87JlevGmhrE0hLY2Wam8vW+tWr5MPOzq7W+d5IGAbpXLt3c6YdfT+mphIQ9803JpQC7t4lWji6KpaSbfa8PJqQDA2xM7KRZzo3l+OPa9cM3L27GtH9c4nOTl5Pv19g9275k7AupJT4D//hP+B3v/sdLl++jKqqqld+DC8aP5MlcmuFtshLTFTrIrB9Pu6qXa74oIqt5CG8kUhM5KLv9VL1qq5OoaxstX6uUtS/1dZnG51dvg6Rlga8+66E280ZmwZXTUzQP9fpJNVJC2E8eiRw7ZoJKZmQNnMBKyhQuHBh9aJfVaUwNKQQDGLNKm1mhjzb3Fz1TBW2igrSdoLB9XnXdjvHFDMzBn74gcjcO3cMZGfzHtF+0mNjBsbHiVwPBPg8jYwQoa4NH553LyoE4tLRnE7KxHZ2ksq0tETsg0an+3xUGRsZIcXtrbeo2PY8Fd/Tp2yHS0m5zJ9jIna7BbxeIukHByMSrq8qlFL4T//pP+Hv//7vcfnyZdTW1r66D9+EeJOIX0Lk5dGar6eHHM94tJLpaeCbbwzMz1PU4dChlcnq9bIvBNiSOntWYm5OoKhIrkmn6ekR+Pprci+3b5d4553Nc0faCpGdjRiDc6U4r+3rE1CKxg2a2zk7ywXaZmPyexVRWqrw8ccWpIyfnNxu4IsvTExNUav7vfdi59yBALsD0fvCjXJns7MJBvL5mPC0AprTya5CezsTs6bGbd8u0dkp0NkJVFUxKWZlWc80Q3meqKhQ2L9fYnSUyTbafWlsTKC9naIvra1UGXtemlh2NtDdzcSk+ccbiWAw0i2prNzaAkMlJQpdXQrLy0Bd3at9npVS+C//5b/gf/7P/4nvvvsO9fX1r+7DNyneJOKXEIbBXfb+/Ws/dEND1K5NS6N8XmNjpDJ8HZMwwIWGhgTrLzZUNKK60cQEqR2vKzpzo2FZgGHwu0aD/7dvV5iYkLAsEaMJ7PEw4a1EFi8sAPfu0V1q9+7V/tMbjfVAUtPTFDnJzVUYG6O/s650Hz+md29mpsLJky8GtnK5OHPv6KB6U2KiltKkZ3JSUiQRp6cD585ZWF420dpqYG6Oil4ffijXFKd53nA6Oauen+fnRd+LyckqzDfPz48P5JIS4c1UvNi3j37MQjybzx8dzc0C16+zZb5/v3wmq+GnjJISctH9/s1Vo3tWKKXw3/7bf8N//a//FV9//TUaGxtf3YdvYrw2ifh1SUYbjdRUhdRULnLbtnG3Gw3Ket2S8PNEcbFEcTHdkerr11akkhJoaiLwq7r65QhmvIoQAjh6VOHhQ8pFRhs7FBYq/PKXRBnrimdwkH7Bfj/NFaITdEuLgQcPDBiGwvIyHYo2iyalIy9PobBQYmqK81Ktjb20RI6xViMrK+PM9EVCI87n5oBPPzUxNkabwEuXrFUYhIICIp8HBgh8m501MDIScVBSCmhpEejvjxzT8z42CQmIm9izs4F33pFwu6lbvpJXOzcHfP893b3274/vnmW3vxhgU3dLTDNilbmV41lKdJsdSin8j//xP/Cf//N/xpdffol9+/a92gPYxHhtEvHPLSoqCDxZXKQvqhCxoCydhFtb+b/8fIpu/Bwqx9xcGqn7/es/vMPDIiQOIUIzw5dnYfiyYy1EL7DaPrGvT4QUv9gtiU7EOsEEAjS0n5wkj3gzaVJpacClSzKsta0rPZuNFeLkJNXI1prt64p/I8lwcZG0ntxcJmWvV8S0hnU0NNAFqqODBg/RrfCJCTokBQICQ0MK2dkWCgoiv3e7mdSiBVGeJ3jt4v+up0eEjola7VVV1qaBE2trFQYGZFh3+01EQimFv/u7v8N//I//EZ999hkOHTr0Ux/Sj4o3ifgnDNLbVnsIa1DW/Dw5qcvL9GjNz1dxvWhfx3A68UyQll7IpdyYSpDfz799EUegrRTZ2QoJCQp+v1iVAHbulAgGSRXp7lZITCQdKSFBoKyMCObNwPQlJa02qbDbgbfflujvj1Uji46REYEbN8hbPnbs2e3jnBx2Ovr7aQG5UrhEh2GQUlVTw+/X1SVw9y6lJjUyPZ7ez/Q08PnnJtxugZISiQsXNi5sspEgQJHSnkVFm3PudbhcCna7CCPrq6q2ngnDTxFKKfz93/89/v2///f49NNPcezYsZ/6kH50vDaJ+OfYogXWnwebJquQ5WXA4VBr7rSDQS44qanPTm6vUxQWKpw4ITEyQtBbdMtSKfJ05+YESkupqUtRCYHDh+VrXUHU1SmkpEgEAqt1l5OT6UQ0Pw98+qmB0VEDbjdw86aJ1laFM2fit0c3KzIzEbdi1fHwocDQkAGlFNLTjRg+8ugoZTFzcyMARpuNCXZp6dlSnU4nMQjaNcvhAG7eVPirv7Jw/LhEfz+7S9FgqtlZdhf8foWrV00UFyscPrx554ctZwvLy9yYbGYidrsFJicNFBRQ93l2Fi9Mg/y5hFIK//AP/4C/+Zu/wR/+8AecOnXqpz6kTYnXJhH/HONZoKzkZC5SPT1s18UTxbAsKgN1dxP48s47Msbv9nUOw6B0YTyBhYEB6j8vLQEFBfSvHR0VcDgEHj16vVt56xkf6HC5SJMaH1e4etUI2b0BCwt0D/upwunkxtAwBBITY4UzvvqKrfS8PIUPPrDC96lh4Lk0mO12blL9fnYODIM0rHhUrLw88vi//dZAaipb2BUVVgzIbXaWtn85Oc9PpTNNvDTsQlaWQkEBNa7Lyp7vuSbdi+vG81ozbuX43e9+h7/+67/Gb3/7W5w5c+anPpxNizeJ+CeK9TyEo6OkZH2rtrk5zhRTU4HBQfIvX2d5uo2GzwcEAuQtLi8DSUn0y10LtfmqeY2vIjRNSkqJ+/cNpKcrlJayAh0b4/y1sFCtatUvLhL0ZVlAQ8Oz7R6fJw4eZMIwjFhw3eIinXxychTm5/nvF71Pq6sVfD4LHg89ttebyerN7Ogon4+HDw0UFSl8/DHxFtPTwBdfGJicNOJStX7KSEujG9jsrAqNKzb2uvl54NtvqWCWliZw8eKLO3NtpfjjH/+If/Nv/g3+4R/+AefPn/+pD2dT47VJxD+X1vRKpawfi4xOSeGuv7fXQE6OWtOEIRgE+vsp5F9Wpl5r7WeAXNiGBonxcYGdO+m3nJ1NUQltyaejq0vg/n1qDR8//nzOO69D7NypUFlJkFBCAlHXX31lwOMhJejcORnTMm1uNnDjBtWqvN6I4tVmREoK6TorIy+PFevAgEB9fQTxHB3T0+xqZGRgXVlQu12bdWwskZeVKezapdDbS9DXxISA20009vS0wPg43cRGRrhZ2Er2nqmpZFg8Tywv87qmpwssLlKa86fskmxGfPbZZ/jX//pf4//5f/4ffPDBBz/14Wx6vDaJ+OcQL0Mpy+Ggifv4OPmOa6GKHzwwcPu2ASGAI0cs7Nv3ej+YiYlMIFJG5orxKCJ+P3DrFvmnw8NUm1pLS/h1jujNxdQUMDNDg4WxMer/RlfFPh8AEHPg97+a47PbyR3Wto0r955LS8DXX9NiMyND4fz52CpOSh73i2AgDINexjMzIuylrRTfMyeHVC23mziEeO3f6WlW8Hl5r4cbUXY2NyqdnZxb/1Ra55sVX3/9Nf7Vv/pX+Lu/+zv88pe//KkP56XEm0T8iuJl8oOTkp4tFDA5yf9KSfPv132HrONZexnTpNTo+Dhgt4tnth2VomjGSk3i1ylIt5FYWBDYsWN1S3PnTgmv10AwSKelQIAOSsGgQHV1/Fb1yIhASwtHIHv3vpjfsmGsRmLrWFyk0EtmpsLMDAVf9D3q9QKXLxuYmmI1vX//8ys3ZWQA771nYXCQdMDPPjOxbZvC8eMyZPvHkcbKRDsyQhW4+Xlgxw6FU6e2vgqcYdCacd8+3sNb/XjXiytXruBf/It/gf/+3/87fv3rX//Uh/PS4rVZal5la3qz54lbQSmrtlbB7ebCtpa4wOQkwopKW6k992PCNIGTJyW6uw0kJ8t16V9SAteu0T0qJ4cI5Nexja152ouLTC4rb7esLM4edTQ1CVy+TM/c8XHg/PnY1nIwCFy9SvBPMCjg8ykcOLC5JvcZGQQ9dXZy7htdxQ0MCHR2GnC5gMePgdraFxOPyM5mt2Bigspg7e0CO3fys9f6LhMTfCZycthW9/leH3rc61C9rxfXrl3Dr3/9a/zt3/4t/uW//Jc/m/FkvHhtEvGriidPBJqa+OCdOPHjDQk2Csp62VFdrZCfbwGIL284O0t94clJSvldvLi5IJ6fMnJygJycZ89BZ2cp0O/4/9u79+Coyjx94M97OiTkBkmAhKuBBAJB7kKAIEG55trdERWndHZkd8pdnNXdRWtXxyl156LWjFNbOLs6tSOzpbOLM0O6kwABApEOBpD7NZE7BEKukDu5kO5+3/3jtduAuZPk9Dn9/VRZNfX7jTuH0DlPn/e87/fxBa5eVRAbKzS7+zowsOc7kVtbZWeun5/ced3RF1EhACEYrl1jqKszoKJCzgjvrImrtxRFvr+fO1cuP7ffwxAUBAQECNTVyclZHQVhT5euhw2Tu6hrauSxt+4KLSIi5HGrujr5n5ubtRPEfXHpklz5CA+XG+/U2rh2+PBhPPPMM/jggw/wd3/3d7oOYUBjQcwYc79fHQhNTcDRo7IVqLJSltr39WiCa1yl0ynDzxPGVXY1F/juXeaePlRTI5cGhw3TZgj1VUAAEBoqUFIi31O2rzB0OGQpQ3Dw/Tfi+noZGv1VcK+GmBiOigoFra3ySffBj6mPD/D44wJHjshu3agogdOnFTQ3M8THc0yb1j+fE8Y6/jmOHy+P5TU2yv/8YDi0tMgyiKoqORRk4cLOl4/HjJFL1PX1ckd5d0vsssHKiT175JntnBwDVq929nnGtydrapLHu+7eZSgpkV9AHrZLvS9OnDiBp556Cj//+c/x8ssvq37fHAyaCuKB5uMjv1FXV8uGHF/fvodw+01ZancI90R4uMCUKRy3bjHExHS8qxWQTx0XLsgZuFOmCE0H0IOGDpUb38rK5AhF15hEh0Oe1b52Ta6UrF4t5ztfuCBHcBoMQEICx8SJ2vziEhYml7KF6PyduxyUIZ9GT52SoTdsmOwQDgtzDuigie7KEm7dkg1JwcEChYUMU6d+V5YhBHD9OkNTk9w9PWyY/Ht9sJqzK0OGyNGbI0a4dlyzTieAaZmiuM5nf3dWe7CdOXMGJpMJb731Fl599VWPv2/2Fwridvz85M7O69flTWbSpN7/39BqaYNr9/Xdu/KppLNfwrNnFRw4oIBzoLaWY/lyz22E6YuQECAk5P6bbF2dnCkcHAzcvCnPagcHC1y4wNDczNx1dVoNYqBnI0R9fIAVKzhGjZJDRAICGJxOuSys5jltuQwvl67Hj+f3rVhcuyaPcrW0MERHy1cuvQ2YoCAZ4pcuydc24eE9/3tubJQNYyEhnZ9o8BT+/vLM9ZUrctPcYH+eCwsLkZaWho0bN+L111/XzL2zP2gqiAd6aRqQ74H6+m3XEzZlPQyDAd1O72luln9OHx/5PtEbBAfLOd/Xr8uuXNdZ7dGjgZISwGC4fwXh3j25wSc4uOPjMFo2dKjs2vbzk19YJ00ScDoZrFYGg0G+5+1oox/nsiGpslLOTH7wrPfDGDtWrlLU1cl5z+3fEzc1yaNHwcFy3KWrS7k3XHOuZ8xg39Yi9uzfa22V08Ru3pSfm5SU7zdLeZrx4wXGjx/8L5Tnz59HWloaXn75Zbz11luau3c+LE0FsSfraFNWQ4O8EYwapd2jMA+aPp2jpkaB3S4wb17nv7AtLfJIjNPJEBvbt95aT+HnJ88sV1XJqWWuJ5v58+XTkaLAPX7U4ZBTja5eVRAWxrFmTcfBpGWMAbNnyyEZALBjh4KSEgWcf3++tEtJCUNBgQKnk6GsTA5f6c/NgJGRApGR3/9/f+QRgehojvp6hlmz+Pc2WnEuVzNaWuTy94M1hy5DhvRuORuQE65cpxCqquQejK7mdHury5cvIzU1FS+++CLeffddrwthgIL4oXW2KauqCtizx4D6ejkHd9ky3q8D4dUyahRgNnf9PhEATp+W05sAuTyn9SXsoCDct3kLkF+uHnyya2yU7yzDwgQqKxVUV8vxhHoWECBnnjN2/3zp9jgHOJdPza7lbLt94I/YhIQAqanyrHRHO6ovX2bIy5MNZ1OnciQn99/vaWioDPfjxxX4+Mgvp+R+169fR2pqKp577jm8//77/TLkSIs0FcSe9k2pq01ZlZXMXXZeXMwQF9e7wfaerCfvE1tbAcbkKM3ObkAOh1wm9LC/1ocSHCyfwi5flu8TO9v01t6dO3Judni4NkePxsXJzWsGQ8fFC4D8mSxcKGc+R0fLXdclJXKZetGizsOvrg64ckWBn5/AtGl9m2zl49P5ilRzM9DSImeW19XJd979lQVDhgCzZnFcuMDQ0sJw9KiCiAin7lZI+urmzZtITk6G0WjEb3/7W68NYUBjQexJ2r8PZox970M0cqT4dsC9/Kbd0bdxIeTAAMbkk6aeAmnGDI76ermp68ElbCGAkycZzp9XMHq0rDrsy6QmT+TjI5/+Z81iCArq/n1icTGDzaaguVn+nBYv1t7KQVAQsGBB19dtMMjABuQytc3GEBAAnD3LEBWFDksJhJADVi5cUL6t+nRi6dL+rRqMjBSIiuJoamKYM4f3+xO6ELKbeeRIGfp2u36m2j2MsrIyJCcnY82aNfjd737n1SEMUBD3SU82ZY0ZA6SmOt0zajv6nBUVMffy7eOP806fJrSo/RL2gz+e2lp5BEYIhqIiueEnOlo/f3Zf365LC9qrrGSoqZGFFFevAgsX9t8Tmafy8xMICJBPuyNHdj4gQwjg7l25+e2bbxjq6w3w9eX9+mXFdXTLbh+YQR0REXIvxbVrsnCiNxtBr1+Xm9tGjx78HcwDqaKiAsnJyUhISMAnn3zi9SEMaCyIPWFpujeTskaMkJ2inSkuZrDbGYSQ/1lPQezS0Y/Hz09OSiovl09T3d0A9Vhh6BIRIXdht7TI4TGKIt+dFhXJo1FTp/LvHXtpbpbL+lqdfBYeLje/3bkjQyYkpOP/nqIAcXECxcUyvO124P/+T960Fy7sv3e5BsPAnZk1GIDFi3mvv2Ddvi3Prrs2eBmNTo8//tQTVVVVSE1Nxfz58/Hpp5/CoMV3MQNAU0GspoGYlBUZKXDrlgzf7org9SQwUJ7XLitTMHx41+0wV68yHD8uj588/rh+xm66TJwob7Jtbd8NibhwQc5+5lygqkqB0fhd6JSXy2Xd1laG+fO5Zpuk5C7n7q89Kkrg2WedyMw04OhRhkcekbOxJ078buCKFvT2S0NbG0NrqzxO2NIyeC1ZA6m6uhpGoxHTp0/HZ599Bh+9HCXpB/ST6IEHO4T7a1LWjBkCI0dyAEIXxd29Iacbdb3E6HQCR44w1NYquHVLHh+ZO1ebwdMVuXnn/nGanAO+vgytrbKyz+XGDVm+EBTEUFioYOZMp25XC1yiogQSEx1wOg1QFIYhQ+SQDIdDnhvW48rm6NHfLWnPmCE0P1KztrYWJpMJkyZNwpYtWzBE640U/UxTQazG0nR3m7IeBmO9P5voTRiTR2PKyuQmKLUG0A+2yZMFqqrkbOX58+/fSR0SIjB0qHxamjJFzoVubASuXGHw85PNWnp80Hj0UWDoUI6KCjlisqBAdmsnJHDMnNn571BzM1BYKDd7TZ/OO10G9zR9XdL2RPX19UhPT0dERAT++te/wtdbfpF7gYmBHlXVjzjnsNvtg/a/p5VJWU6nfKfY0CD7ZPX0dF1TA1y+rMDfXyA2tvPjK67JTWVlsuBdjWH1g0EIWQvY1iaPBPn5ATt3KvjmGwVDhgDLlzu7DCY9yM5WUFoqwzU2lmPVqs5XVg4fVnDwoEyyGTPkgBVvII8PQvXTCI2NjUhPT0dAQAC2b98O/4ets9MpHX537h9aCWFAvkfdv98Au12gtFRBerp69WX9LSxMbszpTlmZfEri/LvJTZ4+TrAvGMN971Y5lxOc/P3lu8SWFv0fj5kyReD2bTnKsqsyCEBufAPkGeeaGnlcUG9HBR907RrDwYMKDAaBZcsExo1T5/PQ1NSEZ555Br6+vsjOzqYQ7gIF8QNcm7K0VNzgcMh//PzkkxL3ji/993Gt6yjKdyUE7f//SkvlsIbx47U5NKMziiKXr48ckTfcyZO7/8vnXP48AG2+Y50+XXZrKwq6XWqeMYOjqUlOO6uqYsjMNGDBAt7leFatO3dOjtN0OBguXOCqBHFLSwuee+45cM6Rk5ODQL1MMxogmgrigQ7EBzdlaSGEAflUMHs2R3U1MGdOx8XpAFBdLZ8cR4zo+TlXrRg3Tg7DKC1lmDz5/qaboiKGr76Sw0Xi4oR7sIReTJ4sMHGiDKaehOq5cwwHDsj/Ynw81+QGuJ6udoSGAomJHAcOKDh2TL5XvnSJ6TqIR4wArl+X75ldBSWD6d69e3j++efR1NSE3NxcBHc2wJu4aSqIB9KD4yq1dMjc37/7Wc7NzcDevfLdWliYQHKyvsrNFUVOpuroBltZKc9r+/oCt24JxMWpcIEDrDcbtEpLGThnYEx+MZs7V7hXUgZiqIUniIgQCAwUuHcPHZZDdMU19lID38kByClnI0bIlY7BHpTT1taGv/mbv8Ht27eRl5eH4XqrHxsgFMTQ1vvgvmpuBurrZbl5fT1DU5P+3yW6TJokUFIi4HCgR5u46uvlnOCAgEG4OBVERwtUVMhjUdHRAuXlDPv3y6XM+HjeaUXhvXvy56Kh76huU6YIBAU54XCwXq0GXbnCcOyYPMe+dCnXRK2ln58cDjPY7HY71q9fj5s3b+LLL79EaGjooF+DVmkqiAciIIUQcDgcAL5bir57V9aXhYXpp082LEz+cl69KndWe9OxqagogbAwJzjvfknz3DmGY8cU+PrKVQa9LeEDwNSpAqNGycE0YWFAfr6C8nKGIUMYzpxh3wti12zwoiIFI0YIPPEE12SBiRwA0vO/T6cTOHpUnmMvLQXGjgXmzdPXa43+4nA48NJLL+HSpUuw2WwYSc0WvaKpIO5P7TdlCSHcIdzSAuTmyn7V8HBZi6aVs4ddURT5jf6xx+Tyo542LPVET/4OhZBHoOx2hro62ZqlxyAG7v9CMmyY/Pzb7ehwjOLdu8DZswocDoZLl2Rj0rRp+vy5tKcocgRraan8Yn7mDENEBFNtF7KncjqdePnll3H69Gnk5+cjPDxc7UvSHM0FMWMMD3v0uatNWfX1QEWFHDdYWamgtlYgJEQfv3iM9V8VY2urXALT0yq+HLAij7j4+amz0UUNs2YJBAY64XR+v18ZkINUgoIEbt5kCAwU8PUFTp2ShQRTpuirsKM918AQpxOorTWgulou4a9dK1Q/n+spOOd49dVXcfjwYdhsNozR0txRD6K5IH5Y3W3KCguT83+LixkeeYQjPFyfN5m+4hz4+msFV67Ip8WEBP1UGAJyF/H48XJwSHfzv5ubgZMnFbS2AjNncs1ufvPxkcvVnfHzk8v0N2/KVzWMAQcPyvasykq5zK23GeAuISHAtGkCN27IiWVOJ/PK44Ed4ZzjtddeQ35+Pmw2GyZMmKD2JWmWVwVxT84H+/oCq1Zx1NTIget0Bv1+1dXyPaqfH/DNNwomTxbdDlXQEl9feRyoJ86fV3DkiAJFEbh7V4HJxHW1QtBe+yax69cZhJC7rr0hlKKiBB57TB4PnDlT9Pie4Dq/brfD/eVOLzjnePPNN7Fz507k5+dj4sSJal+SpmkuiPu6NN2bndG+vh0XlRP5xSQ4WKC8XEFoqEBAgH5C+GG0/0jeuQNcuqQgIEDg0Uf1dQMG5GjNxYs5ysvlk3RPn4YrK4HWVrmSoqWfiZ+f3F/RWxcuMOTny3frjz3GER+vj28tnHO88847sFgsyM/PR3R0tNqXpHmaC+K+6E2HMOlaUJDski0vl0MzulqOLS5m7vftenpqdpk2TU5tamkBZs/m7ifEggIF167JghAfHydmzNDXn91gAObP712o3LjBkJenoKmJYeZMjiee0O/qgcudO7Ku0t8fKClR+2r6hxAC7733Hv73f/8XNpsNMTExal+SLug6iAeiQ5jI8HV153amuhqw2RTU1DCEhMjO3VGjBukCB0lgoNzM054Q8rytr68cNzqIHSUerbqaobaWITRU4NYthooK2bk7ZozQzVz0B0VGCly/LoelqHGut78JIfCb3/wG//3f/419+/Zh+vTpal+SbmguiHsapFqelKUHbW1wF5u3tsqbrjcMEDEYgEWLBI4f5wgOloMkutPQADQ1yTICPVYYArLuMyJCfPvnFMjNNaChgWHaNI6VK7kmh4R055FHBMxmJxwOOWpTy4QQ+Oijj/DRRx9h7969mDVrltqXpCuaqkEE5MFx1xNuZ1ybspxOp8c/Bd+5A9y4oSAwUFb36eWGxDlw9KiCq1flgIi4OO51Z5d7oqIC2LvXgIYGWWag5yXbhgb5paysjCEvz4BRowQ4B9atc3Y6xeziRYarV+XZ3Zkz9fP70RNOp9yhrvafWQiBTz75BL/61a+Qm5uLOD3OiFWZ7r5/a2lcpd0upxoVFysYOlTAx4f3eMeup1MUYNEijrg49W8knqyqSrYCjRwpj8y1tOh3tOawYfIfIQTGjOFoaGCYPr3zXcg1NcCBAwpaWhiuXxcIC+PdHinTi5s3GQ4dYvDxkRvF1DoaJ4TA5s2b8Ytf/AI7d+6kEB4gmgviroJVa5uyHA6gqYkhKEj2yN67p/YV9b/+COHaWvneNTxcf6E+ciQwcqRwL9PqtXShvYgIIC2No7m5593Adjtw6BDD0KEMs2cLTJyo70A+dYqhqkqB0ylw/ryCiIjB33EthMDnn3+On/3sZ9i+fTuWLFky6NfgLTQXxB3R6qYsf3/gscc4zpxRMHGi/m8ufVFa6tptC8yeLbBkiT6OgLiMHSuQmupEc7PcXd7dFw27XdY6NjczxMRwaHWkr+vpuCthYcCSJRxXrzI0NQE3byrw8wOammTHrpaOQPVWcLD8u1YUhqCgwb8vCCHwxRdf4F//9V+RlZWFZcuWDfo1eBPNB/GDm7IYY5oIYZcZMwRiY52aqlkbTBUVDHfuyM0u164xxMVBdzfg9sMyunPxIoPNZgDncgSryaTPjU4u06bJudZFRQxlZYDDISdc6f13ZeFCjrAwAYOh66lnA8ViseCf//mfkZGRgRUrVgz6/7630VwQtw9ZLb0P7gptYurcqFECoaHyiWjWLH0/BfWE3S438fj5Mdy7J6sMb91iOHpUnleNj9dGVV9vxcQItLY60dgol/B7urvc6ZQbIgMC5FOmVgQGAnPmqLNClp2djQ0bNuCLL75AYmKiKtfgbTS3a5pzDrvdrpsQJt27fRu4d49h9GjR5Q24shK4ckVBcLDA9Old/3e16u5dOee5sRGYP18gMlLAYlFQWqrA4QAef5xj4UJ9Ld/3lRDAV18pOH+eYdgwgZUrOagYqGs5OTl48cUX8fnnn2Pt2rVqX47X0OStSmubssjDkYNAuv6+6HDIm25JCYOPjwJfX6cuq/qCgoA1a+4PWn9/+ednDPD11d+fua+am+XrDH9/oLhYwYEDcp/BpEnedQyqp/bu3Yv169dj8+bNFMKDTHNBbLVawTnH8uXL4e/vTyFMAMhzy/fusW+XbL1rolV8PEdoKODnJ1cCuiOEXGVgDLqbdtaev7/cDHf+vILbtxnsdgUVFQKrV+vnmGB/yc/Px/PPP4+PP/4Y69atU/tyvI7mgri4uBj/+Z//iZqaGiQmJsJsNmPVqlUI7K+iXR1rbQVOnZLLmjNnCowZo5+bka+vPLd86hRDaCh025HbkdBQ9KpQoLCQ4euvFSiKXMrW48oBII+6PfEER1SUwN69CgwGhsZGhrt31b4yz1JQUIB169Zh06ZN+OEPf0gPNyrQ3DtiQC5NHzt2DBaLBZmZmSgrK8Pq1athMpmQlJSEYC3tyhhEZ8/KiUaKIjB2rMDatTTtyhtlZ8t3yk4nEBPDv7fUrUdnzzKcOiX3Dzz5JNf8yMn+cvjwYaSnp+P999/Hhg0bKIRVoskgbo9zjjNnziAjIwNWqxXFxcVYuXIljEYjUlJSMHz4cPpwfeu7IAbGjuUUxB3Qc4esy5kzDIcOKWBMllb0ZDlbD1pa5NG33uy4PnFCQVmZ3LWtt5/T8ePHYTQa8e///u949dVX6T6pIs0HcXtCCBQVFSEjIwOZmZm4cOECnnjiCZjNZqSmpiIsLMyrP2ytrcDx4wru3pVHgcaO1c1ffb9xdcja7Qxz5vA+9dB6Os7l+WzGBEaP7tmZ3Joa+e+EhQmv6eq+cYNh+3YFisLg6yvw1FNOhIWpfVX94/Tp00hJScFPf/pTvP766159X/QEugri9oQQuHTpEiwWC6xWK86cOYOlS5fCbDYjLS0N4eHh9OEj33PwoIIjRxQEBgLDh3M895z+gri3mpqAHTsU3LqlYORIgeRkJ0aMkDu19VphCAAlJQzbtilwOhmCgwXS050ICVH7qh5eYWEhkpOT8S//8i/46U9/SvdBD6DbIG5PCIHr16+7Q/n48eNYvHgxTCYTjEYjxo4dSx9GAkDefPPzFdy7B8TFccyapftfj25VVQFWqwEBAUBtLcPy5U7cuCH7hefM4Zg5U58/I87lONHKSoZJk4QuNgCeP38eSUlJ2LBhA959912673kIrwji9oQQKCkpgdVqhdVqxaFDh7BgwQKYTCaYTCY88sgj9OH0co2N8vhTaGjXy7ZCAJcvy52448er15Az0JxOeUb76lWGMWMEwsMFCgoMCAwE/P0Fnn3W6RVlFVp3+fJlJCYm4kc/+hHef/99us95EK8L4vaEECgvL0dmZiYsFgsKCgowe/ZsdyhHR0fTh5V0qriYYedOBS0tcmOXyaTf9iTO5VSvgAD5587NVdDayjBpEofR2PORk96kogIoLVUQEiIQFSVUnY997do1JCUl4emnn8Zvf/tbKDTRxKN4dRC3J4TAnTt33KFss9kQGxsLk8kEs9mMqVOnUiiT+1y8yLBzp3wyHDJEYO1aZ7eNQnrAOXDlipz/PXGi6PFRoIYGuYqgx1nYD2pqksfEyssZgoOBlBTZGKWGGzduIDExEampqfjd735HIeyBKIg7IIRAbW0tsrOzYbVasXfvXkRFRcFkMiE9PR3Tp0+nD3MP3Lkjd2kzBixYwHWz49SlpQUoKFBQVcUwcybH7Nn0q9SZq1cZCgoUCCGrDWNi9P2zqqkBLBYDAIbmZiA11anKO+bS0lKsWbMGK1euxO9//3u6b3koCuIeqK+vx/bt22G1WpGbm4uxY8e6n5TnzJlDH+5O7NmjoLCQQQhg7lyB5cv1twNZCPmESOexu7Z7t4LLl+WXskmTOFJS9PdZaE8IeQb5/Hn5Xn3pUg4/v8G9hoqKCiQmJiI+Ph6bN2+GgT6kHouCuJfu3r2LnTt3wmKxYOfOnRg5ciSMRiPMZjMWLFhAodzOvn0KTp2SP48FCzgSEvR98+2rigqgvl7esPW6tH3qFMPBgwqEYFi8mGP+fO/4LDgc8kvaYL/VqqqqQnJyMubOnYvPPvsMPvQS36NRED+E5uZm5ObmwmKxICcnB0FBQTAajTCZTFi8eLHXfwNtaADOnJEzjWfN4prqgx0sFRXA7t0G1NYyREbKJ8XBfnIaDE6nPBomBPDII6LHKwitrbJFKSQE1JjUQ9XV1UhJScHUqVOxZcsWDNHjeDidoSDuJ62trcjLy4PFYsG2bdvg6+uL1NRUpKenY8mSJfTLQDp06RJDTo4BYWEC9+4BTz+tn+lND6uuDti7V0FtLcO0aQILF8qRrPRw17na2lqkpaVhwoQJ2Lp1K3z1PHFFRyiIB4DdbofNZkNGRgays7PBOUdKSgrS09OxbNky+uUgbo2NQF6erOmbMkVg2TJOT37f+uYbht27DRgxQqCykmHkSI7AQCAhQV/NYf2lvr4eRqMRo0aNQmZmJvz0uLSiUxTEA8zhcKCgoAAZGRnIyspCc3MzUlJSYDKZsGLFCgzV68FT0mNtbfK4y/Dh3S+/ukopmpvl2eWAgMG5RjWUlzPs3q2gro6hthbfHpMSmDVLYMUK73jH3FONjY1IT09HYGAgtm/fTvcVjaEgHkROpxOHDh1y1zfW1dUhMTERJpMJq1evRoCe76qkX1y/zrB3r4LmZoapU2WFoZ6foCsqgMZGhuJihsJCues6Pp4jLo6C2KWpqQlr166FoijIycmhbnYNoiBWiatT2dUUVVFRgVWrVsFsNiMxMZE6lUmHTp9m+PJLA0JCAB8fgXXrvGO8ZGurHCeqKMCUKaJXZRMOh37fK7e0tOCZZ55BW1sbdu3aRfcNjaIg9gCcc5w+fdodyq5OZZPJhOTkZOpU7qHGRjlApK0NmDuXIzxc7Svqf3fuAF9+qaCxkWH2bIEFC+jJsDNtbcCBAwrKyuRmr8ce46qOmexvra2t+MEPfoD6+nrk5uZiuDeMLNMpCmIP075T2Wq14uLFi3jyySdhNpuRkpLi9Z3KXfn6awWHDikwGAQmTxZITdVnSLW2yn+GDx/886lacu0aw/btsjVKCDmCdMQIta+qf7S1teGFF15AeXk58vLyENrTOaPEI+n47ZI2McYwY8YMvPvuuzhz5gzOnj2LhIQE/OEPf0B0dDSMRiM2b96Mqqoq0Heo+7lCiXN9B9TQofJcbV//jE4ncPMmQ2mpPNerV0OHynaohga5qU0vm4jtdjvWr1+PkpIS7Nmzh0JYB+iJWCOEELh27Zq7U/nEiRNYvHgxzGYzjEYjxowZ4/VPynfvAqdOyaXp2bM5Ro5U+4o805EjCo4eZRgyBEhI4Jg+XZ+3ACHkU3FdHcPYsfo48uRwOPDjH/8YRUVFsNlsCNfj+xcvREGsQUII3Lx5092pfPjwYSxYsMA9anPChAleH8qkcxaLgqoq+YVl1iyOJ5/U5xK+3jidTmzYsAHHjh3D/v37MXr0aLUvifQTCmKNE0KgrKwMmZmZsFqt7k5ls9kMk8mEqKgoCmVyn3PnGI4cUWAwAMuWcURF0S2gI5WVct8BACxezBERod61cM7xyiuv4MCBA7DZbBg/frx6F0P6HQWxjgghUFVVhaysLFitVnensiuUqVOZAHLJtqZGlhGEhPTs37Hb5ezw4cP1exToQXv2KCgqkr8vjz4qsHq1OisHnHO89tpr2LNnD/Lz8xEZGanKdZCBQ0GsU+07lS0WC/Ly8hAdHe3uVI6NjaWmKNIjra1yDGdZGcOECXKqlTdMaS0oUHD0qPwdiYvjWLp08IOYc44333wT2dnZsNlsiI6OHvRrIAOPgthLuDqVLRYLcnNzMX78eHen8uzZsymUSadKShgyM+XM59pa4KmnOMaO1f9to6kJOH9e/l7Exso514OJc4533nkHf/7zn2Gz2RATEzO4F0AGDQWxF2psbHR3Ku/atcvdqZyeno758+dTKPfC9esM5eUMEREC0dH6/FWqrwdychRUVCgYN05WNQYFqX1V+iaEwK9+9Sv88Y9/xL59+zB9+nS1L4kMIApiL9fc3Izdu3e7O5WHDRuGtLQ0mM1mLFq0yOs7lbtSXQ1s22ZAXR1DcLCA0ejU5TQvQL5TvnOHYdQoATq2OrCEEPjNb36D//qv/8K+ffswc+ZMtS+JDDAKYuLW2tqKvXv3wmq1Ijs7G35+fkhLS3N3Kvt4yy6dHiovB7KyDPDxYWhrEzCbOcaNo1+njgghv7j4+QE0DrlzQghs2rQJH374IfLy8jBv3jy1L4kMAgpi0qG2tjbYbDZYLBZkZWVBCIHU1FSYzWbqVP4W58CJEwouX2aIipJzn2kBoWPHjys4eZLB3x9YscI73jH3lhACH3/8Md577z3k5uYiLi5O7Usig4SCmHTL1am8detWZGVloaWlBampqTCZTFi+fLnXd58Koe+Rmg/L6QS++MKAlhaGhgaBZcsE5s+nISLtCSHw6aef4u2338auXbsQHx+v9iWRQURBTHrF1amckZGBrKws1NXVISkpCSaTCatWraJOZdIhm03BuXMKhg6Vx5/0urGtL4QQ+Pzzz/Fv//Zv2L59O5YtW6b2JZFBRkFM+oxzjqNHj7rrGysrK7F69Wp3p3IQba0l32prA0pLGfz8QMvS7QghsGXLFmzcuBHZ2dlYvny52pdEVEBBTPoF5xynTp1y1zeWlJRgxYoVMJvNSE5OxrBhw2iqF+mVxkbg9GkFDocs8QgLU/uK+t/WrVvxk5/8BBkZGUhMTFT7cohKKIhJvxNCoLCw0B3Kly5dwvLly2EymZCamorQ0FAKZdKtQ4eUb2c9Czz6qEBior7eK2dlZeGll17CF198gbS0NLUvh6iIgpgMKCEELl68CIvFAovFgsLCQiQkJMBkMiEtLQ2jRo2iUO6l8nKgqUlW++n5lfzBgwoOH1agKAJTpwokJ+sniHfs2IH169fjT3/6E5566im1L4eojIKYDBohBK5everuVD558iTi4+NhMpmoU7mHbt1iyM1V0NjIMGUKR2Kifo9MNTTIY08OBzBvnn76pffs2YMXXngBmzdvxrp169S+HOIBKIiJKlydyhaLBZmZme5OZZPJBJPJRJ3KnTh3jmHPHgPCwuSv7bPPOgd9BrLWeNLxMpvNhnXr1uGTTz7BCy+8QJ9xAoCCmHgAV6ey1WqF1WrFgQMHMGfOHHd946RJk+iG9a2aGmDvXgX19QyPPioQH889JmQ8TXW1XN52OIBFi4Tqu7ULCgrw9NNPY9OmTVi/fj19pokbBTHxKO07lS0WC/Lz8zF9+nR3KMfExHj9DaylRf4TEgJQP0fnvvpKwbFjDAYDQ3Q0R1qaeu+Yv/76azz11FP44IMP8A//8A9e/xkm96MgJh5LCIGampr7OpWnTJnirm+kTmXSlSNHFBw8qEAIefxp5Up1gvj48eMwGo34+c9/jldeeYVCmHwPBTHRBCHEfZ3Ke/bswYQJE9z1jbNmzaJQJvdpbQW++YbB4WCIjeWqlE2cPn0aKSkpeOutt/Daa69RCJMOURATTWpsbEROTg4sFgt2796NUaNGuUP5scceo1AmqissLERSUhJee+01vPnmmxTCpFMUxETzmpqasHv3blitVnenstFohNlsxsKFC6lTmQy68+fPIykpCRs2bMC7775LIUy6REFMdKWlpcXdqbxt2zYMHTrU3akcHx9Pncp9xLncIBYQ4DlHgTzVpUuXkJSUhBdffBHvvfcehTDpFgUx0S1Xp3JGRgays7MBwN2pnJCQQJ3KPdTcLNuTqqoYpk4VWLSI027tTly7dg2JiYl49tln8eGHH9IrEtIjFMTEKzgcDnz11VfYunUrsrOz0drael+nsp+fn9qX6LEuX2bIyTFg+HABhwNYu9apywKGh3Xjxg0kJiYiLS0NH330EYUw6TEKYuJ1nE4nDh486O5UbmhoQGJiIsxmM1auXEmdyg8oL2fIyZFDRMaP5zAaOfz91b4qz1JaWoo1a9Zg1apV+OSTTyiESa9QEBOvxjnHkSNH3KFcVVXl7lRes2YNdSp/q6SEobYWGDdOYMQIta/Gs1RUVCAxMRFLlizBp59+SpsDSa9REBPyLc45Tp486S6lKCkpwcqVK2EymahTmXSoqqoKSUlJmDdvHj7//HMKYdInFMSEdMDVqbx161ZYrVZcuXIFy5cvh9FopE5lAgC4c+cOUlJSEBsbiy1bttCOfNJnFMSEdEMIgQsXLiAjIwOZmZkoLCzEsmXL3J3KI0eOpFD2MrW1tUhNTUVkZCT++te/0g588lAoiAnpBVensiuUT548iSVLlrg7lUePHk2hrHP19fUwGo0IDw+H1WqlHffkoVEQE9JHQgjcuHHD3al85MgRxMXFuTuVx48fT6GsM42NjTCbzQgODnYPjCHkYVEQE9IPhBAoLS11dyofPHgQc+fOddc3Tpw4kUK5l+rrgWvXGIYOBWJiBNTeB9XU1IS1a9fCYDBgx44dCAwMVPeCiG5QEBPSz4QQqKysdHcq79+/H48++qi7vnHKlCkUyt3gHNixQ8GlSwp8fYFVq5yIjVXvVtXS0oJnnnkGdrsdO3fuRLAaVU5EtyiICRlArk5lVyh/+eWXiImJcTdFxcbGUih3wOEA/vIXAxoaGJqagBUrnJg7V51bVWtrK37wgx+gvr4eubm5GD58uCrXQfSLgpiQQeLqVN62bRusVityc3MRGRnpDuWZM2fSRKZ2Ll5kOHZMwbBhAgkJHCEhg38NbW1teOGFF1BRUYG9e/ciNDR08C+C6B4FMSEqaWhoQE5ODqxWK3bt2oWIiAh3KM+bN49CGfLJWFGgSsmE3W7Hj370IxQXF+PLL7/ECBopRgYIBTEhHsDVqWyxWJCTk4OQkBAYjUaYTCbqVFaBw+HAj3/8Y3zzzTfYt28fwsPD1b4komMUxIR4GFenssViwfbt2zF06FAYjUaYzWbqVB4ETqcTGzZswIkTJ2Cz2TB69Gi1L4noHAUxIR6sra0N+/btc3cqM8aQmpqK9PR0JCQkYMiQIWpfoq44nU688sorOHjwIPLz8zFu3Di1L4l4AQpiQjTC4XBg//797k7ltrY2pKSkwGw248knn6QJTw+Jc46NGzciLy8PNpsNkZGRal8S8RIUxIRokNPpxIEDB9xTvRobG5GUlOTuVPanwuBe4ZzjjTfewLZt25Cfn4+oqCi1L4l4EQpiQjSOc47Dhw+7Q/n27dtYs2YNzGYzVq9eTZ3K3eCc4+2338Zf/vIX2Gw2xMTEqH1JxMtQEBOiI65O5YyMDFitVty6dQurVq26r1OZfEcIgV/+8pf4n//5H9hsNsTGxqp9ScQLURATolOcc5w7d84dylevXsWKFSvcncohISFePdVLCIFf//rX+Pjjj7Fv3z7MnDlT7UsiXoqCmBAvIITA+fPn3fWNRUVFWLZsGcxmM1JTU72uU1kIgU2bNuHDDz9EXl4e5s2bp/YlES9GQUyIlxFC4MqVK+5QPnXqFJYsWQKz2Qyj0YiIiAhdh7IQAh9//DHef/997N69G3FxcWpfEvFyFMSEeLH2ncpWqxVHjhzBokWL3J3K48aN01UoCyHw6aef4u2338auXbsQHx+v9iURQkFMCJHadypbLBYcOnQI8+bNc4ey1juVhRD47LPP8MYbb2DHjh1ISEhQ+5IIAUBBTAjpgKtTOTMzExaLBV999RVmzJjh7lSePHmypkJZCIEtW7Zg48aN2LZtG5588km1L4kQNwpiQkiXhBCorq5Gdna2u1N56tSp7vnXWuhU3rp1K37yk5/AYrFgzZo1al8OIfehICaE9JgQAnV1de5O5T179iAyMhImkwnp6emYMWOGx9U3ZmVl4aWXXsKf//xnpKamqn05hHwPBTEhpM8aGhqwY8cOWK1W7N69GxEREe7la0/oVN6xYwf+9m//Fn/605+Qnp6u6rUQ0hkKYkJIv2hqasKuXbvcncqhoaHu5eu4uLhB71TOzc3FD3/4Q/zxj3/Es88+O6j/24T0BgUxIaTftbS0YM+ePbBYLNixYwf8/f2RlpY2aJ3KNpsN69atw+9//3s8//zzHv8Om3g3CmJCyIBqa2tDXl4eLBYLtm3bBkVR3J3KS5cu7fdO5YKCAjz99NPYtGkT1q9fTyFMPB4FMSFk0Njtduzfvx8ZGRnIysqC3W5HamoqzGYznnjiiYfuVP7666+Rnp6OX//61/j7v/97CmGiCRTEhBBVuDqVXaM27969i+TkZJjNZqxYsaLXncrHjx+H0WjEL37xC/zjP/4jhTDRDApiQojqnE7nfZ3Kd+7cQWJiIkwmE9asWYPAwMAu//3Tp08jJSUFP/vZz7Bx40YKYaIpFMSEEI/COceJEyfcT8qlpaXuTuWkpKTvdSoXFhYiKSkJr7/+Ot544w0KYaI5FMSEEI/FOcfZs2fdoezqVDaZTEhJSUFFRQWSkpLw8ssv45133qEQJppEQUwI0YT2ncpWqxVFRUUwGAz4p3/6J3zwwQcUwkSzKIgJIZojhEBRURH+4z/+A3/4wx9Un+BFyMOgICaEEEJURF8jCSGEEBVREBNCCCEqoiAmhBBCVERBTAghhKiIgpgQQghREQUxIYQQoiIKYkIIIURFFMSEEEKIiiiICSGEEBVREBNCCCEqoiAmhBBCVERBTAghhKiIgpgQQghREQUxIYQQoiIKYkIIIURFFMSEEEKIiiiICSGEEBVREBNCCCEqoiAmhBBCVERBTAghhKiIgpgQQghREQUxIYQQoiIKYkIIIURFFMSEEEKIiiiICSGEEBVREBNCCCEqoiAmhBBCVERBTAghhKiIgpgQQghREQUxIYQQoiIKYkIIIURFFMSEEEKIiiiICSGEEBVREBNCCCEqoiAmhBBCVERBTAghhKiIgpgQQghR0f8Dj6gaR6GGPecAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def plot_hex8_mesh(\n", + " pts_coords: jnp.ndarray, # (n_points, 3)\n", + " hex_cells: jnp.ndarray, # (n_hex, 8)\n", + " ax, # noqa: ANN001\n", + " plot_cells: bool = True,\n", + ") -> None:\n", + " \"\"\"Plot hexahedral mesh with optional cell edges.\n", + "\n", + " Args:\n", + " pts_coords: Array of point coordinates, shape (n_points, 3).\n", + " hex_cells: Array of hexahedral cell connectivity, shape (n_hex, 8).\n", + " ax: Matplotlib 3D axis object for plotting.\n", + " plot_cells: Whether to plot cell edges.\n", + " \"\"\"\n", + " ax.scatter(\n", + " pts_coords[:, 0],\n", + " pts_coords[:, 1],\n", + " pts_coords[:, 2],\n", + " color=\"blue\",\n", + " s=3,\n", + " alpha=0.3,\n", + " )\n", + "\n", + " # # Plot hex cells\n", + " if plot_cells:\n", + " for cell in hex_cells:\n", + " # Get the coordinates of the cell's corners\n", + " corners = pts_coords[cell]\n", + " # print(f\"Cells {cell}: Corners {corners}\")\n", + " for corner in [\n", + " (0, 1),\n", + " (1, 2),\n", + " (2, 3),\n", + " (3, 0), # bottom face\n", + " (4, 5),\n", + " (5, 6),\n", + " (6, 7),\n", + " (7, 4), # top face\n", + " (0, 4),\n", + " (1, 5),\n", + " (2, 6),\n", + " (3, 7), # vertical edges\n", + " ]:\n", + " hexagon = [corners[corner[0]], corners[corner[1]]]\n", + " ax.plot3D(\n", + " *zip(*hexagon, strict=True), color=\"red\", linewidth=1, alpha=0.5\n", + " )\n", + "\n", + "\n", + "fig, axs = plt.subplots(1, 1, subplot_kw={\"projection\": \"3d\"}, figsize=(12, 6))\n", + "plt.suptitle(\"HEX8 Mesh Subdivision\")\n", + "# remove the axis ticks\n", + "axs.set_xticks([])\n", + "axs.set_yticks([])\n", + "axs.set_zticks([])\n", + "# remove the grid\n", + "axs.grid(False)\n", + "\n", + "pts = mesher_out[\"mesh\"][\"points\"][: mesher_out[\"mesh\"][\"n_points\"]]\n", + "hex_cells = mesher_out[\"mesh\"][\"faces\"][: mesher_out[\"mesh\"][\"n_faces\"]]\n", + "plot_hex8_mesh(pts, hex_cells, ax=axs, plot_cells=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "id": "c81af0a4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "UnstructuredGrid (0x7ddc67030ac0)\n", + " N Cells: 1184\n", + " N Points: 1645\n", + " X Bounds: -5.000e+00, 5.000e+00\n", + " Y Bounds: -2.500e+00, 2.500e+00\n", + " Z Bounds: -2.500e+00, 2.500e+00\n", + " N Arrays: 0\n" + ] + } + ], + "source": [ + "# Lets export it to a .vtk using pyvista\n", + "import numpy as np\n", + "import pyvista as pv\n", + "\n", + "\n", + "def hex_to_pyvista(pts: np.ndarray, faces: np.ndarray) -> pv.UnstructuredGrid:\n", + " \"\"\"Convert hex mesh defined by points and faces into a PyVista UnstructuredGrid.\n", + "\n", + " Args:\n", + " pts: Array of point coordinates, shape (N, 3).\n", + " faces: Array of hexahedral cell connectivity, shape (M, 8).\n", + "\n", + " Returns:\n", + " PyVista mesh representing the hexahedral grid.\n", + " \"\"\"\n", + " # Define the cell type for hexahedrons (VTK_HEXAHEDRON = 12)\n", + " cell_type = pv.CellType.HEXAHEDRON\n", + " cell_types = np.array([cell_type] * faces.shape[0], dtype=np.uint8)\n", + "\n", + " # Prepare the cells array: [number_of_points, i0, i1, i2, i3, i4, i5, i6, i7]\n", + " n_cells = faces.shape[0]\n", + " cells = np.empty((n_cells, 9), dtype=np.int64)\n", + " cells[:, 0] = 8 # Each cell has 8 points\n", + " cells[:, 1:9] = faces\n", + "\n", + " # Flatten the cells array for PyVista\n", + " cells = cells.flatten()\n", + "\n", + " return pv.UnstructuredGrid(cells, cell_types, pts)\n", + "\n", + "\n", + "# convert arrays to numpy\n", + "pts_np = np.array(pts)\n", + "cells_np = np.array(hex_cells)\n", + "\n", + "hex_mesh = hex_to_pyvista(pts_np, cells_np)\n", + "\n", + "print(hex_mesh)\n", + "\n", + "hex_mesh.save(\"fem_shapeopt_mesh.vtk\")" + ] + }, + { + "cell_type": "markdown", + "id": "87823f98", + "metadata": {}, + "source": [ + "### FEM Tesseract\n", + "\n", + "Now that we have a density field, we compute the *compliance* of the structure (~stiffness against deformation). That is, we find the most stable configuration of the structure under a given load. The compliance is computed using a finite element method (FEM) solver, which is implemented in the FEM Tesseract. The FEM Tesseract takes the density field as input and returns the compliance of the structure.\n", + "\n", + "The compliance Tesseract is using the jax-fem finite element library, which is fully auto-differentiable. Inside the Tesseract the boundary conditions are already hard coded, where the entire left side is subject to a Dirichlet boundary condition and bottom right side to a Neumann boundary condition." + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "id": "dbb96ccf", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Lets setup the boundary conditions\n", + "\n", + "dirichlet_mask = pts[:, 0] <= -Lx / 2 + 1e-5\n", + "van_neumann_mask = jnp.logical_and(\n", + " jnp.isclose(pts[:, 0], Lx / 2, atol=0.1),\n", + " jnp.isclose(pts[:, 2], -Lz / 2, atol=0.1),\n", + ")\n", + "\n", + "\n", + "fig, axs = plt.subplots(1, 2, subplot_kw={\"projection\": \"3d\"}, figsize=(12, 6))\n", + "# set the colormap to Set1\n", + "plt.suptitle(\"Boundary Conditions Visualization\")\n", + "# remove the axis ticks\n", + "colors = jnp.where(dirichlet_mask, 0.1, 0.2)\n", + "\n", + "axs[0].scatter(\n", + " pts[:, 0],\n", + " pts[:, 1],\n", + " pts[:, 2],\n", + " c=colors,\n", + " s=10,\n", + " alpha=1.0,\n", + " cmap=\"Set1\",\n", + ")\n", + "axs[0].set_title(\"Dirichlet Boundary (x = -Lx/2)\")\n", + "\n", + "axs[1].scatter(\n", + " pts[:, 0],\n", + " pts[:, 1],\n", + " pts[:, 2],\n", + " c=jnp.where(van_neumann_mask, 0.1, 0.2),\n", + " s=10,\n", + " alpha=1.0,\n", + " cmap=\"Set1\",\n", + ")\n", + "axs[1].set_title(\"Van Neumann Boundary (x = Lx/2)\")\n", + "\n", + "# convert to int arrays for tesseract input\n", + "dirichlet_mask = dirichlet_mask.astype(jnp.int32)\n", + "van_neumann_mask = van_neumann_mask.astype(jnp.int32)" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "id": "1479ada1", + "metadata": {}, + "outputs": [], + "source": [ + "# fem_tess = Tesseract.from_image(\"structure-jax-fem\")\n", + "# fem_tess.serve()\n", + "fem_tess = Tesseract.from_tesseract_api(\"fem_tess/tesseract_api.py\")" + ] + }, + { + "cell_type": "code", + "execution_count": 99, + "id": "9539f59e", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:34:50][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:34:50][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:34:50][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:34:51][DEBUG] jax_fem: Done pre-computations, took 0.9195077419281006 [s]\n", + "[11-04 16:34:51][INFO] jax_fem: Solving a problem with 1184 cells, 1645x3 = 4935 dofs.\n", + "[11-04 16:34:51][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 1184 elements.\n", + "(1184, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:34:53][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:34:53][DEBUG] jax_fem: Start timing\n", + "[11-04 16:34:54][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:34:54][DEBUG] jax_fem: Function split_and_compute_cell took 0.5486 seconds\n", + "[11-04 16:34:56][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:34:56][DEBUG] jax_fem: Before, l_2 res = 130.86028596931058, relative l_2 res = 1.0\n", + "[11-04 16:34:56][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:34:56][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:34:56][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:34:56][DEBUG] jax_fem: Function split_and_compute_cell took 0.0198 seconds\n", + "[11-04 16:34:56][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (22794,), indices shape = (22794,), indptr shape = (4936,), b shape = (4935,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:34:56][DEBUG] jax_fem: l_2 res = 3.939425676055883e-13, relative l_2 res = 3.0104058285336156e-15\n", + "[11-04 16:34:57][INFO] jax_fem: Solve took 3.098804235458374 [s]\n", + "[11-04 16:34:57][INFO] jax_fem: max of dofs = 0.9350113207375988\n", + "[11-04 16:34:57][INFO] jax_fem: min of dofs = -2.223474368276938\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Compliance: 1527.1154\n" + ] + } + ], + "source": [ + "compliance = apply_tesseract(\n", + " fem_tess,\n", + " {\n", + " # unsqueeze rho to 1D array\n", + " \"rho\": jnp.expand_dims(mesher_out[\"mesh_cell_values\"], axis=-1),\n", + " # \"rho\" : rho.reshape(Nx*Ny*Nz, 1),\n", + " \"Lx\": Lx,\n", + " \"Ly\": Ly,\n", + " \"Lz\": Lz,\n", + " \"Nx\": Nx,\n", + " \"Ny\": Ny,\n", + " \"Nz\": Nz,\n", + " \"hex_mesh\": mesher_out[\"mesh\"],\n", + " \"use_regular_grid\": False,\n", + " \"dirichlet_mask\": dirichlet_mask,\n", + " \"dirichlet_values\": jnp.array([0.0]),\n", + " \"van_neumann_mask\": van_neumann_mask,\n", + " \"van_neumann_values\": jnp.array([[0.0, 0.0, 10.0]]),\n", + " },\n", + ")[\"compliance\"]\n", + "print(f\"Compliance: {compliance:.4f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "5911b4e7", + "metadata": {}, + "source": [ + "## Step 2: Gradient-based parametric shape optimization\n", + "\n", + "Now that we have all the components of the pipeline, we can compose them together and define the loss function for the optimization. The loss function is simply the compliance of the structure, which we can compute by applying the FEM Tesseract to the density field obtained from the design space Tesseract.\n", + "\n", + "**This function looks trivial, but it is actually a complex pipeline that involves several components, each of which is differentiable.** The complexity is hidden behind the Tesseract implementation, which allows us to compose the components together and use them as a single function, without worrying about the details of the implementation." + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "id": "f9994efc", + "metadata": {}, + "outputs": [], + "source": [ + "from typing import TypeVar\n", + "T = TypeVar(\"T\")\n", + "\n", + "def stop_gradient_(x: T) -> T:\n", + " \"\"\"Stops gradient computation.\n", + "\n", + " We cannot use jax.lax.stop_gradient directly because Tesseract meshes are\n", + " nested dictionaries with arrays and integers, and jax.lax.stop_gradient\n", + " does not support integers.\n", + " Args:\n", + " x: Input value.\n", + " Returns:\n", + " Value with stopped gradients.\n", + "\"\"\"\n", + "\n", + " def stop(x):\n", + " return jax._src.ad_util.stop_gradient_p.bind(x)\n", + "\n", + " return jax.tree_util.tree_map(stop, x)\n", + "\n", + "def loss(\n", + " \n", + " params: jnp.ndarray,\n", + " van_neumann_mask: jnp.ndarray,\n", + " dirichlet_mask: jnp.ndarray,\n", + " ) -> float:\n", + " \"\"\"Compute structural compliance for given bar parameters.\n", + "\n", + " Args:\n", + " params: Bar parameter array with shape (n_chains, n_nodes, 3).\n", + "\n", + " Returns:\n", + " Structural compliance (scalar). Lower values indicate better performance.\n", + " \"\"\"\n", + " # -- Tess 1 (design) --\n", + " # Generate signed distance field from design parameters\n", + " sdf = apply_tesseract(\n", + " design_tess,\n", + " {\n", + " \"bar_params\": params,\n", + " \"bar_radius\": bar_radius,\n", + " \"Lx\": Lx,\n", + " \"Ly\": Ly,\n", + " \"Lz\": Lz,\n", + " \"Nx\": Nx,\n", + " \"Ny\": Ny,\n", + " \"Nz\": Nz,\n", + " \"epsilon\": 1e-2, # epsilon for finite difference\n", + " \"normalize_jacobian\": True,\n", + " },\n", + " )[\"sdf\"]\n", + "\n", + " # -- Local JAX code --\n", + " # Convert SDF to material density distribution\n", + " rho = sdf_to_rho(sdf)\n", + "\n", + " sizing = sizing_field(sdf, min_size=Lx / 40, max_size=Lx / 6, scale=5.0)\n", + "\n", + " sizing = jax.lax.stop_gradient(sizing)\n", + "\n", + " mesher_out = apply_tesseract(\n", + " mesher,\n", + " {\n", + " \"Lx\": Lx,\n", + " \"Ly\": Ly,\n", + " \"Lz\": Lz,\n", + " \"sizing_field\": sizing,\n", + " \"field_values\": rho,\n", + " \"max_subdivision_levels\": 5,\n", + " \"max_points\": 10000,\n", + " \"max_cells\": 10000,\n", + " },\n", + " )\n", + "\n", + " mesh = stop_gradient_(mesher_out[\"mesh\"])\n", + "\n", + " van_neumann_mask = jax.lax.stop_gradient(van_neumann_mask)\n", + " dirichlet_mask = jax.lax.stop_gradient(dirichlet_mask)\n", + " dirichlet_values = jnp.array([0.0])\n", + " van_neumann_values = jnp.array([[0.0, 0.0, 10.0]])\n", + "\n", + " # Instead of passing all inputs and trying to stop_gradient on them,\n", + " # we need to wrap the tesseract call to only allow gradients w.r.t. rho\n", + " c = apply_tesseract(\n", + " fem_tess,\n", + " {\n", + " \"rho\": jnp.expand_dims(mesher_out[\"mesh_cell_values\"], axis=-1),\n", + " \"dirichlet_mask\": dirichlet_mask,\n", + " \"dirichlet_values\": dirichlet_values,\n", + " \"van_neumann_mask\": van_neumann_mask,\n", + " \"van_neumann_values\": van_neumann_values,\n", + " \"hex_mesh\": mesh,\n", + " \"Lx\": Lx,\n", + " \"Ly\": Ly,\n", + " \"Lz\": Lz,\n", + " \"Nx\": Nx,\n", + " \"Ny\": Ny,\n", + " \"Nz\": Nz,\n", + " \"use_regular_grid\": False,\n", + " },\n", + " )[\"compliance\"]\n", + "\n", + "\n", + " return c" + ] + }, + { + "cell_type": "markdown", + "id": "a5782b48", + "metadata": {}, + "source": [ + "Now we can use JAX's `grad` function to compute the gradient of the compliance with respect to the design variables. We use a simple gradient descent optimizer to perform the optimization towards a local minimum. This is not a very sophisticated optimization approach, but it serves as a good starting point. The optimization process will take a few minutes to run." + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "id": "da8ce026", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:36:37][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:36:37][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:36:37][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:36:37][DEBUG] jax_fem: Done pre-computations, took 0.6360824108123779 [s]\n", + "[11-04 16:36:37][INFO] jax_fem: Solving a problem with 3424 cells, 5121x3 = 15363 dofs.\n", + "[11-04 16:36:37][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-04 16:36:39][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:36:39][DEBUG] jax_fem: Start timing\n", + "[11-04 16:36:39][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3424 elements.\n", + "(3424, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:36:40][DEBUG] jax_fem: Function split_and_compute_cell took 0.4072 seconds\n", + "[11-04 16:36:40][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:36:40][DEBUG] jax_fem: Before, l_2 res = 96.63717703192317, relative l_2 res = 1.0\n", + "[11-04 16:36:40][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:36:40][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:36:40][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:36:40][DEBUG] jax_fem: Function split_and_compute_cell took 0.0460 seconds\n", + "[11-04 16:36:40][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33546,), indices shape = (33546,), indptr shape = (15364,), b shape = (15363,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:36:41][DEBUG] jax_fem: l_2 res = 2.047406853443393e-13, relative l_2 res = 2.118653417169928e-15\n", + "[11-04 16:36:41][INFO] jax_fem: Solve took 1.4616215229034424 [s]\n", + "[11-04 16:36:41][INFO] jax_fem: max of dofs = 0.9571990951695749\n", + "[11-04 16:36:41][INFO] jax_fem: min of dofs = -2.2763869180264815\n", + "[11-04 16:36:43][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:36:43][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:36:43][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:36:43][DEBUG] jax_fem: Done pre-computations, took 0.6100189685821533 [s]\n", + "[11-04 16:36:43][INFO] jax_fem: Solving a problem with 3424 cells, 5121x3 = 15363 dofs.\n", + "[11-04 16:36:43][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-04 16:36:45][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:36:45][DEBUG] jax_fem: Start timing\n", + "[11-04 16:36:45][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3424 elements.\n", + "(3424, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:36:45][DEBUG] jax_fem: Function split_and_compute_cell took 0.3887 seconds\n", + "[11-04 16:36:46][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:36:46][DEBUG] jax_fem: Before, l_2 res = 96.63717703192317, relative l_2 res = 1.0\n", + "[11-04 16:36:46][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:36:46][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:36:46][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:36:46][DEBUG] jax_fem: Function split_and_compute_cell took 0.0365 seconds\n", + "[11-04 16:36:46][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33546,), indices shape = (33546,), indptr shape = (15364,), b shape = (15363,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:36:46][DEBUG] jax_fem: l_2 res = 2.047406853443393e-13, relative l_2 res = 2.118653417169928e-15\n", + "[11-04 16:36:46][INFO] jax_fem: Solve took 1.3570334911346436 [s]\n", + "[11-04 16:36:46][INFO] jax_fem: max of dofs = 0.9571990951695749\n", + "[11-04 16:36:46][INFO] jax_fem: min of dofs = -2.2763869180264815\n", + "[11-04 16:36:48][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 16:36:48][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:36:48][DEBUG] jax_fem: Function split_and_compute_cell took 0.0332 seconds\n", + "[11-04 16:36:48][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:36:49][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:36:49][DEBUG] jax_fem: Computing cell residual...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33546,), indices shape = (33546,), indptr shape = (15364,), b shape = (15363,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:36:49][DEBUG] jax_fem: Function split_and_compute_cell took 0.3472 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 1, Loss: 816.03\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:37:02][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:37:02][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:37:02][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:37:04][DEBUG] jax_fem: Done pre-computations, took 1.3600070476531982 [s]\n", + "[11-04 16:37:04][INFO] jax_fem: Solving a problem with 3277 cells, 4946x3 = 14838 dofs.\n", + "[11-04 16:37:04][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3277 elements.\n", + "(3277, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:37:07][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:37:07][DEBUG] jax_fem: Start timing\n", + "[11-04 16:37:08][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:37:08][DEBUG] jax_fem: Function split_and_compute_cell took 0.5449 seconds\n", + "[11-04 16:37:10][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:37:10][DEBUG] jax_fem: Before, l_2 res = 96.63717703192316, relative l_2 res = 1.0\n", + "[11-04 16:37:10][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:37:10][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:37:10][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:37:10][DEBUG] jax_fem: Function split_and_compute_cell took 0.0388 seconds\n", + "[11-04 16:37:11][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33021,), indices shape = (33021,), indptr shape = (14839,), b shape = (14838,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:37:11][DEBUG] jax_fem: l_2 res = 1.758447164862047e-13, relative l_2 res = 1.8196383823185987e-15\n", + "[11-04 16:37:11][INFO] jax_fem: Solve took 3.540022373199463 [s]\n", + "[11-04 16:37:11][INFO] jax_fem: max of dofs = 0.9408012578050927\n", + "[11-04 16:37:11][INFO] jax_fem: min of dofs = -2.2784910411303168\n", + "[11-04 16:37:13][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:37:13][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:37:13][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:37:15][DEBUG] jax_fem: Done pre-computations, took 1.5175940990447998 [s]\n", + "[11-04 16:37:15][INFO] jax_fem: Solving a problem with 3277 cells, 4946x3 = 14838 dofs.\n", + "[11-04 16:37:15][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3277 elements.\n", + "(3277, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:37:19][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:37:19][DEBUG] jax_fem: Start timing\n", + "[11-04 16:37:19][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:37:19][DEBUG] jax_fem: Function split_and_compute_cell took 0.5409 seconds\n", + "[11-04 16:37:21][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:37:21][DEBUG] jax_fem: Before, l_2 res = 96.63717703192316, relative l_2 res = 1.0\n", + "[11-04 16:37:21][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:37:21][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:37:22][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:37:22][DEBUG] jax_fem: Function split_and_compute_cell took 0.0307 seconds\n", + "[11-04 16:37:22][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33021,), indices shape = (33021,), indptr shape = (14839,), b shape = (14838,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:37:22][DEBUG] jax_fem: l_2 res = 1.758447164862047e-13, relative l_2 res = 1.8196383823185987e-15\n", + "[11-04 16:37:22][INFO] jax_fem: Solve took 3.488823413848877 [s]\n", + "[11-04 16:37:22][INFO] jax_fem: max of dofs = 0.9408012578050927\n", + "[11-04 16:37:22][INFO] jax_fem: min of dofs = -2.2784910411303168\n", + "[11-04 16:37:25][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 16:37:25][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:37:25][DEBUG] jax_fem: Function split_and_compute_cell took 0.0308 seconds\n", + "[11-04 16:37:25][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:37:25][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33021,), indices shape = (33021,), indptr shape = (14839,), b shape = (14838,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:37:26][DEBUG] jax_fem: Computing cell residual...\n", + "[11-04 16:37:26][DEBUG] jax_fem: Function split_and_compute_cell took 0.4678 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 2, Loss: 804.68\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:37:51][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:37:51][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:37:51][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:37:52][DEBUG] jax_fem: Done pre-computations, took 1.3857941627502441 [s]\n", + "[11-04 16:37:52][INFO] jax_fem: Solving a problem with 3256 cells, 4885x3 = 14655 dofs.\n", + "[11-04 16:37:52][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3256 elements.\n", + "(3256, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:37:56][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:37:56][DEBUG] jax_fem: Start timing\n", + "[11-04 16:37:56][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:37:56][DEBUG] jax_fem: Function split_and_compute_cell took 0.4919 seconds\n", + "[11-04 16:37:58][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:37:58][DEBUG] jax_fem: Before, l_2 res = 96.49250907433589, relative l_2 res = 1.0\n", + "[11-04 16:37:58][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:37:58][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:37:59][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:37:59][DEBUG] jax_fem: Function split_and_compute_cell took 0.0374 seconds\n", + "[11-04 16:37:59][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32820,), indices shape = (32820,), indptr shape = (14656,), b shape = (14655,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:37:59][DEBUG] jax_fem: l_2 res = 2.2481745772707618e-13, relative l_2 res = 2.329895448711789e-15\n", + "[11-04 16:37:59][INFO] jax_fem: Solve took 3.526244640350342 [s]\n", + "[11-04 16:37:59][INFO] jax_fem: max of dofs = 0.926446579491879\n", + "[11-04 16:37:59][INFO] jax_fem: min of dofs = -2.2755912246771377\n", + "[11-04 16:38:01][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:38:01][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:38:01][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:38:03][DEBUG] jax_fem: Done pre-computations, took 1.55104398727417 [s]\n", + "[11-04 16:38:03][INFO] jax_fem: Solving a problem with 3256 cells, 4885x3 = 14655 dofs.\n", + "[11-04 16:38:03][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3256 elements.\n", + "(3256, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:38:07][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:38:07][DEBUG] jax_fem: Start timing\n", + "[11-04 16:38:07][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:38:08][DEBUG] jax_fem: Function split_and_compute_cell took 0.5079 seconds\n", + "[11-04 16:38:09][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:38:10][DEBUG] jax_fem: Before, l_2 res = 96.49250907433589, relative l_2 res = 1.0\n", + "[11-04 16:38:10][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:38:10][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:38:10][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:38:10][DEBUG] jax_fem: Function split_and_compute_cell took 0.0326 seconds\n", + "[11-04 16:38:10][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32820,), indices shape = (32820,), indptr shape = (14656,), b shape = (14655,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:38:10][DEBUG] jax_fem: l_2 res = 2.2481745772707618e-13, relative l_2 res = 2.329895448711789e-15\n", + "[11-04 16:38:10][INFO] jax_fem: Solve took 3.605653762817383 [s]\n", + "[11-04 16:38:10][INFO] jax_fem: max of dofs = 0.926446579491879\n", + "[11-04 16:38:10][INFO] jax_fem: min of dofs = -2.2755912246771377\n", + "[11-04 16:38:13][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 16:38:13][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:38:13][DEBUG] jax_fem: Function split_and_compute_cell took 0.0322 seconds\n", + "[11-04 16:38:13][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:38:13][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32820,), indices shape = (32820,), indptr shape = (14656,), b shape = (14655,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:38:14][DEBUG] jax_fem: Computing cell residual...\n", + "[11-04 16:38:14][DEBUG] jax_fem: Function split_and_compute_cell took 0.4608 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 3, Loss: 793.81\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:38:32][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:38:32][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:38:32][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:38:33][DEBUG] jax_fem: Done pre-computations, took 1.4015722274780273 [s]\n", + "[11-04 16:38:33][INFO] jax_fem: Solving a problem with 3249 cells, 4939x3 = 14817 dofs.\n", + "[11-04 16:38:33][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3249 elements.\n", + "(3249, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:38:37][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:38:37][DEBUG] jax_fem: Start timing\n", + "[11-04 16:38:37][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:38:37][DEBUG] jax_fem: Function split_and_compute_cell took 0.5143 seconds\n", + "[11-04 16:38:39][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:38:39][DEBUG] jax_fem: Before, l_2 res = 96.5909068597192, relative l_2 res = 1.0\n", + "[11-04 16:38:39][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:38:40][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:38:40][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:38:40][DEBUG] jax_fem: Function split_and_compute_cell took 0.0368 seconds\n", + "[11-04 16:38:40][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33045,), indices shape = (33045,), indptr shape = (14818,), b shape = (14817,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:38:40][DEBUG] jax_fem: l_2 res = 1.5953068187842123e-13, relative l_2 res = 1.6516118034807423e-15\n", + "[11-04 16:38:40][INFO] jax_fem: Solve took 3.6004817485809326 [s]\n", + "[11-04 16:38:40][INFO] jax_fem: max of dofs = 0.9096560910384903\n", + "[11-04 16:38:40][INFO] jax_fem: min of dofs = -2.269967389165872\n", + "[11-04 16:38:42][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:38:42][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:38:42][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:38:44][DEBUG] jax_fem: Done pre-computations, took 1.5345971584320068 [s]\n", + "[11-04 16:38:44][INFO] jax_fem: Solving a problem with 3249 cells, 4939x3 = 14817 dofs.\n", + "[11-04 16:38:44][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3249 elements.\n", + "(3249, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:38:48][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:38:48][DEBUG] jax_fem: Start timing\n", + "[11-04 16:38:48][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:38:49][DEBUG] jax_fem: Function split_and_compute_cell took 0.5153 seconds\n", + "[11-04 16:38:50][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:38:51][DEBUG] jax_fem: Before, l_2 res = 96.5909068597192, relative l_2 res = 1.0\n", + "[11-04 16:38:51][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:38:51][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:38:51][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:38:51][DEBUG] jax_fem: Function split_and_compute_cell took 0.0338 seconds\n", + "[11-04 16:38:51][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33045,), indices shape = (33045,), indptr shape = (14818,), b shape = (14817,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:38:51][DEBUG] jax_fem: l_2 res = 1.5953068187842123e-13, relative l_2 res = 1.6516118034807423e-15\n", + "[11-04 16:38:51][INFO] jax_fem: Solve took 3.568021774291992 [s]\n", + "[11-04 16:38:51][INFO] jax_fem: max of dofs = 0.9096560910384903\n", + "[11-04 16:38:51][INFO] jax_fem: min of dofs = -2.269967389165872\n", + "[11-04 16:38:54][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 16:38:54][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:38:54][DEBUG] jax_fem: Function split_and_compute_cell took 0.0346 seconds\n", + "[11-04 16:38:54][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:38:54][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33045,), indices shape = (33045,), indptr shape = (14818,), b shape = (14817,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:38:55][DEBUG] jax_fem: Computing cell residual...\n", + "[11-04 16:38:55][DEBUG] jax_fem: Function split_and_compute_cell took 0.3824 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 4, Loss: 780.51\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:39:12][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:39:12][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:39:12][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:39:13][DEBUG] jax_fem: Done pre-computations, took 1.394620656967163 [s]\n", + "[11-04 16:39:13][INFO] jax_fem: Solving a problem with 3354 cells, 5022x3 = 15066 dofs.\n", + "[11-04 16:39:13][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3354 elements.\n", + "(3354, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:39:17][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:39:17][DEBUG] jax_fem: Start timing\n", + "[11-04 16:39:17][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:39:18][DEBUG] jax_fem: Function split_and_compute_cell took 0.6126 seconds\n", + "[11-04 16:39:19][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:39:20][DEBUG] jax_fem: Before, l_2 res = 96.4128491694942, relative l_2 res = 1.0\n", + "[11-04 16:39:20][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:39:20][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:39:20][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:39:20][DEBUG] jax_fem: Function split_and_compute_cell took 0.0395 seconds\n", + "[11-04 16:39:20][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33339,), indices shape = (33339,), indptr shape = (15067,), b shape = (15066,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:39:20][DEBUG] jax_fem: l_2 res = 2.357195409951208e-13, relative l_2 res = 2.4448975735664117e-15\n", + "[11-04 16:39:21][INFO] jax_fem: Solve took 3.6530914306640625 [s]\n", + "[11-04 16:39:21][INFO] jax_fem: max of dofs = 0.8925549936165259\n", + "[11-04 16:39:21][INFO] jax_fem: min of dofs = -2.2669055710635932\n", + "[11-04 16:39:23][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:39:23][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:39:23][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:39:24][DEBUG] jax_fem: Done pre-computations, took 1.5722260475158691 [s]\n", + "[11-04 16:39:24][INFO] jax_fem: Solving a problem with 3354 cells, 5022x3 = 15066 dofs.\n", + "[11-04 16:39:24][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3354 elements.\n", + "(3354, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:39:28][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:39:28][DEBUG] jax_fem: Start timing\n", + "[11-04 16:39:28][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:39:29][DEBUG] jax_fem: Function split_and_compute_cell took 0.5895 seconds\n", + "[11-04 16:39:31][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:39:31][DEBUG] jax_fem: Before, l_2 res = 96.4128491694942, relative l_2 res = 1.0\n", + "[11-04 16:39:31][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:39:31][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:39:31][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:39:31][DEBUG] jax_fem: Function split_and_compute_cell took 0.0316 seconds\n", + "[11-04 16:39:31][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33339,), indices shape = (33339,), indptr shape = (15067,), b shape = (15066,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:39:32][DEBUG] jax_fem: l_2 res = 2.357195409951208e-13, relative l_2 res = 2.4448975735664117e-15\n", + "[11-04 16:39:32][INFO] jax_fem: Solve took 3.536055088043213 [s]\n", + "[11-04 16:39:32][INFO] jax_fem: max of dofs = 0.8925549936165259\n", + "[11-04 16:39:32][INFO] jax_fem: min of dofs = -2.2669055710635932\n", + "[11-04 16:39:35][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 16:39:35][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:39:35][DEBUG] jax_fem: Function split_and_compute_cell took 0.0332 seconds\n", + "[11-04 16:39:35][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:39:35][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33339,), indices shape = (33339,), indptr shape = (15067,), b shape = (15066,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:39:36][DEBUG] jax_fem: Computing cell residual...\n", + "[11-04 16:39:36][DEBUG] jax_fem: Function split_and_compute_cell took 0.5050 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 5, Loss: 767.00\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:39:53][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:39:53][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:39:53][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:39:54][DEBUG] jax_fem: Done pre-computations, took 1.3949177265167236 [s]\n", + "[11-04 16:39:54][INFO] jax_fem: Solving a problem with 3284 cells, 4951x3 = 14853 dofs.\n", + "[11-04 16:39:54][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3284 elements.\n", + "(3284, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:39:58][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:39:58][DEBUG] jax_fem: Start timing\n", + "[11-04 16:39:58][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:39:59][DEBUG] jax_fem: Function split_and_compute_cell took 0.5202 seconds\n", + "[11-04 16:40:00][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:40:01][DEBUG] jax_fem: Before, l_2 res = 96.4128491694942, relative l_2 res = 1.0\n", + "[11-04 16:40:01][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:40:01][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:40:01][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:40:01][DEBUG] jax_fem: Function split_and_compute_cell took 0.0387 seconds\n", + "[11-04 16:40:01][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33126,), indices shape = (33126,), indptr shape = (14854,), b shape = (14853,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:40:01][DEBUG] jax_fem: l_2 res = 1.7614520187779174e-13, relative l_2 res = 1.8269888650228327e-15\n", + "[11-04 16:40:01][INFO] jax_fem: Solve took 3.5311851501464844 [s]\n", + "[11-04 16:40:01][INFO] jax_fem: max of dofs = 0.8719354002525683\n", + "[11-04 16:40:01][INFO] jax_fem: min of dofs = -2.264344487225659\n", + "[11-04 16:40:04][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:40:04][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:40:04][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:40:05][DEBUG] jax_fem: Done pre-computations, took 1.550306797027588 [s]\n", + "[11-04 16:40:05][INFO] jax_fem: Solving a problem with 3284 cells, 4951x3 = 14853 dofs.\n", + "[11-04 16:40:05][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3284 elements.\n", + "(3284, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:40:09][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:40:09][DEBUG] jax_fem: Start timing\n", + "[11-04 16:40:09][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:40:10][DEBUG] jax_fem: Function split_and_compute_cell took 0.5219 seconds\n", + "[11-04 16:40:11][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:40:12][DEBUG] jax_fem: Before, l_2 res = 96.4128491694942, relative l_2 res = 1.0\n", + "[11-04 16:40:12][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:40:12][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:40:12][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:40:12][DEBUG] jax_fem: Function split_and_compute_cell took 0.0338 seconds\n", + "[11-04 16:40:12][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33126,), indices shape = (33126,), indptr shape = (14854,), b shape = (14853,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:40:12][DEBUG] jax_fem: l_2 res = 1.7614520187779174e-13, relative l_2 res = 1.8269888650228327e-15\n", + "[11-04 16:40:12][INFO] jax_fem: Solve took 3.508685827255249 [s]\n", + "[11-04 16:40:13][INFO] jax_fem: max of dofs = 0.8719354002525683\n", + "[11-04 16:40:13][INFO] jax_fem: min of dofs = -2.264344487225659\n", + "[11-04 16:40:15][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 16:40:15][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:40:15][DEBUG] jax_fem: Function split_and_compute_cell took 0.0352 seconds\n", + "[11-04 16:40:15][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:40:16][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33126,), indices shape = (33126,), indptr shape = (14854,), b shape = (14853,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:40:16][DEBUG] jax_fem: Computing cell residual...\n", + "[11-04 16:40:17][DEBUG] jax_fem: Function split_and_compute_cell took 0.4790 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 6, Loss: 752.07\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:40:28][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:40:28][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:40:28][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:40:30][DEBUG] jax_fem: Done pre-computations, took 1.4289376735687256 [s]\n", + "[11-04 16:40:30][INFO] jax_fem: Solving a problem with 3270 cells, 4940x3 = 14820 dofs.\n", + "[11-04 16:40:30][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3270 elements.\n", + "(3270, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:40:34][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:40:34][DEBUG] jax_fem: Start timing\n", + "[11-04 16:40:34][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:40:34][DEBUG] jax_fem: Function split_and_compute_cell took 0.6081 seconds\n", + "[11-04 16:40:36][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:40:36][DEBUG] jax_fem: Before, l_2 res = 96.4128491694942, relative l_2 res = 1.0\n", + "[11-04 16:40:36][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:40:37][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:40:37][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:40:37][DEBUG] jax_fem: Function split_and_compute_cell took 0.0412 seconds\n", + "[11-04 16:40:37][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33093,), indices shape = (33093,), indptr shape = (14821,), b shape = (14820,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:40:37][DEBUG] jax_fem: l_2 res = 2.0408687750224786e-13, relative l_2 res = 2.116801642729822e-15\n", + "[11-04 16:40:37][INFO] jax_fem: Solve took 3.6834254264831543 [s]\n", + "[11-04 16:40:37][INFO] jax_fem: max of dofs = 0.8498016553842358\n", + "[11-04 16:40:37][INFO] jax_fem: min of dofs = -2.262698070470754\n", + "[11-04 16:40:39][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:40:39][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:40:39][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:40:41][DEBUG] jax_fem: Done pre-computations, took 1.5793955326080322 [s]\n", + "[11-04 16:40:41][INFO] jax_fem: Solving a problem with 3270 cells, 4940x3 = 14820 dofs.\n", + "[11-04 16:40:41][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3270 elements.\n", + "(3270, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:40:45][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:40:45][DEBUG] jax_fem: Start timing\n", + "[11-04 16:40:45][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:40:46][DEBUG] jax_fem: Function split_and_compute_cell took 0.5711 seconds\n", + "[11-04 16:40:47][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:40:48][DEBUG] jax_fem: Before, l_2 res = 96.4128491694942, relative l_2 res = 1.0\n", + "[11-04 16:40:48][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:40:48][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:40:48][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:40:48][DEBUG] jax_fem: Function split_and_compute_cell took 0.0345 seconds\n", + "[11-04 16:40:48][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33093,), indices shape = (33093,), indptr shape = (14821,), b shape = (14820,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:40:48][DEBUG] jax_fem: l_2 res = 2.0408687750224786e-13, relative l_2 res = 2.116801642729822e-15\n", + "[11-04 16:40:48][INFO] jax_fem: Solve took 3.513225555419922 [s]\n", + "[11-04 16:40:48][INFO] jax_fem: max of dofs = 0.8498016553842358\n", + "[11-04 16:40:49][INFO] jax_fem: min of dofs = -2.262698070470754\n", + "[11-04 16:40:51][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 16:40:51][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:40:51][DEBUG] jax_fem: Function split_and_compute_cell took 0.0353 seconds\n", + "[11-04 16:40:51][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:40:52][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33093,), indices shape = (33093,), indptr shape = (14821,), b shape = (14820,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:40:52][DEBUG] jax_fem: Computing cell residual...\n", + "[11-04 16:40:52][DEBUG] jax_fem: Function split_and_compute_cell took 0.4294 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 7, Loss: 736.80\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:41:07][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:41:07][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:41:07][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:41:09][DEBUG] jax_fem: Done pre-computations, took 1.4324121475219727 [s]\n", + "[11-04 16:41:09][INFO] jax_fem: Solving a problem with 3424 cells, 5119x3 = 15357 dofs.\n", + "[11-04 16:41:09][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-04 16:41:11][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:41:11][DEBUG] jax_fem: Start timing\n", + "[11-04 16:41:11][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3424 elements.\n", + "(3424, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:41:12][DEBUG] jax_fem: Function split_and_compute_cell took 0.4023 seconds\n", + "[11-04 16:41:13][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:41:13][DEBUG] jax_fem: Before, l_2 res = 94.30771083566233, relative l_2 res = 1.0\n", + "[11-04 16:41:13][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:41:13][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:41:14][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:41:14][DEBUG] jax_fem: Function split_and_compute_cell took 0.0413 seconds\n", + "[11-04 16:41:14][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33765,), indices shape = (33765,), indptr shape = (15358,), b shape = (15357,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:41:14][DEBUG] jax_fem: l_2 res = 1.5400288772502756e-13, relative l_2 res = 1.6329829911086292e-15\n", + "[11-04 16:41:14][INFO] jax_fem: Solve took 3.076639413833618 [s]\n", + "[11-04 16:41:14][INFO] jax_fem: max of dofs = 0.905812353231569\n", + "[11-04 16:41:14][INFO] jax_fem: min of dofs = -2.2679962693253795\n", + "[11-04 16:41:16][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:41:16][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:41:16][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:41:18][DEBUG] jax_fem: Done pre-computations, took 1.5626091957092285 [s]\n", + "[11-04 16:41:18][INFO] jax_fem: Solving a problem with 3424 cells, 5119x3 = 15357 dofs.\n", + "[11-04 16:41:18][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-04 16:41:20][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:41:20][DEBUG] jax_fem: Start timing\n", + "[11-04 16:41:20][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3424 elements.\n", + "(3424, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:41:21][DEBUG] jax_fem: Function split_and_compute_cell took 0.3979 seconds\n", + "[11-04 16:41:22][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:41:23][DEBUG] jax_fem: Before, l_2 res = 94.30771083566233, relative l_2 res = 1.0\n", + "[11-04 16:41:23][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:41:23][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:41:23][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:41:23][DEBUG] jax_fem: Function split_and_compute_cell took 0.0352 seconds\n", + "[11-04 16:41:23][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33765,), indices shape = (33765,), indptr shape = (15358,), b shape = (15357,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:41:23][DEBUG] jax_fem: l_2 res = 1.5400288772502756e-13, relative l_2 res = 1.6329829911086292e-15\n", + "[11-04 16:41:24][INFO] jax_fem: Solve took 3.156646251678467 [s]\n", + "[11-04 16:41:24][INFO] jax_fem: max of dofs = 0.905812353231569\n", + "[11-04 16:41:24][INFO] jax_fem: min of dofs = -2.2679962693253795\n", + "[11-04 16:41:26][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 16:41:26][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:41:26][DEBUG] jax_fem: Function split_and_compute_cell took 0.0359 seconds\n", + "[11-04 16:41:26][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:41:27][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:41:27][DEBUG] jax_fem: Computing cell residual...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33765,), indices shape = (33765,), indptr shape = (15358,), b shape = (15357,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:41:27][DEBUG] jax_fem: Function split_and_compute_cell took 0.3534 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 8, Loss: 775.59\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:41:44][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:41:44][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:41:44][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:41:45][DEBUG] jax_fem: Done pre-computations, took 1.382901906967163 [s]\n", + "[11-04 16:41:45][INFO] jax_fem: Solving a problem with 3305 cells, 5083x3 = 15249 dofs.\n", + "[11-04 16:41:45][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3305 elements.\n", + "(3305, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:41:49][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:41:49][DEBUG] jax_fem: Start timing\n", + "[11-04 16:41:49][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:41:49][DEBUG] jax_fem: Function split_and_compute_cell took 0.5672 seconds\n", + "[11-04 16:41:51][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:41:51][DEBUG] jax_fem: Before, l_2 res = 95.49125262588274, relative l_2 res = 1.0\n", + "[11-04 16:41:51][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:41:51][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:41:51][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:41:51][DEBUG] jax_fem: Function split_and_compute_cell took 0.0403 seconds\n", + "[11-04 16:41:52][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33270,), indices shape = (33270,), indptr shape = (15250,), b shape = (15249,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:41:52][DEBUG] jax_fem: l_2 res = 2.051949676047926e-13, relative l_2 res = 2.148835227962806e-15\n", + "[11-04 16:41:52][INFO] jax_fem: Solve took 3.458221197128296 [s]\n", + "[11-04 16:41:52][INFO] jax_fem: max of dofs = 0.8844791948050501\n", + "[11-04 16:41:52][INFO] jax_fem: min of dofs = -2.2563002871004585\n", + "[11-04 16:41:54][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:41:54][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:41:54][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:41:56][DEBUG] jax_fem: Done pre-computations, took 1.5822944641113281 [s]\n", + "[11-04 16:41:56][INFO] jax_fem: Solving a problem with 3305 cells, 5083x3 = 15249 dofs.\n", + "[11-04 16:41:56][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3305 elements.\n", + "(3305, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:42:00][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:42:00][DEBUG] jax_fem: Start timing\n", + "[11-04 16:42:00][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:42:00][DEBUG] jax_fem: Function split_and_compute_cell took 0.5523 seconds\n", + "[11-04 16:42:02][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:42:02][DEBUG] jax_fem: Before, l_2 res = 95.49125262588274, relative l_2 res = 1.0\n", + "[11-04 16:42:02][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:42:02][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:42:03][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:42:03][DEBUG] jax_fem: Function split_and_compute_cell took 0.0342 seconds\n", + "[11-04 16:42:03][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33270,), indices shape = (33270,), indptr shape = (15250,), b shape = (15249,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:42:03][DEBUG] jax_fem: l_2 res = 2.051949676047926e-13, relative l_2 res = 2.148835227962806e-15\n", + "[11-04 16:42:03][INFO] jax_fem: Solve took 3.4355177879333496 [s]\n", + "[11-04 16:42:03][INFO] jax_fem: max of dofs = 0.8844791948050501\n", + "[11-04 16:42:03][INFO] jax_fem: min of dofs = -2.2563002871004585\n", + "[11-04 16:42:06][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 16:42:06][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:42:06][DEBUG] jax_fem: Function split_and_compute_cell took 0.0343 seconds\n", + "[11-04 16:42:06][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:42:06][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33270,), indices shape = (33270,), indptr shape = (15250,), b shape = (15249,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:42:07][DEBUG] jax_fem: Computing cell residual...\n", + "[11-04 16:42:07][DEBUG] jax_fem: Function split_and_compute_cell took 0.4801 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 9, Loss: 755.24\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:42:26][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:42:26][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:42:26][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:42:28][DEBUG] jax_fem: Done pre-computations, took 1.4037370681762695 [s]\n", + "[11-04 16:42:28][INFO] jax_fem: Solving a problem with 3102 cells, 4877x3 = 14631 dofs.\n", + "[11-04 16:42:28][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3102 elements.\n", + "(3102, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:42:31][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:42:31][DEBUG] jax_fem: Start timing\n", + "[11-04 16:42:31][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:42:32][DEBUG] jax_fem: Function split_and_compute_cell took 0.6054 seconds\n", + "[11-04 16:42:34][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:42:34][DEBUG] jax_fem: Before, l_2 res = 96.7527556532114, relative l_2 res = 1.0\n", + "[11-04 16:42:34][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:42:34][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:42:34][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:42:34][DEBUG] jax_fem: Function split_and_compute_cell took 0.0390 seconds\n", + "[11-04 16:42:34][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32454,), indices shape = (32454,), indptr shape = (14632,), b shape = (14631,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:42:35][DEBUG] jax_fem: l_2 res = 2.666109904503205e-13, relative l_2 res = 2.755590666646518e-15\n", + "[11-04 16:42:35][INFO] jax_fem: Solve took 3.658313035964966 [s]\n", + "[11-04 16:42:35][INFO] jax_fem: max of dofs = 0.8601972587771521\n", + "[11-04 16:42:35][INFO] jax_fem: min of dofs = -2.2419862859950297\n", + "[11-04 16:42:37][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:42:37][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:42:37][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:42:39][DEBUG] jax_fem: Done pre-computations, took 1.5683047771453857 [s]\n", + "[11-04 16:42:39][INFO] jax_fem: Solving a problem with 3102 cells, 4877x3 = 14631 dofs.\n", + "[11-04 16:42:39][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3102 elements.\n", + "(3102, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:42:42][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:42:42][DEBUG] jax_fem: Start timing\n", + "[11-04 16:42:43][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:42:43][DEBUG] jax_fem: Function split_and_compute_cell took 0.6380 seconds\n", + "[11-04 16:42:45][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:42:45][DEBUG] jax_fem: Before, l_2 res = 96.7527556532114, relative l_2 res = 1.0\n", + "[11-04 16:42:45][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:42:45][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:42:45][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:42:46][DEBUG] jax_fem: Function split_and_compute_cell took 0.0331 seconds\n", + "[11-04 16:42:46][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32454,), indices shape = (32454,), indptr shape = (14632,), b shape = (14631,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:42:46][DEBUG] jax_fem: l_2 res = 2.666109904503205e-13, relative l_2 res = 2.755590666646518e-15\n", + "[11-04 16:42:46][INFO] jax_fem: Solve took 3.565122127532959 [s]\n", + "[11-04 16:42:46][INFO] jax_fem: max of dofs = 0.8601972587771521\n", + "[11-04 16:42:46][INFO] jax_fem: min of dofs = -2.2419862859950297\n", + "[11-04 16:42:49][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 16:42:49][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:42:49][DEBUG] jax_fem: Function split_and_compute_cell took 0.0341 seconds\n", + "[11-04 16:42:49][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:42:49][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32454,), indices shape = (32454,), indptr shape = (14632,), b shape = (14631,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:42:50][DEBUG] jax_fem: Computing cell residual...\n", + "[11-04 16:42:50][DEBUG] jax_fem: Function split_and_compute_cell took 0.4829 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 10, Loss: 732.70\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:43:14][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:43:14][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:43:14][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:43:16][DEBUG] jax_fem: Done pre-computations, took 1.3785839080810547 [s]\n", + "[11-04 16:43:16][INFO] jax_fem: Solving a problem with 3039 cells, 4804x3 = 14412 dofs.\n", + "[11-04 16:43:16][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3039 elements.\n", + "(3039, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:43:19][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:43:19][DEBUG] jax_fem: Start timing\n", + "[11-04 16:43:19][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:43:20][DEBUG] jax_fem: Function split_and_compute_cell took 0.5706 seconds\n", + "[11-04 16:43:22][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:43:22][DEBUG] jax_fem: Before, l_2 res = 96.8249222313618, relative l_2 res = 1.0\n", + "[11-04 16:43:22][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:43:22][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:43:22][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:43:22][DEBUG] jax_fem: Function split_and_compute_cell took 0.0391 seconds\n", + "[11-04 16:43:23][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32181,), indices shape = (32181,), indptr shape = (14413,), b shape = (14412,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:43:23][DEBUG] jax_fem: l_2 res = 2.7596595582170984e-13, relative l_2 res = 2.8501541696289005e-15\n", + "[11-04 16:43:23][INFO] jax_fem: Solve took 3.6841111183166504 [s]\n", + "[11-04 16:43:23][INFO] jax_fem: max of dofs = 0.8334996096682247\n", + "[11-04 16:43:23][INFO] jax_fem: min of dofs = -2.2409777066248413\n", + "[11-04 16:43:25][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:43:25][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:43:25][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:43:27][DEBUG] jax_fem: Done pre-computations, took 1.5744290351867676 [s]\n", + "[11-04 16:43:27][INFO] jax_fem: Solving a problem with 3039 cells, 4804x3 = 14412 dofs.\n", + "[11-04 16:43:27][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3039 elements.\n", + "(3039, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:43:30][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:43:30][DEBUG] jax_fem: Start timing\n", + "[11-04 16:43:30][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:43:31][DEBUG] jax_fem: Function split_and_compute_cell took 0.5415 seconds\n", + "[11-04 16:43:33][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:43:33][DEBUG] jax_fem: Before, l_2 res = 96.8249222313618, relative l_2 res = 1.0\n", + "[11-04 16:43:33][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:43:33][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:43:33][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:43:34][DEBUG] jax_fem: Function split_and_compute_cell took 0.0329 seconds\n", + "[11-04 16:43:34][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32181,), indices shape = (32181,), indptr shape = (14413,), b shape = (14412,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:43:34][DEBUG] jax_fem: l_2 res = 2.7596595582170984e-13, relative l_2 res = 2.8501541696289005e-15\n", + "[11-04 16:43:34][INFO] jax_fem: Solve took 3.5870168209075928 [s]\n", + "[11-04 16:43:34][INFO] jax_fem: max of dofs = 0.8334996096682247\n", + "[11-04 16:43:34][INFO] jax_fem: min of dofs = -2.2409777066248413\n", + "[11-04 16:43:37][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 16:43:37][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:43:37][DEBUG] jax_fem: Function split_and_compute_cell took 0.0348 seconds\n", + "[11-04 16:43:37][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:43:37][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32181,), indices shape = (32181,), indptr shape = (14413,), b shape = (14412,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:43:38][DEBUG] jax_fem: Computing cell residual...\n", + "[11-04 16:43:38][DEBUG] jax_fem: Function split_and_compute_cell took 0.4497 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 11, Loss: 717.04\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:44:04][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:44:04][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:44:04][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:44:05][DEBUG] jax_fem: Done pre-computations, took 1.3843183517456055 [s]\n", + "[11-04 16:44:05][INFO] jax_fem: Solving a problem with 3200 cells, 4991x3 = 14973 dofs.\n", + "[11-04 16:44:05][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3200 elements.\n", + "(3200, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:44:09][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:44:09][DEBUG] jax_fem: Start timing\n", + "[11-04 16:44:09][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:44:09][DEBUG] jax_fem: Function split_and_compute_cell took 0.2847 seconds\n", + "[11-04 16:44:11][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:44:11][DEBUG] jax_fem: Before, l_2 res = 95.78193611409566, relative l_2 res = 1.0\n", + "[11-04 16:44:11][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:44:11][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:44:11][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:44:11][DEBUG] jax_fem: Function split_and_compute_cell took 0.0395 seconds\n", + "[11-04 16:44:11][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32787,), indices shape = (32787,), indptr shape = (14974,), b shape = (14973,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:44:12][DEBUG] jax_fem: l_2 res = 1.7901355059135254e-13, relative l_2 res = 1.868969848115319e-15\n", + "[11-04 16:44:12][INFO] jax_fem: Solve took 3.3154993057250977 [s]\n", + "[11-04 16:44:12][INFO] jax_fem: max of dofs = 0.8125611542521877\n", + "[11-04 16:44:12][INFO] jax_fem: min of dofs = -2.207402595896366\n", + "[11-04 16:44:14][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:44:14][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:44:14][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:44:16][DEBUG] jax_fem: Done pre-computations, took 1.5577828884124756 [s]\n", + "[11-04 16:44:16][INFO] jax_fem: Solving a problem with 3200 cells, 4991x3 = 14973 dofs.\n", + "[11-04 16:44:16][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3200 elements.\n", + "(3200, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:44:19][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:44:19][DEBUG] jax_fem: Start timing\n", + "[11-04 16:44:20][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:44:20][DEBUG] jax_fem: Function split_and_compute_cell took 0.3091 seconds\n", + "[11-04 16:44:22][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:44:22][DEBUG] jax_fem: Before, l_2 res = 95.78193611409566, relative l_2 res = 1.0\n", + "[11-04 16:44:22][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:44:22][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:44:22][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:44:22][DEBUG] jax_fem: Function split_and_compute_cell took 0.0429 seconds\n", + "[11-04 16:44:22][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32787,), indices shape = (32787,), indptr shape = (14974,), b shape = (14973,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:44:23][DEBUG] jax_fem: l_2 res = 1.7901355059135254e-13, relative l_2 res = 1.868969848115319e-15\n", + "[11-04 16:44:23][INFO] jax_fem: Solve took 3.343935251235962 [s]\n", + "[11-04 16:44:23][INFO] jax_fem: max of dofs = 0.8125611542521877\n", + "[11-04 16:44:23][INFO] jax_fem: min of dofs = -2.207402595896366\n", + "[11-04 16:44:25][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 16:44:25][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:44:26][DEBUG] jax_fem: Function split_and_compute_cell took 0.0338 seconds\n", + "[11-04 16:44:26][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:44:26][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32787,), indices shape = (32787,), indptr shape = (14974,), b shape = (14973,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:44:26][DEBUG] jax_fem: Computing cell residual...\n", + "[11-04 16:44:27][DEBUG] jax_fem: Function split_and_compute_cell took 0.3206 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 12, Loss: 703.00\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:44:49][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:44:49][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:44:49][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:44:50][DEBUG] jax_fem: Done pre-computations, took 1.4233205318450928 [s]\n", + "[11-04 16:44:50][INFO] jax_fem: Solving a problem with 3200 cells, 5044x3 = 15132 dofs.\n", + "[11-04 16:44:50][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-04 16:44:52][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:44:52][DEBUG] jax_fem: Start timing\n", + "[11-04 16:44:52][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3200 elements.\n", + "(3200, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:44:53][DEBUG] jax_fem: Function split_and_compute_cell took 0.1803 seconds\n", + "[11-04 16:44:54][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:44:54][DEBUG] jax_fem: Before, l_2 res = 94.76137996137979, relative l_2 res = 1.0\n", + "[11-04 16:44:54][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:44:55][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:44:55][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:44:55][DEBUG] jax_fem: Function split_and_compute_cell took 0.0391 seconds\n", + "[11-04 16:44:55][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33243,), indices shape = (33243,), indptr shape = (15133,), b shape = (15132,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:44:55][DEBUG] jax_fem: l_2 res = 2.1830441553912318e-13, relative l_2 res = 2.3037276961151646e-15\n", + "[11-04 16:44:55][INFO] jax_fem: Solve took 2.8864636421203613 [s]\n", + "[11-04 16:44:55][INFO] jax_fem: max of dofs = 0.789281443121377\n", + "[11-04 16:44:55][INFO] jax_fem: min of dofs = -2.2256921422309746\n", + "[11-04 16:44:57][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:44:57][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:44:57][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:44:59][DEBUG] jax_fem: Done pre-computations, took 1.5990498065948486 [s]\n", + "[11-04 16:44:59][INFO] jax_fem: Solving a problem with 3200 cells, 5044x3 = 15132 dofs.\n", + "[11-04 16:44:59][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-04 16:45:01][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:45:01][DEBUG] jax_fem: Start timing\n", + "[11-04 16:45:01][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3200 elements.\n", + "(3200, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:45:02][DEBUG] jax_fem: Function split_and_compute_cell took 0.1834 seconds\n", + "[11-04 16:45:03][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:45:03][DEBUG] jax_fem: Before, l_2 res = 94.76137996137979, relative l_2 res = 1.0\n", + "[11-04 16:45:03][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:45:04][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:45:04][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:45:04][DEBUG] jax_fem: Function split_and_compute_cell took 0.0438 seconds\n", + "[11-04 16:45:04][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33243,), indices shape = (33243,), indptr shape = (15133,), b shape = (15132,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:45:04][DEBUG] jax_fem: l_2 res = 2.1830441553912318e-13, relative l_2 res = 2.3037276961151646e-15\n", + "[11-04 16:45:04][INFO] jax_fem: Solve took 2.857917070388794 [s]\n", + "[11-04 16:45:04][INFO] jax_fem: max of dofs = 0.789281443121377\n", + "[11-04 16:45:04][INFO] jax_fem: min of dofs = -2.2256921422309746\n", + "[11-04 16:45:07][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 16:45:07][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:45:07][DEBUG] jax_fem: Function split_and_compute_cell took 0.0340 seconds\n", + "[11-04 16:45:07][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:45:07][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:45:07][DEBUG] jax_fem: Computing cell residual...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33243,), indices shape = (33243,), indptr shape = (15133,), b shape = (15132,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:45:08][DEBUG] jax_fem: Function split_and_compute_cell took 0.2193 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 13, Loss: 700.06\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:45:30][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:45:30][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:45:30][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:45:31][DEBUG] jax_fem: Done pre-computations, took 1.3936870098114014 [s]\n", + "[11-04 16:45:31][INFO] jax_fem: Solving a problem with 3207 cells, 5047x3 = 15141 dofs.\n", + "[11-04 16:45:31][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3207 elements.\n", + "(3207, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:45:35][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:45:35][DEBUG] jax_fem: Start timing\n", + "[11-04 16:45:35][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:45:36][DEBUG] jax_fem: Function split_and_compute_cell took 0.5375 seconds\n", + "[11-04 16:45:38][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:45:38][DEBUG] jax_fem: Before, l_2 res = 94.76137996137979, relative l_2 res = 1.0\n", + "[11-04 16:45:38][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:45:38][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:45:38][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:45:38][DEBUG] jax_fem: Function split_and_compute_cell took 0.0390 seconds\n", + "[11-04 16:45:38][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33252,), indices shape = (33252,), indptr shape = (15142,), b shape = (15141,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:45:39][DEBUG] jax_fem: l_2 res = 1.769360706959225e-13, relative l_2 res = 1.8671749057267127e-15\n", + "[11-04 16:45:39][INFO] jax_fem: Solve took 3.7201943397521973 [s]\n", + "[11-04 16:45:39][INFO] jax_fem: max of dofs = 0.7584814420628603\n", + "[11-04 16:45:39][INFO] jax_fem: min of dofs = -2.227529015397974\n", + "[11-04 16:45:41][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:45:41][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:45:41][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:45:43][DEBUG] jax_fem: Done pre-computations, took 1.5601592063903809 [s]\n", + "[11-04 16:45:43][INFO] jax_fem: Solving a problem with 3207 cells, 5047x3 = 15141 dofs.\n", + "[11-04 16:45:43][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3207 elements.\n", + "(3207, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:45:46][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:45:46][DEBUG] jax_fem: Start timing\n", + "[11-04 16:45:46][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:45:47][DEBUG] jax_fem: Function split_and_compute_cell took 0.5248 seconds\n", + "[11-04 16:45:49][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:45:49][DEBUG] jax_fem: Before, l_2 res = 94.76137996137979, relative l_2 res = 1.0\n", + "[11-04 16:45:49][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:45:49][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:45:49][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:45:49][DEBUG] jax_fem: Function split_and_compute_cell took 0.0330 seconds\n", + "[11-04 16:45:49][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33252,), indices shape = (33252,), indptr shape = (15142,), b shape = (15141,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:45:50][DEBUG] jax_fem: l_2 res = 1.769360706959225e-13, relative l_2 res = 1.8671749057267127e-15\n", + "[11-04 16:45:50][INFO] jax_fem: Solve took 3.495558261871338 [s]\n", + "[11-04 16:45:50][INFO] jax_fem: max of dofs = 0.7584814420628603\n", + "[11-04 16:45:50][INFO] jax_fem: min of dofs = -2.227529015397974\n", + "[11-04 16:45:53][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 16:45:53][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:45:53][DEBUG] jax_fem: Function split_and_compute_cell took 0.0334 seconds\n", + "[11-04 16:45:53][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:45:53][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33252,), indices shape = (33252,), indptr shape = (15142,), b shape = (15141,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:45:53][DEBUG] jax_fem: Computing cell residual...\n", + "[11-04 16:45:54][DEBUG] jax_fem: Function split_and_compute_cell took 0.4178 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 14, Loss: 687.26\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:46:12][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:46:12][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:46:12][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:46:13][DEBUG] jax_fem: Done pre-computations, took 1.3675904273986816 [s]\n", + "[11-04 16:46:13][INFO] jax_fem: Solving a problem with 3193 cells, 4981x3 = 14943 dofs.\n", + "[11-04 16:46:13][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3193 elements.\n", + "(3193, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:46:17][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:46:17][DEBUG] jax_fem: Start timing\n", + "[11-04 16:46:17][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:46:18][DEBUG] jax_fem: Function split_and_compute_cell took 0.5652 seconds\n", + "[11-04 16:46:19][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:46:20][DEBUG] jax_fem: Before, l_2 res = 94.59907762353014, relative l_2 res = 1.0\n", + "[11-04 16:46:20][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:46:20][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:46:20][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:46:20][DEBUG] jax_fem: Function split_and_compute_cell took 0.0390 seconds\n", + "[11-04 16:46:20][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33108,), indices shape = (33108,), indptr shape = (14944,), b shape = (14943,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:46:20][DEBUG] jax_fem: l_2 res = 1.7593964349792976e-13, relative l_2 res = 1.859845232298199e-15\n", + "[11-04 16:46:21][INFO] jax_fem: Solve took 3.5911245346069336 [s]\n", + "[11-04 16:46:21][INFO] jax_fem: max of dofs = 0.7715082377400378\n", + "[11-04 16:46:21][INFO] jax_fem: min of dofs = -2.2407701134126943\n", + "[11-04 16:46:23][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:46:23][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:46:23][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:46:24][DEBUG] jax_fem: Done pre-computations, took 1.5628492832183838 [s]\n", + "[11-04 16:46:24][INFO] jax_fem: Solving a problem with 3193 cells, 4981x3 = 14943 dofs.\n", + "[11-04 16:46:24][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3193 elements.\n", + "(3193, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:46:28][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:46:28][DEBUG] jax_fem: Start timing\n", + "[11-04 16:46:28][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:46:29][DEBUG] jax_fem: Function split_and_compute_cell took 0.5579 seconds\n", + "[11-04 16:46:30][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:46:31][DEBUG] jax_fem: Before, l_2 res = 94.59907762353014, relative l_2 res = 1.0\n", + "[11-04 16:46:31][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:46:31][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:46:31][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:46:31][DEBUG] jax_fem: Function split_and_compute_cell took 0.0327 seconds\n", + "[11-04 16:46:31][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33108,), indices shape = (33108,), indptr shape = (14944,), b shape = (14943,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:46:31][DEBUG] jax_fem: l_2 res = 1.7593964349792976e-13, relative l_2 res = 1.859845232298199e-15\n", + "[11-04 16:46:32][INFO] jax_fem: Solve took 3.485915184020996 [s]\n", + "[11-04 16:46:32][INFO] jax_fem: max of dofs = 0.7715082377400378\n", + "[11-04 16:46:32][INFO] jax_fem: min of dofs = -2.2407701134126943\n", + "[11-04 16:46:34][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 16:46:34][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:46:34][DEBUG] jax_fem: Function split_and_compute_cell took 0.0338 seconds\n", + "[11-04 16:46:34][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:46:35][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33108,), indices shape = (33108,), indptr shape = (14944,), b shape = (14943,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:46:35][DEBUG] jax_fem: Computing cell residual...\n", + "[11-04 16:46:36][DEBUG] jax_fem: Function split_and_compute_cell took 0.4774 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 15, Loss: 701.97\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:46:54][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:46:54][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:46:54][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:46:55][DEBUG] jax_fem: Done pre-computations, took 1.4008653163909912 [s]\n", + "[11-04 16:46:55][INFO] jax_fem: Solving a problem with 3291 cells, 5091x3 = 15273 dofs.\n", + "[11-04 16:46:55][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3291 elements.\n", + "(3291, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:46:59][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:46:59][DEBUG] jax_fem: Start timing\n", + "[11-04 16:46:59][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:47:00][DEBUG] jax_fem: Function split_and_compute_cell took 0.5337 seconds\n", + "[11-04 16:47:02][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:47:02][DEBUG] jax_fem: Before, l_2 res = 92.74231238007708, relative l_2 res = 1.0\n", + "[11-04 16:47:02][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:47:02][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:47:02][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:47:02][DEBUG] jax_fem: Function split_and_compute_cell took 0.0393 seconds\n", + "[11-04 16:47:02][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33582,), indices shape = (33582,), indptr shape = (15274,), b shape = (15273,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:47:03][DEBUG] jax_fem: l_2 res = 1.6498411033608456e-13, relative l_2 res = 1.77895187322854e-15\n", + "[11-04 16:47:03][INFO] jax_fem: Solve took 3.653648853302002 [s]\n", + "[11-04 16:47:03][INFO] jax_fem: max of dofs = 0.8419096069115888\n", + "[11-04 16:47:03][INFO] jax_fem: min of dofs = -2.2441120284200293\n", + "[11-04 16:47:05][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:47:05][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:47:05][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:47:07][DEBUG] jax_fem: Done pre-computations, took 1.5668177604675293 [s]\n", + "[11-04 16:47:07][INFO] jax_fem: Solving a problem with 3291 cells, 5091x3 = 15273 dofs.\n", + "[11-04 16:47:07][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3291 elements.\n", + "(3291, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:47:11][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:47:11][DEBUG] jax_fem: Start timing\n", + "[11-04 16:47:11][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:47:11][DEBUG] jax_fem: Function split_and_compute_cell took 0.5229 seconds\n", + "[11-04 16:47:13][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:47:13][DEBUG] jax_fem: Before, l_2 res = 92.74231238007708, relative l_2 res = 1.0\n", + "[11-04 16:47:13][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:47:13][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:47:14][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:47:14][DEBUG] jax_fem: Function split_and_compute_cell took 0.0350 seconds\n", + "[11-04 16:47:14][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33582,), indices shape = (33582,), indptr shape = (15274,), b shape = (15273,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:47:14][DEBUG] jax_fem: l_2 res = 1.6498411033608456e-13, relative l_2 res = 1.77895187322854e-15\n", + "[11-04 16:47:14][INFO] jax_fem: Solve took 3.510580539703369 [s]\n", + "[11-04 16:47:14][INFO] jax_fem: max of dofs = 0.8419096069115888\n", + "[11-04 16:47:14][INFO] jax_fem: min of dofs = -2.2441120284200293\n", + "[11-04 16:47:17][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 16:47:17][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:47:17][DEBUG] jax_fem: Function split_and_compute_cell took 0.0360 seconds\n", + "[11-04 16:47:17][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:47:17][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33582,), indices shape = (33582,), indptr shape = (15274,), b shape = (15273,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:47:18][DEBUG] jax_fem: Computing cell residual...\n", + "[11-04 16:47:18][DEBUG] jax_fem: Function split_and_compute_cell took 0.5077 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 16, Loss: 715.78\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:47:43][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:47:43][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:47:43][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:47:44][DEBUG] jax_fem: Done pre-computations, took 1.456979751586914 [s]\n", + "[11-04 16:47:44][INFO] jax_fem: Solving a problem with 3347 cells, 5142x3 = 15426 dofs.\n", + "[11-04 16:47:44][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3347 elements.\n", + "(3347, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:47:48][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:47:48][DEBUG] jax_fem: Start timing\n", + "[11-04 16:47:48][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:47:49][DEBUG] jax_fem: Function split_and_compute_cell took 0.5590 seconds\n", + "[11-04 16:47:50][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:47:51][DEBUG] jax_fem: Before, l_2 res = 92.74231238007708, relative l_2 res = 1.0\n", + "[11-04 16:47:51][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:47:51][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:47:51][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:47:51][DEBUG] jax_fem: Function split_and_compute_cell took 0.0401 seconds\n", + "[11-04 16:47:51][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33735,), indices shape = (33735,), indptr shape = (15427,), b shape = (15426,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:47:52][DEBUG] jax_fem: l_2 res = 1.4935724113788634e-13, relative l_2 res = 1.6104541422882538e-15\n", + "[11-04 16:47:52][INFO] jax_fem: Solve took 3.682126998901367 [s]\n", + "[11-04 16:47:52][INFO] jax_fem: max of dofs = 0.8237171974308953\n", + "[11-04 16:47:52][INFO] jax_fem: min of dofs = -2.2488264699192073\n", + "[11-04 16:47:54][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:47:54][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:47:54][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:47:55][DEBUG] jax_fem: Done pre-computations, took 1.5853099822998047 [s]\n", + "[11-04 16:47:55][INFO] jax_fem: Solving a problem with 3347 cells, 5142x3 = 15426 dofs.\n", + "[11-04 16:47:55][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3347 elements.\n", + "(3347, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:47:59][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:47:59][DEBUG] jax_fem: Start timing\n", + "[11-04 16:47:59][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:48:00][DEBUG] jax_fem: Function split_and_compute_cell took 0.5423 seconds\n", + "[11-04 16:48:02][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:48:02][DEBUG] jax_fem: Before, l_2 res = 92.74231238007708, relative l_2 res = 1.0\n", + "[11-04 16:48:02][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:48:02][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:48:02][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:48:02][DEBUG] jax_fem: Function split_and_compute_cell took 0.0337 seconds\n", + "[11-04 16:48:02][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33735,), indices shape = (33735,), indptr shape = (15427,), b shape = (15426,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:48:03][DEBUG] jax_fem: l_2 res = 1.4935724113788634e-13, relative l_2 res = 1.6104541422882538e-15\n", + "[11-04 16:48:03][INFO] jax_fem: Solve took 3.5253732204437256 [s]\n", + "[11-04 16:48:03][INFO] jax_fem: max of dofs = 0.8237171974308953\n", + "[11-04 16:48:03][INFO] jax_fem: min of dofs = -2.2488264699192073\n", + "[11-04 16:48:06][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 16:48:06][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:48:06][DEBUG] jax_fem: Function split_and_compute_cell took 0.0347 seconds\n", + "[11-04 16:48:06][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:48:06][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33735,), indices shape = (33735,), indptr shape = (15427,), b shape = (15426,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:48:06][DEBUG] jax_fem: Computing cell residual...\n", + "[11-04 16:48:08][DEBUG] jax_fem: Function split_and_compute_cell took 1.9793 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 17, Loss: 708.90\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:48:32][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:48:32][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:48:32][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:48:34][DEBUG] jax_fem: Done pre-computations, took 1.397407054901123 [s]\n", + "[11-04 16:48:34][INFO] jax_fem: Solving a problem with 3319 cells, 5125x3 = 15375 dofs.\n", + "[11-04 16:48:34][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3319 elements.\n", + "(3319, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:48:37][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:48:37][DEBUG] jax_fem: Start timing\n", + "[11-04 16:48:37][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:48:38][DEBUG] jax_fem: Function split_and_compute_cell took 0.5521 seconds\n", + "[11-04 16:48:40][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:48:40][DEBUG] jax_fem: Before, l_2 res = 92.57948830160089, relative l_2 res = 1.0\n", + "[11-04 16:48:40][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:48:40][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:48:40][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:48:40][DEBUG] jax_fem: Function split_and_compute_cell took 0.0392 seconds\n", + "[11-04 16:48:40][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33621,), indices shape = (33621,), indptr shape = (15376,), b shape = (15375,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:48:41][DEBUG] jax_fem: l_2 res = 1.6224165949131773e-13, relative l_2 res = 1.7524579414694414e-15\n", + "[11-04 16:48:41][INFO] jax_fem: Solve took 3.6250979900360107 [s]\n", + "[11-04 16:48:41][INFO] jax_fem: max of dofs = 0.8080255687301299\n", + "[11-04 16:48:41][INFO] jax_fem: min of dofs = -2.2530238858408476\n", + "[11-04 16:48:43][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:48:43][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:48:43][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:48:45][DEBUG] jax_fem: Done pre-computations, took 1.6088321208953857 [s]\n", + "[11-04 16:48:45][INFO] jax_fem: Solving a problem with 3319 cells, 5125x3 = 15375 dofs.\n", + "[11-04 16:48:45][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3319 elements.\n", + "(3319, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:48:49][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:48:49][DEBUG] jax_fem: Start timing\n", + "[11-04 16:48:49][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:48:49][DEBUG] jax_fem: Function split_and_compute_cell took 0.5360 seconds\n", + "[11-04 16:48:51][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:48:51][DEBUG] jax_fem: Before, l_2 res = 92.57948830160089, relative l_2 res = 1.0\n", + "[11-04 16:48:51][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:48:52][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:48:52][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:48:52][DEBUG] jax_fem: Function split_and_compute_cell took 0.0345 seconds\n", + "[11-04 16:48:52][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33621,), indices shape = (33621,), indptr shape = (15376,), b shape = (15375,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:48:52][DEBUG] jax_fem: l_2 res = 1.6224165949131773e-13, relative l_2 res = 1.7524579414694414e-15\n", + "[11-04 16:48:52][INFO] jax_fem: Solve took 3.5678746700286865 [s]\n", + "[11-04 16:48:52][INFO] jax_fem: max of dofs = 0.8080255687301299\n", + "[11-04 16:48:52][INFO] jax_fem: min of dofs = -2.2530238858408476\n", + "[11-04 16:48:55][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 16:48:55][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:48:55][DEBUG] jax_fem: Function split_and_compute_cell took 0.0345 seconds\n", + "[11-04 16:48:55][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:48:55][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33621,), indices shape = (33621,), indptr shape = (15376,), b shape = (15375,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:48:56][DEBUG] jax_fem: Computing cell residual...\n", + "[11-04 16:48:56][DEBUG] jax_fem: Function split_and_compute_cell took 0.4620 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 18, Loss: 702.95\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:49:20][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:49:20][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:49:20][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:49:21][DEBUG] jax_fem: Done pre-computations, took 1.3781778812408447 [s]\n", + "[11-04 16:49:21][INFO] jax_fem: Solving a problem with 3242 cells, 5092x3 = 15276 dofs.\n", + "[11-04 16:49:21][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3242 elements.\n", + "(3242, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:49:25][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:49:25][DEBUG] jax_fem: Start timing\n", + "[11-04 16:49:25][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:49:25][DEBUG] jax_fem: Function split_and_compute_cell took 0.5085 seconds\n", + "[11-04 16:49:27][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:49:27][DEBUG] jax_fem: Before, l_2 res = 93.40871839685298, relative l_2 res = 1.0\n", + "[11-04 16:49:27][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:49:28][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:49:28][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:49:28][DEBUG] jax_fem: Function split_and_compute_cell took 0.0396 seconds\n", + "[11-04 16:49:28][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33504,), indices shape = (33504,), indptr shape = (15277,), b shape = (15276,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:49:28][DEBUG] jax_fem: l_2 res = 1.6432144185598733e-13, relative l_2 res = 1.759166003732725e-15\n", + "[11-04 16:49:28][INFO] jax_fem: Solve took 3.622836112976074 [s]\n", + "[11-04 16:49:28][INFO] jax_fem: max of dofs = 0.7939802832865741\n", + "[11-04 16:49:28][INFO] jax_fem: min of dofs = -2.254598172334348\n", + "[11-04 16:49:31][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:49:31][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:49:31][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:49:32][DEBUG] jax_fem: Done pre-computations, took 1.563553810119629 [s]\n", + "[11-04 16:49:32][INFO] jax_fem: Solving a problem with 3242 cells, 5092x3 = 15276 dofs.\n", + "[11-04 16:49:32][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3242 elements.\n", + "(3242, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:49:36][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:49:36][DEBUG] jax_fem: Start timing\n", + "[11-04 16:49:36][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:49:37][DEBUG] jax_fem: Function split_and_compute_cell took 0.5282 seconds\n", + "[11-04 16:49:39][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:49:39][DEBUG] jax_fem: Before, l_2 res = 93.40871839685298, relative l_2 res = 1.0\n", + "[11-04 16:49:39][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:49:39][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:49:39][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:49:39][DEBUG] jax_fem: Function split_and_compute_cell took 0.0340 seconds\n", + "[11-04 16:49:39][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33504,), indices shape = (33504,), indptr shape = (15277,), b shape = (15276,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:49:40][DEBUG] jax_fem: l_2 res = 1.6432144185598733e-13, relative l_2 res = 1.759166003732725e-15\n", + "[11-04 16:49:40][INFO] jax_fem: Solve took 3.671433448791504 [s]\n", + "[11-04 16:49:40][INFO] jax_fem: max of dofs = 0.7939802832865741\n", + "[11-04 16:49:40][INFO] jax_fem: min of dofs = -2.254598172334348\n", + "[11-04 16:49:42][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 16:49:42][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:49:42][DEBUG] jax_fem: Function split_and_compute_cell took 0.0347 seconds\n", + "[11-04 16:49:43][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:49:43][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33504,), indices shape = (33504,), indptr shape = (15277,), b shape = (15276,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:49:43][DEBUG] jax_fem: Computing cell residual...\n", + "[11-04 16:49:44][DEBUG] jax_fem: Function split_and_compute_cell took 0.4882 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 19, Loss: 696.19\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:50:02][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:50:02][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:50:02][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:50:03][DEBUG] jax_fem: Done pre-computations, took 1.4114441871643066 [s]\n", + "[11-04 16:50:03][INFO] jax_fem: Solving a problem with 3270 cells, 5117x3 = 15351 dofs.\n", + "[11-04 16:50:03][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3270 elements.\n", + "(3270, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:50:07][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:50:07][DEBUG] jax_fem: Start timing\n", + "[11-04 16:50:07][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:50:08][DEBUG] jax_fem: Function split_and_compute_cell took 0.5730 seconds\n", + "[11-04 16:50:10][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:50:10][DEBUG] jax_fem: Before, l_2 res = 90.65518698583571, relative l_2 res = 1.0\n", + "[11-04 16:50:10][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:50:10][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:50:10][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:50:10][DEBUG] jax_fem: Function split_and_compute_cell took 0.0392 seconds\n", + "[11-04 16:50:10][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33570,), indices shape = (33570,), indptr shape = (15352,), b shape = (15351,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:50:11][DEBUG] jax_fem: l_2 res = 1.8473168173626305e-13, relative l_2 res = 2.037739790500087e-15\n", + "[11-04 16:50:11][INFO] jax_fem: Solve took 3.6807355880737305 [s]\n", + "[11-04 16:50:11][INFO] jax_fem: max of dofs = 0.7808311007857369\n", + "[11-04 16:50:11][INFO] jax_fem: min of dofs = -2.23450572038542\n", + "[11-04 16:50:13][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:50:13][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:50:13][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:50:15][DEBUG] jax_fem: Done pre-computations, took 1.5898642539978027 [s]\n", + "[11-04 16:50:15][INFO] jax_fem: Solving a problem with 3270 cells, 5117x3 = 15351 dofs.\n", + "[11-04 16:50:15][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3270 elements.\n", + "(3270, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:50:18][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:50:18][DEBUG] jax_fem: Start timing\n", + "[11-04 16:50:19][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:50:19][DEBUG] jax_fem: Function split_and_compute_cell took 0.5640 seconds\n", + "[11-04 16:50:21][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:50:21][DEBUG] jax_fem: Before, l_2 res = 90.65518698583571, relative l_2 res = 1.0\n", + "[11-04 16:50:21][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:50:21][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:50:22][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:50:22][DEBUG] jax_fem: Function split_and_compute_cell took 0.0337 seconds\n", + "[11-04 16:50:22][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33570,), indices shape = (33570,), indptr shape = (15352,), b shape = (15351,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:50:22][DEBUG] jax_fem: l_2 res = 1.8473168173626305e-13, relative l_2 res = 2.037739790500087e-15\n", + "[11-04 16:50:22][INFO] jax_fem: Solve took 3.5880632400512695 [s]\n", + "[11-04 16:50:22][INFO] jax_fem: max of dofs = 0.7808311007857369\n", + "[11-04 16:50:22][INFO] jax_fem: min of dofs = -2.23450572038542\n", + "[11-04 16:50:25][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 16:50:25][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:50:25][DEBUG] jax_fem: Function split_and_compute_cell took 0.0349 seconds\n", + "[11-04 16:50:25][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:50:25][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33570,), indices shape = (33570,), indptr shape = (15352,), b shape = (15351,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:50:26][DEBUG] jax_fem: Computing cell residual...\n", + "[11-04 16:50:26][DEBUG] jax_fem: Function split_and_compute_cell took 0.4668 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 20, Loss: 622.06\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:50:45][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:50:45][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:50:45][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:50:46][DEBUG] jax_fem: Done pre-computations, took 1.417344570159912 [s]\n", + "[11-04 16:50:46][INFO] jax_fem: Solving a problem with 3151 cells, 4982x3 = 14946 dofs.\n", + "[11-04 16:50:46][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3151 elements.\n", + "(3151, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:50:50][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:50:50][DEBUG] jax_fem: Start timing\n", + "[11-04 16:50:50][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:50:51][DEBUG] jax_fem: Function split_and_compute_cell took 0.5223 seconds\n", + "[11-04 16:50:52][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:50:53][DEBUG] jax_fem: Before, l_2 res = 93.37581026984515, relative l_2 res = 1.0\n", + "[11-04 16:50:53][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:50:53][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:50:53][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:50:53][DEBUG] jax_fem: Function split_and_compute_cell took 0.0388 seconds\n", + "[11-04 16:50:53][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33084,), indices shape = (33084,), indptr shape = (14947,), b shape = (14946,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:50:53][DEBUG] jax_fem: l_2 res = 1.6451773095470987e-13, relative l_2 res = 1.7618881215517478e-15\n", + "[11-04 16:50:53][INFO] jax_fem: Solve took 3.568408250808716 [s]\n", + "[11-04 16:50:54][INFO] jax_fem: max of dofs = 0.7691791387818464\n", + "[11-04 16:50:54][INFO] jax_fem: min of dofs = -2.2536532478647273\n", + "[11-04 16:50:56][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:50:56][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:50:56][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:50:57][DEBUG] jax_fem: Done pre-computations, took 1.5058317184448242 [s]\n", + "[11-04 16:50:57][INFO] jax_fem: Solving a problem with 3151 cells, 4982x3 = 14946 dofs.\n", + "[11-04 16:50:57][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3151 elements.\n", + "(3151, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:51:01][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:51:01][DEBUG] jax_fem: Start timing\n", + "[11-04 16:51:01][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:51:02][DEBUG] jax_fem: Function split_and_compute_cell took 0.5154 seconds\n", + "[11-04 16:51:03][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:51:04][DEBUG] jax_fem: Before, l_2 res = 93.37581026984515, relative l_2 res = 1.0\n", + "[11-04 16:51:04][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:51:04][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:51:04][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:51:04][DEBUG] jax_fem: Function split_and_compute_cell took 0.0337 seconds\n", + "[11-04 16:51:04][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33084,), indices shape = (33084,), indptr shape = (14947,), b shape = (14946,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:51:04][DEBUG] jax_fem: l_2 res = 1.6451773095470987e-13, relative l_2 res = 1.7618881215517478e-15\n", + "[11-04 16:51:04][INFO] jax_fem: Solve took 3.4468421936035156 [s]\n", + "[11-04 16:51:04][INFO] jax_fem: max of dofs = 0.7691791387818464\n", + "[11-04 16:51:04][INFO] jax_fem: min of dofs = -2.2536532478647273\n", + "[11-04 16:51:07][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 16:51:07][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:51:07][DEBUG] jax_fem: Function split_and_compute_cell took 0.0340 seconds\n", + "[11-04 16:51:07][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:51:07][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33084,), indices shape = (33084,), indptr shape = (14947,), b shape = (14946,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:51:08][DEBUG] jax_fem: Computing cell residual...\n", + "[11-04 16:51:08][DEBUG] jax_fem: Function split_and_compute_cell took 0.4655 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 21, Loss: 682.99\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:51:32][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:51:32][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:51:32][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:51:34][DEBUG] jax_fem: Done pre-computations, took 1.379098653793335 [s]\n", + "[11-04 16:51:34][INFO] jax_fem: Solving a problem with 3011 cells, 4834x3 = 14502 dofs.\n", + "[11-04 16:51:34][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3011 elements.\n", + "(3011, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:51:37][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:51:37][DEBUG] jax_fem: Start timing\n", + "[11-04 16:51:37][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:51:38][DEBUG] jax_fem: Function split_and_compute_cell took 0.5831 seconds\n", + "[11-04 16:51:40][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:51:40][DEBUG] jax_fem: Before, l_2 res = 93.51334902894615, relative l_2 res = 1.0\n", + "[11-04 16:51:40][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:51:40][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:51:41][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:51:41][DEBUG] jax_fem: Function split_and_compute_cell took 0.0382 seconds\n", + "[11-04 16:51:41][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32559,), indices shape = (32559,), indptr shape = (14503,), b shape = (14502,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:51:41][DEBUG] jax_fem: l_2 res = 2.2554727147670759e-13, relative l_2 res = 2.4119259316324093e-15\n", + "[11-04 16:51:41][INFO] jax_fem: Solve took 3.7968239784240723 [s]\n", + "[11-04 16:51:41][INFO] jax_fem: max of dofs = 0.7567293597778112\n", + "[11-04 16:51:41][INFO] jax_fem: min of dofs = -2.2515171105639578\n", + "[11-04 16:51:43][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:51:43][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:51:43][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:51:45][DEBUG] jax_fem: Done pre-computations, took 1.5423998832702637 [s]\n", + "[11-04 16:51:45][INFO] jax_fem: Solving a problem with 3011 cells, 4834x3 = 14502 dofs.\n", + "[11-04 16:51:45][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3011 elements.\n", + "(3011, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:51:48][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:51:48][DEBUG] jax_fem: Start timing\n", + "[11-04 16:51:48][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:51:49][DEBUG] jax_fem: Function split_and_compute_cell took 0.5628 seconds\n", + "[11-04 16:51:51][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:51:51][DEBUG] jax_fem: Before, l_2 res = 93.51334902894615, relative l_2 res = 1.0\n", + "[11-04 16:51:51][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:51:51][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:51:51][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:51:51][DEBUG] jax_fem: Function split_and_compute_cell took 0.0327 seconds\n", + "[11-04 16:51:51][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32559,), indices shape = (32559,), indptr shape = (14503,), b shape = (14502,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:51:52][DEBUG] jax_fem: l_2 res = 2.2554727147670759e-13, relative l_2 res = 2.4119259316324093e-15\n", + "[11-04 16:51:52][INFO] jax_fem: Solve took 3.501250743865967 [s]\n", + "[11-04 16:51:52][INFO] jax_fem: max of dofs = 0.7567293597778112\n", + "[11-04 16:51:52][INFO] jax_fem: min of dofs = -2.2515171105639578\n", + "[11-04 16:51:54][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 16:51:54][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:51:54][DEBUG] jax_fem: Function split_and_compute_cell took 0.0324 seconds\n", + "[11-04 16:51:54][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:51:55][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32559,), indices shape = (32559,), indptr shape = (14503,), b shape = (14502,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:51:55][DEBUG] jax_fem: Computing cell residual...\n", + "[11-04 16:51:56][DEBUG] jax_fem: Function split_and_compute_cell took 0.4830 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 22, Loss: 675.65\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:52:22][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:52:22][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:52:22][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:52:23][DEBUG] jax_fem: Done pre-computations, took 1.4161672592163086 [s]\n", + "[11-04 16:52:23][INFO] jax_fem: Solving a problem with 3032 cells, 4866x3 = 14598 dofs.\n", + "[11-04 16:52:23][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3032 elements.\n", + "(3032, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:52:27][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:52:27][DEBUG] jax_fem: Start timing\n", + "[11-04 16:52:27][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:52:28][DEBUG] jax_fem: Function split_and_compute_cell took 0.6284 seconds\n", + "[11-04 16:52:29][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:52:30][DEBUG] jax_fem: Before, l_2 res = 93.339897262708, relative l_2 res = 1.0\n", + "[11-04 16:52:30][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:52:30][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:52:30][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:52:30][DEBUG] jax_fem: Function split_and_compute_cell took 0.0372 seconds\n", + "[11-04 16:52:30][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32727,), indices shape = (32727,), indptr shape = (14599,), b shape = (14598,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:52:31][DEBUG] jax_fem: l_2 res = 2.2670821275786578e-13, relative l_2 res = 2.4288457498489477e-15\n", + "[11-04 16:52:31][INFO] jax_fem: Solve took 3.7797064781188965 [s]\n", + "[11-04 16:52:31][INFO] jax_fem: max of dofs = 0.7493548492382893\n", + "[11-04 16:52:31][INFO] jax_fem: min of dofs = -2.2479183454266587\n", + "[11-04 16:52:33][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:52:33][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:52:33][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:52:34][DEBUG] jax_fem: Done pre-computations, took 1.587559700012207 [s]\n", + "[11-04 16:52:34][INFO] jax_fem: Solving a problem with 3032 cells, 4866x3 = 14598 dofs.\n", + "[11-04 16:52:34][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3032 elements.\n", + "(3032, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:52:38][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:52:38][DEBUG] jax_fem: Start timing\n", + "[11-04 16:52:38][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:52:39][DEBUG] jax_fem: Function split_and_compute_cell took 0.5728 seconds\n", + "[11-04 16:52:41][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:52:41][DEBUG] jax_fem: Before, l_2 res = 93.339897262708, relative l_2 res = 1.0\n", + "[11-04 16:52:41][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:52:41][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:52:41][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:52:41][DEBUG] jax_fem: Function split_and_compute_cell took 0.0313 seconds\n", + "[11-04 16:52:41][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32727,), indices shape = (32727,), indptr shape = (14599,), b shape = (14598,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:52:42][DEBUG] jax_fem: l_2 res = 2.2670821275786578e-13, relative l_2 res = 2.4288457498489477e-15\n", + "[11-04 16:52:42][INFO] jax_fem: Solve took 3.6511728763580322 [s]\n", + "[11-04 16:52:42][INFO] jax_fem: max of dofs = 0.7493548492382893\n", + "[11-04 16:52:42][INFO] jax_fem: min of dofs = -2.2479183454266587\n", + "[11-04 16:52:44][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 16:52:44][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:52:44][DEBUG] jax_fem: Function split_and_compute_cell took 0.0330 seconds\n", + "[11-04 16:52:44][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:52:45][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32727,), indices shape = (32727,), indptr shape = (14599,), b shape = (14598,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:52:45][DEBUG] jax_fem: Computing cell residual...\n", + "[11-04 16:52:46][DEBUG] jax_fem: Function split_and_compute_cell took 0.4639 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 23, Loss: 669.72\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:53:10][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:53:10][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:53:10][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:53:11][DEBUG] jax_fem: Done pre-computations, took 1.346348524093628 [s]\n", + "[11-04 16:53:11][INFO] jax_fem: Solving a problem with 3004 cells, 4843x3 = 14529 dofs.\n", + "[11-04 16:53:11][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3004 elements.\n", + "(3004, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:53:15][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:53:15][DEBUG] jax_fem: Start timing\n", + "[11-04 16:53:15][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:53:16][DEBUG] jax_fem: Function split_and_compute_cell took 0.5565 seconds\n", + "[11-04 16:53:18][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:53:18][DEBUG] jax_fem: Before, l_2 res = 93.33989726270802, relative l_2 res = 1.0\n", + "[11-04 16:53:18][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:53:18][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:53:18][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:53:18][DEBUG] jax_fem: Function split_and_compute_cell took 0.0373 seconds\n", + "[11-04 16:53:18][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32658,), indices shape = (32658,), indptr shape = (14530,), b shape = (14529,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:53:19][DEBUG] jax_fem: l_2 res = 1.9164398174436207e-13, relative l_2 res = 2.053183979889909e-15\n", + "[11-04 16:53:19][INFO] jax_fem: Solve took 3.6658244132995605 [s]\n", + "[11-04 16:53:19][INFO] jax_fem: max of dofs = 0.7374546669258399\n", + "[11-04 16:53:19][INFO] jax_fem: min of dofs = -2.241864279807108\n", + "[11-04 16:53:21][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:53:21][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:53:21][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:53:22][DEBUG] jax_fem: Done pre-computations, took 1.4938008785247803 [s]\n", + "[11-04 16:53:22][INFO] jax_fem: Solving a problem with 3004 cells, 4843x3 = 14529 dofs.\n", + "[11-04 16:53:22][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3004 elements.\n", + "(3004, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:53:26][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:53:26][DEBUG] jax_fem: Start timing\n", + "[11-04 16:53:26][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:53:27][DEBUG] jax_fem: Function split_and_compute_cell took 0.5167 seconds\n", + "[11-04 16:53:28][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:53:29][DEBUG] jax_fem: Before, l_2 res = 93.33989726270802, relative l_2 res = 1.0\n", + "[11-04 16:53:29][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:53:29][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:53:29][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:53:29][DEBUG] jax_fem: Function split_and_compute_cell took 0.0323 seconds\n", + "[11-04 16:53:29][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32658,), indices shape = (32658,), indptr shape = (14530,), b shape = (14529,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:53:29][DEBUG] jax_fem: l_2 res = 1.9164398174436207e-13, relative l_2 res = 2.053183979889909e-15\n", + "[11-04 16:53:30][INFO] jax_fem: Solve took 3.5756680965423584 [s]\n", + "[11-04 16:53:30][INFO] jax_fem: max of dofs = 0.7374546669258399\n", + "[11-04 16:53:30][INFO] jax_fem: min of dofs = -2.241864279807108\n", + "[11-04 16:53:32][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 16:53:32][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:53:32][DEBUG] jax_fem: Function split_and_compute_cell took 0.0328 seconds\n", + "[11-04 16:53:32][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:53:32][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32658,), indices shape = (32658,), indptr shape = (14530,), b shape = (14529,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:53:33][DEBUG] jax_fem: Computing cell residual...\n", + "[11-04 16:53:33][DEBUG] jax_fem: Function split_and_compute_cell took 0.4259 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 24, Loss: 661.58\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:53:55][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:53:55][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:53:55][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:53:56][DEBUG] jax_fem: Done pre-computations, took 1.4084022045135498 [s]\n", + "[11-04 16:53:56][INFO] jax_fem: Solving a problem with 3004 cells, 4833x3 = 14499 dofs.\n", + "[11-04 16:53:56][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-04 16:53:59][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:53:59][DEBUG] jax_fem: Start timing\n", + "[11-04 16:53:59][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3004 elements.\n", + "(3004, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:53:59][DEBUG] jax_fem: Function split_and_compute_cell took 0.3312 seconds\n", + "[11-04 16:54:00][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:54:01][DEBUG] jax_fem: Before, l_2 res = 90.5811894510244, relative l_2 res = 1.0\n", + "[11-04 16:54:01][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:54:01][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:54:01][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:54:01][DEBUG] jax_fem: Function split_and_compute_cell took 0.0376 seconds\n", + "[11-04 16:54:01][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32700,), indices shape = (32700,), indptr shape = (14500,), b shape = (14499,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:54:01][DEBUG] jax_fem: l_2 res = 1.9482554733940397e-13, relative l_2 res = 2.1508389161167133e-15\n", + "[11-04 16:54:02][INFO] jax_fem: Solve took 2.9783194065093994 [s]\n", + "[11-04 16:54:02][INFO] jax_fem: max of dofs = 0.7249546635592812\n", + "[11-04 16:54:02][INFO] jax_fem: min of dofs = -2.2189064574619786\n", + "[11-04 16:54:04][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:54:04][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:54:04][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:54:05][DEBUG] jax_fem: Done pre-computations, took 1.487473487854004 [s]\n", + "[11-04 16:54:05][INFO] jax_fem: Solving a problem with 3004 cells, 4833x3 = 14499 dofs.\n", + "[11-04 16:54:05][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-04 16:54:08][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:54:08][DEBUG] jax_fem: Start timing\n", + "[11-04 16:54:08][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3004 elements.\n", + "(3004, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:54:08][DEBUG] jax_fem: Function split_and_compute_cell took 0.3325 seconds\n", + "[11-04 16:54:09][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:54:10][DEBUG] jax_fem: Before, l_2 res = 90.5811894510244, relative l_2 res = 1.0\n", + "[11-04 16:54:10][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:54:10][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:54:10][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:54:10][DEBUG] jax_fem: Function split_and_compute_cell took 0.0327 seconds\n", + "[11-04 16:54:10][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32700,), indices shape = (32700,), indptr shape = (14500,), b shape = (14499,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:54:10][DEBUG] jax_fem: l_2 res = 1.9482554733940397e-13, relative l_2 res = 2.1508389161167133e-15\n", + "[11-04 16:54:10][INFO] jax_fem: Solve took 2.9275124073028564 [s]\n", + "[11-04 16:54:11][INFO] jax_fem: max of dofs = 0.7249546635592812\n", + "[11-04 16:54:11][INFO] jax_fem: min of dofs = -2.2189064574619786\n", + "[11-04 16:54:13][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 16:54:13][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:54:13][DEBUG] jax_fem: Function split_and_compute_cell took 0.0329 seconds\n", + "[11-04 16:54:13][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:54:13][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:54:13][DEBUG] jax_fem: Computing cell residual...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32700,), indices shape = (32700,), indptr shape = (14500,), b shape = (14499,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:54:14][DEBUG] jax_fem: Function split_and_compute_cell took 0.3316 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 25, Loss: 587.91\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:54:31][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:54:31][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:54:31][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:54:32][DEBUG] jax_fem: Done pre-computations, took 1.3715639114379883 [s]\n", + "[11-04 16:54:32][INFO] jax_fem: Solving a problem with 3060 cells, 4895x3 = 14685 dofs.\n", + "[11-04 16:54:32][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3060 elements.\n", + "(3060, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:54:36][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:54:36][DEBUG] jax_fem: Start timing\n", + "[11-04 16:54:36][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:54:36][DEBUG] jax_fem: Function split_and_compute_cell took 0.3187 seconds\n", + "[11-04 16:54:38][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:54:38][DEBUG] jax_fem: Before, l_2 res = 90.5811894510244, relative l_2 res = 1.0\n", + "[11-04 16:54:38][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:54:38][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:54:38][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:54:39][DEBUG] jax_fem: Function split_and_compute_cell took 0.0384 seconds\n", + "[11-04 16:54:39][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32886,), indices shape = (32886,), indptr shape = (14686,), b shape = (14685,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:54:39][DEBUG] jax_fem: l_2 res = 1.7390516410634948e-13, relative l_2 res = 1.9198816571113456e-15\n", + "[11-04 16:54:39][INFO] jax_fem: Solve took 3.327167272567749 [s]\n", + "[11-04 16:54:39][INFO] jax_fem: max of dofs = 0.7125720882596072\n", + "[11-04 16:54:39][INFO] jax_fem: min of dofs = -2.2096662798337343\n", + "[11-04 16:54:41][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:54:41][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:54:41][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:54:43][DEBUG] jax_fem: Done pre-computations, took 1.5378289222717285 [s]\n", + "[11-04 16:54:43][INFO] jax_fem: Solving a problem with 3060 cells, 4895x3 = 14685 dofs.\n", + "[11-04 16:54:43][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3060 elements.\n", + "(3060, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:54:46][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:54:46][DEBUG] jax_fem: Start timing\n", + "[11-04 16:54:46][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:54:47][DEBUG] jax_fem: Function split_and_compute_cell took 0.3029 seconds\n", + "[11-04 16:54:49][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:54:49][DEBUG] jax_fem: Before, l_2 res = 90.5811894510244, relative l_2 res = 1.0\n", + "[11-04 16:54:49][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:54:49][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:54:49][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:54:49][DEBUG] jax_fem: Function split_and_compute_cell took 0.0330 seconds\n", + "[11-04 16:54:49][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32886,), indices shape = (32886,), indptr shape = (14686,), b shape = (14685,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:54:50][DEBUG] jax_fem: l_2 res = 1.7390516410634948e-13, relative l_2 res = 1.9198816571113456e-15\n", + "[11-04 16:54:50][INFO] jax_fem: Solve took 3.2648465633392334 [s]\n", + "[11-04 16:54:50][INFO] jax_fem: max of dofs = 0.7125720882596072\n", + "[11-04 16:54:50][INFO] jax_fem: min of dofs = -2.2096662798337343\n", + "[11-04 16:54:52][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 16:54:52][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:54:52][DEBUG] jax_fem: Function split_and_compute_cell took 0.0332 seconds\n", + "[11-04 16:54:52][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:54:53][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32886,), indices shape = (32886,), indptr shape = (14686,), b shape = (14685,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:54:53][DEBUG] jax_fem: Computing cell residual...\n", + "[11-04 16:54:53][DEBUG] jax_fem: Function split_and_compute_cell took 0.3192 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 26, Loss: 579.16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:55:05][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:55:05][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:55:05][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:55:07][DEBUG] jax_fem: Done pre-computations, took 1.3791093826293945 [s]\n", + "[11-04 16:55:07][INFO] jax_fem: Solving a problem with 3060 cells, 4899x3 = 14697 dofs.\n", + "[11-04 16:55:07][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-04 16:55:08][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:55:08][DEBUG] jax_fem: Start timing\n", + "[11-04 16:55:08][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3060 elements.\n", + "(3060, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:55:09][DEBUG] jax_fem: Function split_and_compute_cell took 0.2233 seconds\n", + "[11-04 16:55:10][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:55:10][DEBUG] jax_fem: Before, l_2 res = 90.58118945102439, relative l_2 res = 1.0\n", + "[11-04 16:55:10][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:55:10][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:55:10][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:55:10][DEBUG] jax_fem: Function split_and_compute_cell took 0.0382 seconds\n", + "[11-04 16:55:10][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32898,), indices shape = (32898,), indptr shape = (14698,), b shape = (14697,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:55:11][DEBUG] jax_fem: l_2 res = 1.7677702874475526e-13, relative l_2 res = 1.951586524930051e-15\n", + "[11-04 16:55:11][INFO] jax_fem: Solve took 2.4326958656311035 [s]\n", + "[11-04 16:55:11][INFO] jax_fem: max of dofs = 0.6995736658683966\n", + "[11-04 16:55:11][INFO] jax_fem: min of dofs = -2.19931092239766\n", + "[11-04 16:55:12][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:55:12][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:55:12][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:55:14][DEBUG] jax_fem: Done pre-computations, took 1.5471038818359375 [s]\n", + "[11-04 16:55:14][INFO] jax_fem: Solving a problem with 3060 cells, 4899x3 = 14697 dofs.\n", + "[11-04 16:55:14][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-04 16:55:16][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:55:16][DEBUG] jax_fem: Start timing\n", + "[11-04 16:55:16][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3060 elements.\n", + "(3060, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:55:16][DEBUG] jax_fem: Function split_and_compute_cell took 0.2110 seconds\n", + "[11-04 16:55:17][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:55:17][DEBUG] jax_fem: Before, l_2 res = 90.58118945102439, relative l_2 res = 1.0\n", + "[11-04 16:55:17][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:55:17][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:55:17][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:55:17][DEBUG] jax_fem: Function split_and_compute_cell took 0.0330 seconds\n", + "[11-04 16:55:18][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32898,), indices shape = (32898,), indptr shape = (14698,), b shape = (14697,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:55:18][DEBUG] jax_fem: l_2 res = 1.7677702874475526e-13, relative l_2 res = 1.951586524930051e-15\n", + "[11-04 16:55:18][INFO] jax_fem: Solve took 2.3361282348632812 [s]\n", + "[11-04 16:55:18][INFO] jax_fem: max of dofs = 0.6995736658683966\n", + "[11-04 16:55:18][INFO] jax_fem: min of dofs = -2.19931092239766\n", + "[11-04 16:55:20][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 16:55:20][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:55:20][DEBUG] jax_fem: Function split_and_compute_cell took 0.0332 seconds\n", + "[11-04 16:55:20][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:55:20][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:55:20][DEBUG] jax_fem: Computing cell residual...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32898,), indices shape = (32898,), indptr shape = (14698,), b shape = (14697,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:55:20][DEBUG] jax_fem: Function split_and_compute_cell took 0.2408 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 27, Loss: 569.78\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:55:32][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:55:32][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:55:32][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:55:33][DEBUG] jax_fem: Done pre-computations, took 1.3750207424163818 [s]\n", + "[11-04 16:55:33][INFO] jax_fem: Solving a problem with 3067 cells, 4913x3 = 14739 dofs.\n", + "[11-04 16:55:33][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3067 elements.\n", + "(3067, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:55:37][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:55:37][DEBUG] jax_fem: Start timing\n", + "[11-04 16:55:37][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:55:37][DEBUG] jax_fem: Function split_and_compute_cell took 0.5373 seconds\n", + "[11-04 16:55:39][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:55:39][DEBUG] jax_fem: Before, l_2 res = 85.82495776224587, relative l_2 res = 1.0\n", + "[11-04 16:55:39][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:55:39][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:55:40][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:55:40][DEBUG] jax_fem: Function split_and_compute_cell took 0.0374 seconds\n", + "[11-04 16:55:40][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32913,), indices shape = (32913,), indptr shape = (14740,), b shape = (14739,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:55:40][DEBUG] jax_fem: l_2 res = 1.8015437645557105e-13, relative l_2 res = 2.0990907674506353e-15\n", + "[11-04 16:55:40][INFO] jax_fem: Solve took 3.6127679347991943 [s]\n", + "[11-04 16:55:40][INFO] jax_fem: max of dofs = 0.6854018883324995\n", + "[11-04 16:55:40][INFO] jax_fem: min of dofs = -2.214670185645687\n", + "[11-04 16:55:42][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:55:42][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:55:42][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:55:44][DEBUG] jax_fem: Done pre-computations, took 1.5191774368286133 [s]\n", + "[11-04 16:55:44][INFO] jax_fem: Solving a problem with 3067 cells, 4913x3 = 14739 dofs.\n", + "[11-04 16:55:44][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3067 elements.\n", + "(3067, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:55:47][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:55:47][DEBUG] jax_fem: Start timing\n", + "[11-04 16:55:47][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:55:48][DEBUG] jax_fem: Function split_and_compute_cell took 0.5422 seconds\n", + "[11-04 16:55:50][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:55:50][DEBUG] jax_fem: Before, l_2 res = 85.82495776224587, relative l_2 res = 1.0\n", + "[11-04 16:55:50][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:55:50][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:55:50][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:55:50][DEBUG] jax_fem: Function split_and_compute_cell took 0.0328 seconds\n", + "[11-04 16:55:51][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32913,), indices shape = (32913,), indptr shape = (14740,), b shape = (14739,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:55:51][DEBUG] jax_fem: l_2 res = 1.8015437645557105e-13, relative l_2 res = 2.0990907674506353e-15\n", + "[11-04 16:55:51][INFO] jax_fem: Solve took 3.5569841861724854 [s]\n", + "[11-04 16:55:51][INFO] jax_fem: max of dofs = 0.6854018883324995\n", + "[11-04 16:55:51][INFO] jax_fem: min of dofs = -2.214670185645687\n", + "[11-04 16:55:53][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 16:55:53][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:55:53][DEBUG] jax_fem: Function split_and_compute_cell took 0.0328 seconds\n", + "[11-04 16:55:54][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:55:54][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32913,), indices shape = (32913,), indptr shape = (14740,), b shape = (14739,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:55:54][DEBUG] jax_fem: Computing cell residual...\n", + "[11-04 16:55:55][DEBUG] jax_fem: Function split_and_compute_cell took 0.4068 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 28, Loss: 557.74\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:56:13][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:56:13][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:56:13][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:56:14][DEBUG] jax_fem: Done pre-computations, took 1.3795650005340576 [s]\n", + "[11-04 16:56:14][INFO] jax_fem: Solving a problem with 3137 cells, 5033x3 = 15099 dofs.\n", + "[11-04 16:56:14][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3137 elements.\n", + "(3137, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:56:18][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:56:18][DEBUG] jax_fem: Start timing\n", + "[11-04 16:56:18][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:56:19][DEBUG] jax_fem: Function split_and_compute_cell took 0.5598 seconds\n", + "[11-04 16:56:20][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:56:21][DEBUG] jax_fem: Before, l_2 res = 82.42571311077582, relative l_2 res = 1.0\n", + "[11-04 16:56:21][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:56:21][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:56:21][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:56:21][DEBUG] jax_fem: Function split_and_compute_cell took 0.0392 seconds\n", + "[11-04 16:56:21][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33444,), indices shape = (33444,), indptr shape = (15100,), b shape = (15099,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:56:21][DEBUG] jax_fem: l_2 res = 1.3901086300454733e-13, relative l_2 res = 1.6864987606200513e-15\n", + "[11-04 16:56:22][INFO] jax_fem: Solve took 3.7460076808929443 [s]\n", + "[11-04 16:56:22][INFO] jax_fem: max of dofs = 0.6787240240039427\n", + "[11-04 16:56:22][INFO] jax_fem: min of dofs = -2.2461583902597133\n", + "[11-04 16:56:24][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:56:24][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:56:24][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:56:25][DEBUG] jax_fem: Done pre-computations, took 1.5765094757080078 [s]\n", + "[11-04 16:56:25][INFO] jax_fem: Solving a problem with 3137 cells, 5033x3 = 15099 dofs.\n", + "[11-04 16:56:25][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3137 elements.\n", + "(3137, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:56:29][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:56:29][DEBUG] jax_fem: Start timing\n", + "[11-04 16:56:29][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:56:30][DEBUG] jax_fem: Function split_and_compute_cell took 0.5596 seconds\n", + "[11-04 16:56:34][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:56:34][DEBUG] jax_fem: Before, l_2 res = 82.42571311077582, relative l_2 res = 1.0\n", + "[11-04 16:56:34][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:56:34][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:56:34][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:56:34][DEBUG] jax_fem: Function split_and_compute_cell took 0.0335 seconds\n", + "[11-04 16:56:34][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33444,), indices shape = (33444,), indptr shape = (15100,), b shape = (15099,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:56:35][DEBUG] jax_fem: l_2 res = 1.3901086300454733e-13, relative l_2 res = 1.6864987606200513e-15\n", + "[11-04 16:56:35][INFO] jax_fem: Solve took 5.538772821426392 [s]\n", + "[11-04 16:56:35][INFO] jax_fem: max of dofs = 0.6787240240039427\n", + "[11-04 16:56:35][INFO] jax_fem: min of dofs = -2.2461583902597133\n", + "[11-04 16:56:37][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 16:56:37][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:56:38][DEBUG] jax_fem: Function split_and_compute_cell took 0.0343 seconds\n", + "[11-04 16:56:38][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:56:38][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (33444,), indices shape = (33444,), indptr shape = (15100,), b shape = (15099,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:56:38][DEBUG] jax_fem: Computing cell residual...\n", + "[11-04 16:56:39][DEBUG] jax_fem: Function split_and_compute_cell took 0.4879 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 29, Loss: 546.56\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:56:58][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:56:58][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:56:58][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:56:58][DEBUG] jax_fem: Done pre-computations, took 0.5445718765258789 [s]\n", + "[11-04 16:56:58][INFO] jax_fem: Solving a problem with 2990 cells, 4913x3 = 14739 dofs.\n", + "[11-04 16:56:58][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 2990 elements.\n", + "(2990, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:57:02][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:57:02][DEBUG] jax_fem: Start timing\n", + "[11-04 16:57:02][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:57:03][DEBUG] jax_fem: Function split_and_compute_cell took 0.6251 seconds\n", + "[11-04 16:57:04][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:57:04][DEBUG] jax_fem: Before, l_2 res = 88.29447891907655, relative l_2 res = 1.0\n", + "[11-04 16:57:04][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:57:04][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:57:04][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:57:04][DEBUG] jax_fem: Function split_and_compute_cell took 0.0377 seconds\n", + "[11-04 16:57:04][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32616,), indices shape = (32616,), indptr shape = (14740,), b shape = (14739,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:57:05][DEBUG] jax_fem: l_2 res = 3.957540754052386e-13, relative l_2 res = 4.482206364997682e-15\n", + "[11-04 16:57:05][INFO] jax_fem: Solve took 2.7229318618774414 [s]\n", + "[11-04 16:57:05][INFO] jax_fem: max of dofs = 0.6718322800121677\n", + "[11-04 16:57:05][INFO] jax_fem: min of dofs = -2.1764100567648748\n", + "[11-04 16:57:07][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:57:07][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:57:07][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:57:07][DEBUG] jax_fem: Done pre-computations, took 0.5327563285827637 [s]\n", + "[11-04 16:57:07][INFO] jax_fem: Solving a problem with 2990 cells, 4913x3 = 14739 dofs.\n", + "[11-04 16:57:07][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 2990 elements.\n", + "(2990, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:57:11][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:57:11][DEBUG] jax_fem: Start timing\n", + "[11-04 16:57:11][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:57:12][DEBUG] jax_fem: Function split_and_compute_cell took 0.6088 seconds\n", + "[11-04 16:57:13][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:57:13][DEBUG] jax_fem: Before, l_2 res = 88.29447891907655, relative l_2 res = 1.0\n", + "[11-04 16:57:13][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:57:13][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:57:13][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:57:13][DEBUG] jax_fem: Function split_and_compute_cell took 0.0325 seconds\n", + "[11-04 16:57:13][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32616,), indices shape = (32616,), indptr shape = (14740,), b shape = (14739,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:57:14][DEBUG] jax_fem: l_2 res = 3.957540754052386e-13, relative l_2 res = 4.482206364997682e-15\n", + "[11-04 16:57:14][INFO] jax_fem: Solve took 2.6512808799743652 [s]\n", + "[11-04 16:57:14][INFO] jax_fem: max of dofs = 0.6718322800121677\n", + "[11-04 16:57:14][INFO] jax_fem: min of dofs = -2.1764100567648748\n", + "[11-04 16:57:16][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 16:57:16][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:57:16][DEBUG] jax_fem: Function split_and_compute_cell took 0.0334 seconds\n", + "[11-04 16:57:16][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:57:17][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32616,), indices shape = (32616,), indptr shape = (14740,), b shape = (14739,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:57:17][DEBUG] jax_fem: Computing cell residual...\n", + "[11-04 16:57:18][DEBUG] jax_fem: Function split_and_compute_cell took 0.5005 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 30, Loss: 539.20\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:57:32][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:57:32][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:57:32][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:57:33][DEBUG] jax_fem: Done pre-computations, took 1.3817179203033447 [s]\n", + "[11-04 16:57:33][INFO] jax_fem: Solving a problem with 3039 cells, 4934x3 = 14802 dofs.\n", + "[11-04 16:57:33][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3039 elements.\n", + "(3039, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:57:36][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:57:36][DEBUG] jax_fem: Start timing\n", + "[11-04 16:57:37][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:57:37][DEBUG] jax_fem: Function split_and_compute_cell took 0.5529 seconds\n", + "[11-04 16:57:39][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:57:39][DEBUG] jax_fem: Before, l_2 res = 87.03076103936029, relative l_2 res = 1.0\n", + "[11-04 16:57:39][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:57:40][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:57:40][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:57:40][DEBUG] jax_fem: Function split_and_compute_cell took 0.0381 seconds\n", + "[11-04 16:57:40][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32427,), indices shape = (32427,), indptr shape = (14803,), b shape = (14802,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:57:40][DEBUG] jax_fem: l_2 res = 3.194750523480697e-13, relative l_2 res = 3.670829124469965e-15\n", + "[11-04 16:57:40][INFO] jax_fem: Solve took 3.724241018295288 [s]\n", + "[11-04 16:57:40][INFO] jax_fem: max of dofs = 0.659182386140057\n", + "[11-04 16:57:40][INFO] jax_fem: min of dofs = -2.175881302839424\n", + "[11-04 16:57:42][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:57:42][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:57:42][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:57:44][DEBUG] jax_fem: Done pre-computations, took 1.5432136058807373 [s]\n", + "[11-04 16:57:44][INFO] jax_fem: Solving a problem with 3039 cells, 4934x3 = 14802 dofs.\n", + "[11-04 16:57:44][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3039 elements.\n", + "(3039, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:57:47][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:57:47][DEBUG] jax_fem: Start timing\n", + "[11-04 16:57:48][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:57:48][DEBUG] jax_fem: Function split_and_compute_cell took 0.5399 seconds\n", + "[11-04 16:57:50][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:57:50][DEBUG] jax_fem: Before, l_2 res = 87.03076103936029, relative l_2 res = 1.0\n", + "[11-04 16:57:50][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:57:50][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:57:50][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:57:50][DEBUG] jax_fem: Function split_and_compute_cell took 0.0331 seconds\n", + "[11-04 16:57:51][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32427,), indices shape = (32427,), indptr shape = (14803,), b shape = (14802,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:57:51][DEBUG] jax_fem: l_2 res = 3.194750523480697e-13, relative l_2 res = 3.670829124469965e-15\n", + "[11-04 16:57:51][INFO] jax_fem: Solve took 3.505213737487793 [s]\n", + "[11-04 16:57:51][INFO] jax_fem: max of dofs = 0.659182386140057\n", + "[11-04 16:57:51][INFO] jax_fem: min of dofs = -2.175881302839424\n", + "[11-04 16:57:54][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 16:57:54][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:57:54][DEBUG] jax_fem: Function split_and_compute_cell took 0.0328 seconds\n", + "[11-04 16:57:54][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:57:54][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32427,), indices shape = (32427,), indptr shape = (14803,), b shape = (14802,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:57:54][DEBUG] jax_fem: Computing cell residual...\n", + "[11-04 16:57:55][DEBUG] jax_fem: Function split_and_compute_cell took 0.4210 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 31, Loss: 532.29\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:58:12][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:58:12][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:58:12][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:58:13][DEBUG] jax_fem: Done pre-computations, took 1.431959867477417 [s]\n", + "[11-04 16:58:13][INFO] jax_fem: Solving a problem with 3039 cells, 4941x3 = 14823 dofs.\n", + "[11-04 16:58:13][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-04 16:58:15][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:58:15][DEBUG] jax_fem: Start timing\n", + "[11-04 16:58:16][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3039 elements.\n", + "(3039, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:58:16][DEBUG] jax_fem: Function split_and_compute_cell took 0.3735 seconds\n", + "[11-04 16:58:17][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:58:18][DEBUG] jax_fem: Before, l_2 res = 87.29521083389224, relative l_2 res = 1.0\n", + "[11-04 16:58:18][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:58:18][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:58:18][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:58:18][DEBUG] jax_fem: Function split_and_compute_cell took 0.0385 seconds\n", + "[11-04 16:58:18][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32493,), indices shape = (32493,), indptr shape = (14824,), b shape = (14823,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:58:18][DEBUG] jax_fem: l_2 res = 1.9808796129272664e-13, relative l_2 res = 2.2691732959973477e-15\n", + "[11-04 16:58:19][INFO] jax_fem: Solve took 3.1263716220855713 [s]\n", + "[11-04 16:58:19][INFO] jax_fem: max of dofs = 0.645899002302105\n", + "[11-04 16:58:19][INFO] jax_fem: min of dofs = -2.1748615083462006\n", + "[11-04 16:58:21][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:58:21][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:58:21][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:58:22][DEBUG] jax_fem: Done pre-computations, took 1.6103780269622803 [s]\n", + "[11-04 16:58:22][INFO] jax_fem: Solving a problem with 3039 cells, 4941x3 = 14823 dofs.\n", + "[11-04 16:58:22][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-04 16:58:25][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:58:25][DEBUG] jax_fem: Start timing\n", + "[11-04 16:58:25][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3039 elements.\n", + "(3039, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:58:25][DEBUG] jax_fem: Function split_and_compute_cell took 0.3691 seconds\n", + "[11-04 16:58:26][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:58:27][DEBUG] jax_fem: Before, l_2 res = 87.29521083389224, relative l_2 res = 1.0\n", + "[11-04 16:58:27][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:58:27][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:58:27][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:58:27][DEBUG] jax_fem: Function split_and_compute_cell took 0.0332 seconds\n", + "[11-04 16:58:27][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32493,), indices shape = (32493,), indptr shape = (14824,), b shape = (14823,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:58:27][DEBUG] jax_fem: l_2 res = 1.9808796129272664e-13, relative l_2 res = 2.2691732959973477e-15\n", + "[11-04 16:58:28][INFO] jax_fem: Solve took 2.9962146282196045 [s]\n", + "[11-04 16:58:28][INFO] jax_fem: max of dofs = 0.645899002302105\n", + "[11-04 16:58:28][INFO] jax_fem: min of dofs = -2.1748615083462006\n", + "[11-04 16:58:30][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 16:58:30][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:58:30][DEBUG] jax_fem: Function split_and_compute_cell took 0.0337 seconds\n", + "[11-04 16:58:30][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:58:31][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:58:31][DEBUG] jax_fem: Computing cell residual...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32493,), indices shape = (32493,), indptr shape = (14824,), b shape = (14823,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:58:31][DEBUG] jax_fem: Function split_and_compute_cell took 0.3378 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 32, Loss: 523.40\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:58:47][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:58:47][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:58:47][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:58:49][DEBUG] jax_fem: Done pre-computations, took 1.3756144046783447 [s]\n", + "[11-04 16:58:49][INFO] jax_fem: Solving a problem with 3032 cells, 4948x3 = 14844 dofs.\n", + "[11-04 16:58:49][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3032 elements.\n", + "(3032, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:58:52][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:58:52][DEBUG] jax_fem: Start timing\n", + "[11-04 16:58:52][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:58:53][DEBUG] jax_fem: Function split_and_compute_cell took 0.5817 seconds\n", + "[11-04 16:58:55][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:58:55][DEBUG] jax_fem: Before, l_2 res = 86.96492453525423, relative l_2 res = 1.0\n", + "[11-04 16:58:55][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:58:55][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:58:55][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:58:55][DEBUG] jax_fem: Function split_and_compute_cell took 0.0385 seconds\n", + "[11-04 16:58:56][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32442,), indices shape = (32442,), indptr shape = (14845,), b shape = (14844,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:58:56][DEBUG] jax_fem: l_2 res = 2.49862283198753e-13, relative l_2 res = 2.873138619208055e-15\n", + "[11-04 16:58:56][INFO] jax_fem: Solve took 3.7021334171295166 [s]\n", + "[11-04 16:58:56][INFO] jax_fem: max of dofs = 0.6346682903912926\n", + "[11-04 16:58:56][INFO] jax_fem: min of dofs = -2.1793100676294874\n", + "[11-04 16:58:58][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:58:58][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:58:58][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:59:00][DEBUG] jax_fem: Done pre-computations, took 1.5193629264831543 [s]\n", + "[11-04 16:59:00][INFO] jax_fem: Solving a problem with 3032 cells, 4948x3 = 14844 dofs.\n", + "[11-04 16:59:00][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3032 elements.\n", + "(3032, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:59:03][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:59:03][DEBUG] jax_fem: Start timing\n", + "[11-04 16:59:03][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:59:04][DEBUG] jax_fem: Function split_and_compute_cell took 0.5710 seconds\n", + "[11-04 16:59:06][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:59:06][DEBUG] jax_fem: Before, l_2 res = 86.96492453525423, relative l_2 res = 1.0\n", + "[11-04 16:59:06][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:59:06][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:59:06][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:59:06][DEBUG] jax_fem: Function split_and_compute_cell took 0.0334 seconds\n", + "[11-04 16:59:07][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32442,), indices shape = (32442,), indptr shape = (14845,), b shape = (14844,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:59:07][DEBUG] jax_fem: l_2 res = 2.49862283198753e-13, relative l_2 res = 2.873138619208055e-15\n", + "[11-04 16:59:07][INFO] jax_fem: Solve took 3.65861177444458 [s]\n", + "[11-04 16:59:07][INFO] jax_fem: max of dofs = 0.6346682903912926\n", + "[11-04 16:59:07][INFO] jax_fem: min of dofs = -2.1793100676294874\n", + "[11-04 16:59:10][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 16:59:10][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:59:10][DEBUG] jax_fem: Function split_and_compute_cell took 0.0345 seconds\n", + "[11-04 16:59:10][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:59:10][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32442,), indices shape = (32442,), indptr shape = (14845,), b shape = (14844,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:59:10][DEBUG] jax_fem: Computing cell residual...\n", + "[11-04 16:59:11][DEBUG] jax_fem: Function split_and_compute_cell took 0.4217 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 33, Loss: 519.30\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:59:24][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:59:24][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:59:24][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:59:26][DEBUG] jax_fem: Done pre-computations, took 1.4024131298065186 [s]\n", + "[11-04 16:59:26][INFO] jax_fem: Solving a problem with 3046 cells, 4961x3 = 14883 dofs.\n", + "[11-04 16:59:26][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3046 elements.\n", + "(3046, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:59:29][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:59:29][DEBUG] jax_fem: Start timing\n", + "[11-04 16:59:29][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:59:30][DEBUG] jax_fem: Function split_and_compute_cell took 0.5579 seconds\n", + "[11-04 16:59:32][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:59:32][DEBUG] jax_fem: Before, l_2 res = 86.19203585860016, relative l_2 res = 1.0\n", + "[11-04 16:59:32][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:59:33][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:59:33][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:59:33][DEBUG] jax_fem: Function split_and_compute_cell took 0.0394 seconds\n", + "[11-04 16:59:33][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32445,), indices shape = (32445,), indptr shape = (14884,), b shape = (14883,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:59:33][DEBUG] jax_fem: l_2 res = 1.6002912464309456e-13, relative l_2 res = 1.8566579040507373e-15\n", + "[11-04 16:59:33][INFO] jax_fem: Solve took 3.8198137283325195 [s]\n", + "[11-04 16:59:33][INFO] jax_fem: max of dofs = 0.6244942635179442\n", + "[11-04 16:59:33][INFO] jax_fem: min of dofs = -2.1760168836930065\n", + "[11-04 16:59:35][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 16:59:35][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 16:59:35][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 16:59:37][DEBUG] jax_fem: Done pre-computations, took 1.5633773803710938 [s]\n", + "[11-04 16:59:37][INFO] jax_fem: Solving a problem with 3046 cells, 4961x3 = 14883 dofs.\n", + "[11-04 16:59:37][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3046 elements.\n", + "(3046, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:59:41][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 16:59:41][DEBUG] jax_fem: Start timing\n", + "[11-04 16:59:41][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:59:42][DEBUG] jax_fem: Function split_and_compute_cell took 0.5392 seconds\n", + "[11-04 16:59:43][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:59:44][DEBUG] jax_fem: Before, l_2 res = 86.19203585860016, relative l_2 res = 1.0\n", + "[11-04 16:59:44][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 16:59:44][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 16:59:44][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:59:44][DEBUG] jax_fem: Function split_and_compute_cell took 0.0323 seconds\n", + "[11-04 16:59:44][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32445,), indices shape = (32445,), indptr shape = (14884,), b shape = (14883,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:59:44][DEBUG] jax_fem: l_2 res = 1.6002912464309456e-13, relative l_2 res = 1.8566579040507373e-15\n", + "[11-04 16:59:45][INFO] jax_fem: Solve took 3.6483898162841797 [s]\n", + "[11-04 16:59:45][INFO] jax_fem: max of dofs = 0.6244942635179442\n", + "[11-04 16:59:45][INFO] jax_fem: min of dofs = -2.1760168836930065\n", + "[11-04 16:59:47][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 16:59:47][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 16:59:47][DEBUG] jax_fem: Function split_and_compute_cell took 0.0336 seconds\n", + "[11-04 16:59:47][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 16:59:48][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32445,), indices shape = (32445,), indptr shape = (14884,), b shape = (14883,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 16:59:48][DEBUG] jax_fem: Computing cell residual...\n", + "[11-04 16:59:49][DEBUG] jax_fem: Function split_and_compute_cell took 0.4962 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 34, Loss: 513.28\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:00:07][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 17:00:07][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 17:00:07][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 17:00:09][DEBUG] jax_fem: Done pre-computations, took 1.3692197799682617 [s]\n", + "[11-04 17:00:09][INFO] jax_fem: Solving a problem with 3102 cells, 4960x3 = 14880 dofs.\n", + "[11-04 17:00:09][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3102 elements.\n", + "(3102, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:00:12][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 17:00:12][DEBUG] jax_fem: Start timing\n", + "[11-04 17:00:12][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:00:13][DEBUG] jax_fem: Function split_and_compute_cell took 0.5987 seconds\n", + "[11-04 17:00:15][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 17:00:15][DEBUG] jax_fem: Before, l_2 res = 81.23754075696907, relative l_2 res = 1.0\n", + "[11-04 17:00:15][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 17:00:15][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 17:00:15][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:00:15][DEBUG] jax_fem: Function split_and_compute_cell took 0.0377 seconds\n", + "[11-04 17:00:16][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32595,), indices shape = (32595,), indptr shape = (14881,), b shape = (14880,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:00:16][DEBUG] jax_fem: l_2 res = 1.7798521580919644e-13, relative l_2 res = 2.1909232375910857e-15\n", + "[11-04 17:00:16][INFO] jax_fem: Solve took 3.843214750289917 [s]\n", + "[11-04 17:00:16][INFO] jax_fem: max of dofs = 0.6279556837633204\n", + "[11-04 17:00:16][INFO] jax_fem: min of dofs = -2.1701647471892342\n", + "[11-04 17:00:18][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 17:00:18][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 17:00:18][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 17:00:20][DEBUG] jax_fem: Done pre-computations, took 1.6534738540649414 [s]\n", + "[11-04 17:00:20][INFO] jax_fem: Solving a problem with 3102 cells, 4960x3 = 14880 dofs.\n", + "[11-04 17:00:20][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3102 elements.\n", + "(3102, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:00:24][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 17:00:24][DEBUG] jax_fem: Start timing\n", + "[11-04 17:00:24][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:00:25][DEBUG] jax_fem: Function split_and_compute_cell took 0.5964 seconds\n", + "[11-04 17:00:26][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 17:00:27][DEBUG] jax_fem: Before, l_2 res = 81.23754075696907, relative l_2 res = 1.0\n", + "[11-04 17:00:27][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 17:00:27][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 17:00:27][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:00:27][DEBUG] jax_fem: Function split_and_compute_cell took 0.0314 seconds\n", + "[11-04 17:00:27][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32595,), indices shape = (32595,), indptr shape = (14881,), b shape = (14880,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:00:27][DEBUG] jax_fem: l_2 res = 1.7798521580919644e-13, relative l_2 res = 2.1909232375910857e-15\n", + "[11-04 17:00:28][INFO] jax_fem: Solve took 3.8165369033813477 [s]\n", + "[11-04 17:00:28][INFO] jax_fem: max of dofs = 0.6279556837633204\n", + "[11-04 17:00:28][INFO] jax_fem: min of dofs = -2.1701647471892342\n", + "[11-04 17:00:30][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 17:00:30][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:00:30][DEBUG] jax_fem: Function split_and_compute_cell took 0.0319 seconds\n", + "[11-04 17:00:30][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 17:00:31][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32595,), indices shape = (32595,), indptr shape = (14881,), b shape = (14880,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:00:31][DEBUG] jax_fem: Computing cell residual...\n", + "[11-04 17:00:32][DEBUG] jax_fem: Function split_and_compute_cell took 0.4960 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 35, Loss: 479.60\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:00:57][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 17:00:57][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 17:00:57][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 17:00:58][DEBUG] jax_fem: Done pre-computations, took 1.3363053798675537 [s]\n", + "[11-04 17:00:58][INFO] jax_fem: Solving a problem with 3109 cells, 4954x3 = 14862 dofs.\n", + "[11-04 17:00:58][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3109 elements.\n", + "(3109, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:01:02][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 17:01:02][DEBUG] jax_fem: Start timing\n", + "[11-04 17:01:02][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:01:03][DEBUG] jax_fem: Function split_and_compute_cell took 0.5768 seconds\n", + "[11-04 17:01:04][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 17:01:05][DEBUG] jax_fem: Before, l_2 res = 84.15329379992268, relative l_2 res = 1.0\n", + "[11-04 17:01:05][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 17:01:05][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 17:01:05][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:01:05][DEBUG] jax_fem: Function split_and_compute_cell took 0.0375 seconds\n", + "[11-04 17:01:05][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32505,), indices shape = (32505,), indptr shape = (14863,), b shape = (14862,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:01:05][DEBUG] jax_fem: l_2 res = 1.891162387243872e-13, relative l_2 res = 2.247282669339331e-15\n", + "[11-04 17:01:05][INFO] jax_fem: Solve took 3.7948222160339355 [s]\n", + "[11-04 17:01:05][INFO] jax_fem: max of dofs = 0.6253659428205023\n", + "[11-04 17:01:06][INFO] jax_fem: min of dofs = -2.1636458857776755\n", + "[11-04 17:01:08][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 17:01:08][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 17:01:08][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 17:01:09][DEBUG] jax_fem: Done pre-computations, took 1.5655004978179932 [s]\n", + "[11-04 17:01:09][INFO] jax_fem: Solving a problem with 3109 cells, 4954x3 = 14862 dofs.\n", + "[11-04 17:01:09][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3109 elements.\n", + "(3109, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:01:13][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 17:01:13][DEBUG] jax_fem: Start timing\n", + "[11-04 17:01:13][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:01:14][DEBUG] jax_fem: Function split_and_compute_cell took 0.5973 seconds\n", + "[11-04 17:01:17][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 17:01:18][DEBUG] jax_fem: Before, l_2 res = 84.15329379992268, relative l_2 res = 1.0\n", + "[11-04 17:01:18][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 17:01:18][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 17:01:18][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:01:18][DEBUG] jax_fem: Function split_and_compute_cell took 0.0334 seconds\n", + "[11-04 17:01:18][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32505,), indices shape = (32505,), indptr shape = (14863,), b shape = (14862,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:01:19][DEBUG] jax_fem: l_2 res = 1.891162387243872e-13, relative l_2 res = 2.247282669339331e-15\n", + "[11-04 17:01:19][INFO] jax_fem: Solve took 5.563593626022339 [s]\n", + "[11-04 17:01:19][INFO] jax_fem: max of dofs = 0.6253659428205023\n", + "[11-04 17:01:19][INFO] jax_fem: min of dofs = -2.1636458857776755\n", + "[11-04 17:01:21][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 17:01:21][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:01:21][DEBUG] jax_fem: Function split_and_compute_cell took 0.0332 seconds\n", + "[11-04 17:01:21][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 17:01:22][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32505,), indices shape = (32505,), indptr shape = (14863,), b shape = (14862,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:01:22][DEBUG] jax_fem: Computing cell residual...\n", + "[11-04 17:01:23][DEBUG] jax_fem: Function split_and_compute_cell took 0.4226 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 36, Loss: 507.65\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:01:45][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 17:01:45][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 17:01:45][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 17:01:46][DEBUG] jax_fem: Done pre-computations, took 1.4101784229278564 [s]\n", + "[11-04 17:01:46][INFO] jax_fem: Solving a problem with 3046 cells, 4898x3 = 14694 dofs.\n", + "[11-04 17:01:46][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-04 17:01:49][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 17:01:49][DEBUG] jax_fem: Start timing\n", + "[11-04 17:01:49][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3046 elements.\n", + "(3046, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:01:49][DEBUG] jax_fem: Function split_and_compute_cell took 0.3392 seconds\n", + "[11-04 17:01:51][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 17:01:51][DEBUG] jax_fem: Before, l_2 res = 84.15329379992266, relative l_2 res = 1.0\n", + "[11-04 17:01:51][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 17:01:51][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 17:01:51][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:01:51][DEBUG] jax_fem: Function split_and_compute_cell took 0.0457 seconds\n", + "[11-04 17:01:51][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32337,), indices shape = (32337,), indptr shape = (14695,), b shape = (14694,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:01:52][DEBUG] jax_fem: l_2 res = 2.2989307166511675e-13, relative l_2 res = 2.7318368810577445e-15\n", + "[11-04 17:01:52][INFO] jax_fem: Solve took 3.121657133102417 [s]\n", + "[11-04 17:01:52][INFO] jax_fem: max of dofs = 0.6182945291288967\n", + "[11-04 17:01:52][INFO] jax_fem: min of dofs = -2.1555572746475904\n", + "[11-04 17:01:54][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 17:01:54][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 17:01:54][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 17:01:55][DEBUG] jax_fem: Done pre-computations, took 1.6089355945587158 [s]\n", + "[11-04 17:01:55][INFO] jax_fem: Solving a problem with 3046 cells, 4898x3 = 14694 dofs.\n", + "[11-04 17:01:55][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-04 17:01:58][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 17:01:58][DEBUG] jax_fem: Start timing\n", + "[11-04 17:01:58][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3046 elements.\n", + "(3046, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:01:58][DEBUG] jax_fem: Function split_and_compute_cell took 0.4013 seconds\n", + "[11-04 17:02:00][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 17:02:00][DEBUG] jax_fem: Before, l_2 res = 84.15329379992266, relative l_2 res = 1.0\n", + "[11-04 17:02:00][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 17:02:00][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 17:02:00][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:02:00][DEBUG] jax_fem: Function split_and_compute_cell took 0.0344 seconds\n", + "[11-04 17:02:00][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32337,), indices shape = (32337,), indptr shape = (14695,), b shape = (14694,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:02:01][DEBUG] jax_fem: l_2 res = 2.2989307166511675e-13, relative l_2 res = 2.7318368810577445e-15\n", + "[11-04 17:02:01][INFO] jax_fem: Solve took 3.1223058700561523 [s]\n", + "[11-04 17:02:01][INFO] jax_fem: max of dofs = 0.6182945291288967\n", + "[11-04 17:02:01][INFO] jax_fem: min of dofs = -2.1555572746475904\n", + "[11-04 17:02:03][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 17:02:03][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:02:04][DEBUG] jax_fem: Function split_and_compute_cell took 0.0343 seconds\n", + "[11-04 17:02:04][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 17:02:04][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 17:02:04][DEBUG] jax_fem: Computing cell residual...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32337,), indices shape = (32337,), indptr shape = (14695,), b shape = (14694,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:02:04][DEBUG] jax_fem: Function split_and_compute_cell took 0.3500 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 37, Loss: 502.68\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:02:21][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 17:02:21][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 17:02:21][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 17:02:22][DEBUG] jax_fem: Done pre-computations, took 1.4713587760925293 [s]\n", + "[11-04 17:02:22][INFO] jax_fem: Solving a problem with 2990 cells, 4839x3 = 14517 dofs.\n", + "[11-04 17:02:22][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 2990 elements.\n", + "(2990, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:02:26][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 17:02:26][DEBUG] jax_fem: Start timing\n", + "[11-04 17:02:26][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:02:27][DEBUG] jax_fem: Function split_and_compute_cell took 0.5909 seconds\n", + "[11-04 17:02:29][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 17:02:29][DEBUG] jax_fem: Before, l_2 res = 84.15329379992268, relative l_2 res = 1.0\n", + "[11-04 17:02:29][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 17:02:29][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 17:02:29][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:02:29][DEBUG] jax_fem: Function split_and_compute_cell took 0.0376 seconds\n", + "[11-04 17:02:29][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32160,), indices shape = (32160,), indptr shape = (14518,), b shape = (14517,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:02:30][DEBUG] jax_fem: l_2 res = 2.8006842658959954e-13, relative l_2 res = 3.328074445374316e-15\n", + "[11-04 17:02:30][INFO] jax_fem: Solve took 3.7422592639923096 [s]\n", + "[11-04 17:02:30][INFO] jax_fem: max of dofs = 0.6142123562681211\n", + "[11-04 17:02:30][INFO] jax_fem: min of dofs = -2.1459955163450197\n", + "[11-04 17:02:32][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 17:02:32][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 17:02:32][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 17:02:34][DEBUG] jax_fem: Done pre-computations, took 1.5725409984588623 [s]\n", + "[11-04 17:02:34][INFO] jax_fem: Solving a problem with 2990 cells, 4839x3 = 14517 dofs.\n", + "[11-04 17:02:34][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 2990 elements.\n", + "(2990, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:02:37][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 17:02:37][DEBUG] jax_fem: Start timing\n", + "[11-04 17:02:37][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:02:38][DEBUG] jax_fem: Function split_and_compute_cell took 0.5794 seconds\n", + "[11-04 17:02:40][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 17:02:40][DEBUG] jax_fem: Before, l_2 res = 84.15329379992268, relative l_2 res = 1.0\n", + "[11-04 17:02:40][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 17:02:40][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 17:02:40][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:02:40][DEBUG] jax_fem: Function split_and_compute_cell took 0.0332 seconds\n", + "[11-04 17:02:41][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32160,), indices shape = (32160,), indptr shape = (14518,), b shape = (14517,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:02:41][DEBUG] jax_fem: l_2 res = 2.8006842658959954e-13, relative l_2 res = 3.328074445374316e-15\n", + "[11-04 17:02:41][INFO] jax_fem: Solve took 3.651531934738159 [s]\n", + "[11-04 17:02:41][INFO] jax_fem: max of dofs = 0.6142123562681211\n", + "[11-04 17:02:41][INFO] jax_fem: min of dofs = -2.1459955163450197\n", + "[11-04 17:02:44][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 17:02:44][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:02:44][DEBUG] jax_fem: Function split_and_compute_cell took 0.0357 seconds\n", + "[11-04 17:02:44][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 17:02:44][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32160,), indices shape = (32160,), indptr shape = (14518,), b shape = (14517,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:02:44][DEBUG] jax_fem: Computing cell residual...\n", + "[11-04 17:02:45][DEBUG] jax_fem: Function split_and_compute_cell took 0.4959 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 38, Loss: 497.69\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:02:59][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 17:02:59][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 17:02:59][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 17:03:00][DEBUG] jax_fem: Done pre-computations, took 1.3827216625213623 [s]\n", + "[11-04 17:03:00][INFO] jax_fem: Solving a problem with 2997 cells, 4842x3 = 14526 dofs.\n", + "[11-04 17:03:00][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 2997 elements.\n", + "(2997, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:03:04][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 17:03:04][DEBUG] jax_fem: Start timing\n", + "[11-04 17:03:04][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:03:05][DEBUG] jax_fem: Function split_and_compute_cell took 0.5730 seconds\n", + "[11-04 17:03:07][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 17:03:07][DEBUG] jax_fem: Before, l_2 res = 86.82666627826605, relative l_2 res = 1.0\n", + "[11-04 17:03:07][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 17:03:07][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 17:03:07][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:03:07][DEBUG] jax_fem: Function split_and_compute_cell took 0.0384 seconds\n", + "[11-04 17:03:07][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32196,), indices shape = (32196,), indptr shape = (14527,), b shape = (14526,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:03:08][DEBUG] jax_fem: l_2 res = 2.0538357881895137e-13, relative l_2 res = 2.3654435627037523e-15\n", + "[11-04 17:03:08][INFO] jax_fem: Solve took 3.728189706802368 [s]\n", + "[11-04 17:03:08][INFO] jax_fem: max of dofs = 0.5938603475530255\n", + "[11-04 17:03:08][INFO] jax_fem: min of dofs = -2.1355163444967293\n", + "[11-04 17:03:10][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 17:03:10][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 17:03:10][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 17:03:12][DEBUG] jax_fem: Done pre-computations, took 1.6243019104003906 [s]\n", + "[11-04 17:03:12][INFO] jax_fem: Solving a problem with 2997 cells, 4842x3 = 14526 dofs.\n", + "[11-04 17:03:12][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 2997 elements.\n", + "(2997, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:03:15][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 17:03:15][DEBUG] jax_fem: Start timing\n", + "[11-04 17:03:15][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:03:16][DEBUG] jax_fem: Function split_and_compute_cell took 0.5472 seconds\n", + "[11-04 17:03:18][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 17:03:18][DEBUG] jax_fem: Before, l_2 res = 86.82666627826605, relative l_2 res = 1.0\n", + "[11-04 17:03:18][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 17:03:18][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 17:03:18][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:03:18][DEBUG] jax_fem: Function split_and_compute_cell took 0.0331 seconds\n", + "[11-04 17:03:19][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32196,), indices shape = (32196,), indptr shape = (14527,), b shape = (14526,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:03:19][DEBUG] jax_fem: l_2 res = 2.0538357881895137e-13, relative l_2 res = 2.3654435627037523e-15\n", + "[11-04 17:03:19][INFO] jax_fem: Solve took 3.541396379470825 [s]\n", + "[11-04 17:03:19][INFO] jax_fem: max of dofs = 0.5938603475530255\n", + "[11-04 17:03:19][INFO] jax_fem: min of dofs = -2.1355163444967293\n", + "[11-04 17:03:22][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 17:03:22][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:03:22][DEBUG] jax_fem: Function split_and_compute_cell took 0.0322 seconds\n", + "[11-04 17:03:22][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 17:03:22][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32196,), indices shape = (32196,), indptr shape = (14527,), b shape = (14526,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:03:22][DEBUG] jax_fem: Computing cell residual...\n", + "[11-04 17:03:23][DEBUG] jax_fem: Function split_and_compute_cell took 0.4458 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 39, Loss: 489.10\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:03:34][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 17:03:34][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 17:03:34][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 17:03:35][DEBUG] jax_fem: Done pre-computations, took 1.363396406173706 [s]\n", + "[11-04 17:03:35][INFO] jax_fem: Solving a problem with 2990 cells, 4843x3 = 14529 dofs.\n", + "[11-04 17:03:35][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-04 17:03:37][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 17:03:37][DEBUG] jax_fem: Start timing\n", + "[11-04 17:03:37][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 2990 elements.\n", + "(2990, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:03:38][DEBUG] jax_fem: Function split_and_compute_cell took 0.4048 seconds\n", + "[11-04 17:03:39][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 17:03:40][DEBUG] jax_fem: Before, l_2 res = 86.82666627826605, relative l_2 res = 1.0\n", + "[11-04 17:03:40][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 17:03:40][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 17:03:40][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:03:40][DEBUG] jax_fem: Function split_and_compute_cell took 0.0378 seconds\n", + "[11-04 17:03:40][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32199,), indices shape = (32199,), indptr shape = (14530,), b shape = (14529,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:03:40][DEBUG] jax_fem: l_2 res = 2.1143746184054081e-13, relative l_2 res = 2.4351673386021343e-15\n", + "[11-04 17:03:40][INFO] jax_fem: Solve took 3.1971077919006348 [s]\n", + "[11-04 17:03:41][INFO] jax_fem: max of dofs = 0.5890047628729336\n", + "[11-04 17:03:41][INFO] jax_fem: min of dofs = -2.124410725728493\n", + "[11-04 17:03:43][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 17:03:43][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 17:03:43][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 17:03:44][DEBUG] jax_fem: Done pre-computations, took 1.549253225326538 [s]\n", + "[11-04 17:03:44][INFO] jax_fem: Solving a problem with 2990 cells, 4843x3 = 14529 dofs.\n", + "[11-04 17:03:44][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-04 17:03:46][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 17:03:46][DEBUG] jax_fem: Start timing\n", + "[11-04 17:03:46][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 2990 elements.\n", + "(2990, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:03:47][DEBUG] jax_fem: Function split_and_compute_cell took 0.4060 seconds\n", + "[11-04 17:03:48][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 17:03:49][DEBUG] jax_fem: Before, l_2 res = 86.82666627826605, relative l_2 res = 1.0\n", + "[11-04 17:03:49][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 17:03:49][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 17:03:49][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:03:49][DEBUG] jax_fem: Function split_and_compute_cell took 0.0323 seconds\n", + "[11-04 17:03:49][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32199,), indices shape = (32199,), indptr shape = (14530,), b shape = (14529,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:03:49][DEBUG] jax_fem: l_2 res = 2.1143746184054081e-13, relative l_2 res = 2.4351673386021343e-15\n", + "[11-04 17:03:49][INFO] jax_fem: Solve took 3.022594451904297 [s]\n", + "[11-04 17:03:49][INFO] jax_fem: max of dofs = 0.5890047628729336\n", + "[11-04 17:03:49][INFO] jax_fem: min of dofs = -2.124410725728493\n", + "[11-04 17:03:52][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 17:03:52][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:03:52][DEBUG] jax_fem: Function split_and_compute_cell took 0.0321 seconds\n", + "[11-04 17:03:52][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 17:03:52][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 17:03:52][DEBUG] jax_fem: Computing cell residual...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32199,), indices shape = (32199,), indptr shape = (14530,), b shape = (14529,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:03:53][DEBUG] jax_fem: Function split_and_compute_cell took 0.3515 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 40, Loss: 484.30\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:04:07][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 17:04:07][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 17:04:07][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 17:04:09][DEBUG] jax_fem: Done pre-computations, took 1.4337706565856934 [s]\n", + "[11-04 17:04:09][INFO] jax_fem: Solving a problem with 2990 cells, 4835x3 = 14505 dofs.\n", + "[11-04 17:04:09][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-04 17:04:11][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 17:04:11][DEBUG] jax_fem: Start timing\n", + "[11-04 17:04:11][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 2990 elements.\n", + "(2990, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:04:11][DEBUG] jax_fem: Function split_and_compute_cell took 0.4869 seconds\n", + "[11-04 17:04:13][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 17:04:13][DEBUG] jax_fem: Before, l_2 res = 86.82666627826605, relative l_2 res = 1.0\n", + "[11-04 17:04:13][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 17:04:13][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 17:04:13][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:04:14][DEBUG] jax_fem: Function split_and_compute_cell took 0.0379 seconds\n", + "[11-04 17:04:14][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32175,), indices shape = (32175,), indptr shape = (14506,), b shape = (14505,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:04:14][DEBUG] jax_fem: l_2 res = 3.593954728332277e-13, relative l_2 res = 4.139229205016587e-15\n", + "[11-04 17:04:14][INFO] jax_fem: Solve took 3.2239625453948975 [s]\n", + "[11-04 17:04:14][INFO] jax_fem: max of dofs = 0.5851556332234672\n", + "[11-04 17:04:14][INFO] jax_fem: min of dofs = -2.1132627677178855\n", + "[11-04 17:04:16][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 17:04:16][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 17:04:16][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 17:04:17][DEBUG] jax_fem: Done pre-computations, took 1.357908010482788 [s]\n", + "[11-04 17:04:17][INFO] jax_fem: Solving a problem with 2990 cells, 4835x3 = 14505 dofs.\n", + "[11-04 17:04:17][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-04 17:04:20][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 17:04:20][DEBUG] jax_fem: Start timing\n", + "[11-04 17:04:20][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 2990 elements.\n", + "(2990, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:04:20][DEBUG] jax_fem: Function split_and_compute_cell took 0.4093 seconds\n", + "[11-04 17:04:22][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 17:04:22][DEBUG] jax_fem: Before, l_2 res = 86.82666627826605, relative l_2 res = 1.0\n", + "[11-04 17:04:22][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 17:04:22][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 17:04:22][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:04:22][DEBUG] jax_fem: Function split_and_compute_cell took 0.0334 seconds\n", + "[11-04 17:04:22][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32175,), indices shape = (32175,), indptr shape = (14506,), b shape = (14505,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:04:23][DEBUG] jax_fem: l_2 res = 3.593954728332277e-13, relative l_2 res = 4.139229205016587e-15\n", + "[11-04 17:04:23][INFO] jax_fem: Solve took 3.127502918243408 [s]\n", + "[11-04 17:04:23][INFO] jax_fem: max of dofs = 0.5851556332234672\n", + "[11-04 17:04:23][INFO] jax_fem: min of dofs = -2.1132627677178855\n", + "[11-04 17:04:25][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 17:04:25][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:04:26][DEBUG] jax_fem: Function split_and_compute_cell took 0.0323 seconds\n", + "[11-04 17:04:26][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 17:04:26][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 17:04:26][DEBUG] jax_fem: Computing cell residual...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32175,), indices shape = (32175,), indptr shape = (14506,), b shape = (14505,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:04:26][DEBUG] jax_fem: Function split_and_compute_cell took 0.3537 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 41, Loss: 479.34\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:04:49][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 17:04:49][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 17:04:49][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 17:04:51][DEBUG] jax_fem: Done pre-computations, took 1.429267406463623 [s]\n", + "[11-04 17:04:51][INFO] jax_fem: Solving a problem with 2955 cells, 4801x3 = 14403 dofs.\n", + "[11-04 17:04:51][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 2955 elements.\n", + "(2955, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:04:54][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 17:04:54][DEBUG] jax_fem: Start timing\n", + "[11-04 17:04:54][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:04:55][DEBUG] jax_fem: Function split_and_compute_cell took 0.5993 seconds\n", + "[11-04 17:04:57][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 17:04:57][DEBUG] jax_fem: Before, l_2 res = 86.49136054162506, relative l_2 res = 1.0\n", + "[11-04 17:04:57][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 17:04:57][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 17:04:57][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:04:57][DEBUG] jax_fem: Function split_and_compute_cell took 0.0375 seconds\n", + "[11-04 17:04:57][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32001,), indices shape = (32001,), indptr shape = (14404,), b shape = (14403,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:04:58][DEBUG] jax_fem: l_2 res = 2.2508177648799437e-13, relative l_2 res = 2.6023613812812084e-15\n", + "[11-04 17:04:58][INFO] jax_fem: Solve took 3.5488696098327637 [s]\n", + "[11-04 17:04:58][INFO] jax_fem: max of dofs = 0.5832736896010955\n", + "[11-04 17:04:58][INFO] jax_fem: min of dofs = -2.1017546685631707\n", + "[11-04 17:05:00][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 17:05:00][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 17:05:00][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 17:05:01][DEBUG] jax_fem: Done pre-computations, took 1.5861718654632568 [s]\n", + "[11-04 17:05:01][INFO] jax_fem: Solving a problem with 2955 cells, 4801x3 = 14403 dofs.\n", + "[11-04 17:05:01][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 2955 elements.\n", + "(2955, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:05:05][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 17:05:05][DEBUG] jax_fem: Start timing\n", + "[11-04 17:05:05][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:05:06][DEBUG] jax_fem: Function split_and_compute_cell took 0.5722 seconds\n", + "[11-04 17:05:08][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 17:05:08][DEBUG] jax_fem: Before, l_2 res = 86.49136054162506, relative l_2 res = 1.0\n", + "[11-04 17:05:08][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 17:05:08][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 17:05:08][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:05:08][DEBUG] jax_fem: Function split_and_compute_cell took 0.0326 seconds\n", + "[11-04 17:05:08][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32001,), indices shape = (32001,), indptr shape = (14404,), b shape = (14403,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:05:09][DEBUG] jax_fem: l_2 res = 2.2508177648799437e-13, relative l_2 res = 2.6023613812812084e-15\n", + "[11-04 17:05:09][INFO] jax_fem: Solve took 3.5331332683563232 [s]\n", + "[11-04 17:05:09][INFO] jax_fem: max of dofs = 0.5832736896010955\n", + "[11-04 17:05:09][INFO] jax_fem: min of dofs = -2.1017546685631707\n", + "[11-04 17:05:11][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 17:05:11][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:05:11][DEBUG] jax_fem: Function split_and_compute_cell took 0.0342 seconds\n", + "[11-04 17:05:11][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 17:05:12][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32001,), indices shape = (32001,), indptr shape = (14404,), b shape = (14403,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:05:12][DEBUG] jax_fem: Computing cell residual...\n", + "[11-04 17:05:13][DEBUG] jax_fem: Function split_and_compute_cell took 0.5134 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 42, Loss: 474.60\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:05:33][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 17:05:33][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 17:05:33][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 17:05:34][DEBUG] jax_fem: Done pre-computations, took 1.4084744453430176 [s]\n", + "[11-04 17:05:34][INFO] jax_fem: Solving a problem with 3025 cells, 4886x3 = 14658 dofs.\n", + "[11-04 17:05:34][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3025 elements.\n", + "(3025, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:05:38][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 17:05:38][DEBUG] jax_fem: Start timing\n", + "[11-04 17:05:38][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:05:39][DEBUG] jax_fem: Function split_and_compute_cell took 0.5555 seconds\n", + "[11-04 17:05:40][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 17:05:41][DEBUG] jax_fem: Before, l_2 res = 81.38529443741842, relative l_2 res = 1.0\n", + "[11-04 17:05:41][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 17:05:41][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 17:05:41][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:05:41][DEBUG] jax_fem: Function split_and_compute_cell took 0.0379 seconds\n", + "[11-04 17:05:41][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32319,), indices shape = (32319,), indptr shape = (14659,), b shape = (14658,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:05:41][DEBUG] jax_fem: l_2 res = 1.7133386794729435e-13, relative l_2 res = 2.105218997260522e-15\n", + "[11-04 17:05:42][INFO] jax_fem: Solve took 3.7557480335235596 [s]\n", + "[11-04 17:05:42][INFO] jax_fem: max of dofs = 0.618852657129187\n", + "[11-04 17:05:42][INFO] jax_fem: min of dofs = -2.0857188653010783\n", + "[11-04 17:05:44][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 17:05:44][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 17:05:44][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 17:05:45][DEBUG] jax_fem: Done pre-computations, took 1.5910274982452393 [s]\n", + "[11-04 17:05:45][INFO] jax_fem: Solving a problem with 3025 cells, 4886x3 = 14658 dofs.\n", + "[11-04 17:05:45][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3025 elements.\n", + "(3025, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:05:49][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 17:05:49][DEBUG] jax_fem: Start timing\n", + "[11-04 17:05:49][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:05:50][DEBUG] jax_fem: Function split_and_compute_cell took 0.5565 seconds\n", + "[11-04 17:05:52][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 17:05:52][DEBUG] jax_fem: Before, l_2 res = 81.38529443741842, relative l_2 res = 1.0\n", + "[11-04 17:05:52][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 17:05:52][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 17:05:52][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:05:52][DEBUG] jax_fem: Function split_and_compute_cell took 0.0323 seconds\n", + "[11-04 17:05:52][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32319,), indices shape = (32319,), indptr shape = (14659,), b shape = (14658,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:05:53][DEBUG] jax_fem: l_2 res = 1.7133386794729435e-13, relative l_2 res = 2.105218997260522e-15\n", + "[11-04 17:05:53][INFO] jax_fem: Solve took 3.775749921798706 [s]\n", + "[11-04 17:05:53][INFO] jax_fem: max of dofs = 0.618852657129187\n", + "[11-04 17:05:53][INFO] jax_fem: min of dofs = -2.0857188653010783\n", + "[11-04 17:05:55][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 17:05:55][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:05:56][DEBUG] jax_fem: Function split_and_compute_cell took 0.0327 seconds\n", + "[11-04 17:05:56][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 17:05:56][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32319,), indices shape = (32319,), indptr shape = (14659,), b shape = (14658,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:05:56][DEBUG] jax_fem: Computing cell residual...\n", + "[11-04 17:05:57][DEBUG] jax_fem: Function split_and_compute_cell took 0.4769 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 43, Loss: 444.44\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:06:19][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 17:06:19][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 17:06:19][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 17:06:20][DEBUG] jax_fem: Done pre-computations, took 1.388458013534546 [s]\n", + "[11-04 17:06:20][INFO] jax_fem: Solving a problem with 3039 cells, 4899x3 = 14697 dofs.\n", + "[11-04 17:06:20][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3039 elements.\n", + "(3039, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:06:24][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 17:06:24][DEBUG] jax_fem: Start timing\n", + "[11-04 17:06:24][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:06:24][DEBUG] jax_fem: Function split_and_compute_cell took 0.5379 seconds\n", + "[11-04 17:06:26][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 17:06:27][DEBUG] jax_fem: Before, l_2 res = 81.38529443741841, relative l_2 res = 1.0\n", + "[11-04 17:06:27][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 17:06:27][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 17:06:27][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:06:27][DEBUG] jax_fem: Function split_and_compute_cell took 0.0367 seconds\n", + "[11-04 17:06:27][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32358,), indices shape = (32358,), indptr shape = (14698,), b shape = (14697,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:06:27][DEBUG] jax_fem: l_2 res = 1.650822036148518e-13, relative l_2 res = 2.0284033467716027e-15\n", + "[11-04 17:06:27][INFO] jax_fem: Solve took 3.694025993347168 [s]\n", + "[11-04 17:06:27][INFO] jax_fem: max of dofs = 0.6189498399691852\n", + "[11-04 17:06:27][INFO] jax_fem: min of dofs = -2.0711936292498123\n", + "[11-04 17:06:29][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 17:06:29][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 17:06:29][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 17:06:31][DEBUG] jax_fem: Done pre-computations, took 1.564469575881958 [s]\n", + "[11-04 17:06:31][INFO] jax_fem: Solving a problem with 3039 cells, 4899x3 = 14697 dofs.\n", + "[11-04 17:06:31][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3039 elements.\n", + "(3039, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:06:35][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 17:06:35][DEBUG] jax_fem: Start timing\n", + "[11-04 17:06:35][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:06:36][DEBUG] jax_fem: Function split_and_compute_cell took 0.5453 seconds\n", + "[11-04 17:06:37][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 17:06:38][DEBUG] jax_fem: Before, l_2 res = 81.38529443741841, relative l_2 res = 1.0\n", + "[11-04 17:06:38][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 17:06:38][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 17:06:38][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:06:38][DEBUG] jax_fem: Function split_and_compute_cell took 0.0323 seconds\n", + "[11-04 17:06:38][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32358,), indices shape = (32358,), indptr shape = (14698,), b shape = (14697,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:06:38][DEBUG] jax_fem: l_2 res = 1.650822036148518e-13, relative l_2 res = 2.0284033467716027e-15\n", + "[11-04 17:06:38][INFO] jax_fem: Solve took 3.627338409423828 [s]\n", + "[11-04 17:06:39][INFO] jax_fem: max of dofs = 0.6189498399691852\n", + "[11-04 17:06:39][INFO] jax_fem: min of dofs = -2.0711936292498123\n", + "[11-04 17:06:41][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 17:06:41][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:06:41][DEBUG] jax_fem: Function split_and_compute_cell took 0.0335 seconds\n", + "[11-04 17:06:41][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 17:06:41][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32358,), indices shape = (32358,), indptr shape = (14698,), b shape = (14697,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:06:42][DEBUG] jax_fem: Computing cell residual...\n", + "[11-04 17:06:42][DEBUG] jax_fem: Function split_and_compute_cell took 0.4271 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 44, Loss: 440.99\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:07:00][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 17:07:00][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 17:07:00][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 17:07:02][DEBUG] jax_fem: Done pre-computations, took 1.4477767944335938 [s]\n", + "[11-04 17:07:02][INFO] jax_fem: Solving a problem with 3011 cells, 4867x3 = 14601 dofs.\n", + "[11-04 17:07:02][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3011 elements.\n", + "(3011, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:07:05][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 17:07:05][DEBUG] jax_fem: Start timing\n", + "[11-04 17:07:05][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:07:06][DEBUG] jax_fem: Function split_and_compute_cell took 0.6159 seconds\n", + "[11-04 17:07:08][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 17:07:09][DEBUG] jax_fem: Before, l_2 res = 81.38529443741841, relative l_2 res = 1.0\n", + "[11-04 17:07:09][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 17:07:09][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 17:07:09][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:07:09][DEBUG] jax_fem: Function split_and_compute_cell took 0.0391 seconds\n", + "[11-04 17:07:09][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32262,), indices shape = (32262,), indptr shape = (14602,), b shape = (14601,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:07:09][DEBUG] jax_fem: l_2 res = 1.6904059128282052e-13, relative l_2 res = 2.0770409746788478e-15\n", + "[11-04 17:07:09][INFO] jax_fem: Solve took 3.942185401916504 [s]\n", + "[11-04 17:07:09][INFO] jax_fem: max of dofs = 0.6208240294844075\n", + "[11-04 17:07:09][INFO] jax_fem: min of dofs = -2.0542902102443654\n", + "[11-04 17:07:11][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 17:07:11][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 17:07:11][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 17:07:13][DEBUG] jax_fem: Done pre-computations, took 1.6063201427459717 [s]\n", + "[11-04 17:07:13][INFO] jax_fem: Solving a problem with 3011 cells, 4867x3 = 14601 dofs.\n", + "[11-04 17:07:13][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 3011 elements.\n", + "(3011, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:07:17][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 17:07:17][DEBUG] jax_fem: Start timing\n", + "[11-04 17:07:17][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:07:18][DEBUG] jax_fem: Function split_and_compute_cell took 0.5746 seconds\n", + "[11-04 17:07:19][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 17:07:20][DEBUG] jax_fem: Before, l_2 res = 81.38529443741841, relative l_2 res = 1.0\n", + "[11-04 17:07:20][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 17:07:20][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 17:07:20][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:07:20][DEBUG] jax_fem: Function split_and_compute_cell took 0.0325 seconds\n", + "[11-04 17:07:20][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32262,), indices shape = (32262,), indptr shape = (14602,), b shape = (14601,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:07:20][DEBUG] jax_fem: l_2 res = 1.6904059128282052e-13, relative l_2 res = 2.0770409746788478e-15\n", + "[11-04 17:07:20][INFO] jax_fem: Solve took 3.6416001319885254 [s]\n", + "[11-04 17:07:21][INFO] jax_fem: max of dofs = 0.6208240294844075\n", + "[11-04 17:07:21][INFO] jax_fem: min of dofs = -2.0542902102443654\n", + "[11-04 17:07:23][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 17:07:23][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:07:23][DEBUG] jax_fem: Function split_and_compute_cell took 0.0333 seconds\n", + "[11-04 17:07:23][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 17:07:24][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32262,), indices shape = (32262,), indptr shape = (14602,), b shape = (14601,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:07:24][DEBUG] jax_fem: Computing cell residual...\n", + "[11-04 17:07:25][DEBUG] jax_fem: Function split_and_compute_cell took 0.5112 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 45, Loss: 437.53\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:07:43][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 17:07:43][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 17:07:43][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 17:07:44][DEBUG] jax_fem: Done pre-computations, took 1.3467252254486084 [s]\n", + "[11-04 17:07:44][INFO] jax_fem: Solving a problem with 2962 cells, 4820x3 = 14460 dofs.\n", + "[11-04 17:07:44][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 2962 elements.\n", + "(2962, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:07:48][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 17:07:48][DEBUG] jax_fem: Start timing\n", + "[11-04 17:07:48][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:07:48][DEBUG] jax_fem: Function split_and_compute_cell took 0.5322 seconds\n", + "[11-04 17:07:50][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 17:07:50][DEBUG] jax_fem: Before, l_2 res = 81.38529443741841, relative l_2 res = 1.0\n", + "[11-04 17:07:50][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 17:07:51][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 17:07:51][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:07:51][DEBUG] jax_fem: Function split_and_compute_cell took 0.0377 seconds\n", + "[11-04 17:07:51][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32121,), indices shape = (32121,), indptr shape = (14461,), b shape = (14460,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:07:51][DEBUG] jax_fem: l_2 res = 2.1466082894683589e-13, relative l_2 res = 2.637587422036057e-15\n", + "[11-04 17:07:51][INFO] jax_fem: Solve took 3.6954832077026367 [s]\n", + "[11-04 17:07:51][INFO] jax_fem: max of dofs = 0.6245253364478732\n", + "[11-04 17:07:51][INFO] jax_fem: min of dofs = -2.0352003143204285\n", + "[11-04 17:07:53][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 17:07:53][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 17:07:53][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 17:07:55][DEBUG] jax_fem: Done pre-computations, took 1.548252820968628 [s]\n", + "[11-04 17:07:55][INFO] jax_fem: Solving a problem with 2962 cells, 4820x3 = 14460 dofs.\n", + "[11-04 17:07:55][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 2962 elements.\n", + "(2962, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:07:59][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 17:07:59][DEBUG] jax_fem: Start timing\n", + "[11-04 17:07:59][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:07:59][DEBUG] jax_fem: Function split_and_compute_cell took 0.5369 seconds\n", + "[11-04 17:08:01][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 17:08:01][DEBUG] jax_fem: Before, l_2 res = 81.38529443741841, relative l_2 res = 1.0\n", + "[11-04 17:08:01][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 17:08:02][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 17:08:02][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:08:02][DEBUG] jax_fem: Function split_and_compute_cell took 0.0326 seconds\n", + "[11-04 17:08:02][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32121,), indices shape = (32121,), indptr shape = (14461,), b shape = (14460,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:08:02][DEBUG] jax_fem: l_2 res = 2.1466082894683589e-13, relative l_2 res = 2.637587422036057e-15\n", + "[11-04 17:08:02][INFO] jax_fem: Solve took 3.667450189590454 [s]\n", + "[11-04 17:08:02][INFO] jax_fem: max of dofs = 0.6245253364478732\n", + "[11-04 17:08:02][INFO] jax_fem: min of dofs = -2.0352003143204285\n", + "[11-04 17:08:05][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 17:08:05][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:08:05][DEBUG] jax_fem: Function split_and_compute_cell took 0.0329 seconds\n", + "[11-04 17:08:05][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 17:08:05][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32121,), indices shape = (32121,), indptr shape = (14461,), b shape = (14460,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:08:06][DEBUG] jax_fem: Computing cell residual...\n", + "[11-04 17:08:06][DEBUG] jax_fem: Function split_and_compute_cell took 0.4596 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 46, Loss: 434.12\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:08:25][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 17:08:25][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 17:08:25][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 17:08:27][DEBUG] jax_fem: Done pre-computations, took 1.3817973136901855 [s]\n", + "[11-04 17:08:27][INFO] jax_fem: Solving a problem with 2934 cells, 4798x3 = 14394 dofs.\n", + "[11-04 17:08:27][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 2934 elements.\n", + "(2934, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:08:30][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 17:08:30][DEBUG] jax_fem: Start timing\n", + "[11-04 17:08:30][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:08:31][DEBUG] jax_fem: Function split_and_compute_cell took 0.5432 seconds\n", + "[11-04 17:08:33][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 17:08:33][DEBUG] jax_fem: Before, l_2 res = 81.38529443741841, relative l_2 res = 1.0\n", + "[11-04 17:08:33][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 17:08:33][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 17:08:33][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:08:33][DEBUG] jax_fem: Function split_and_compute_cell took 0.0380 seconds\n", + "[11-04 17:08:33][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32055,), indices shape = (32055,), indptr shape = (14395,), b shape = (14394,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:08:34][DEBUG] jax_fem: l_2 res = 2.1237323461511165e-13, relative l_2 res = 2.609479219595587e-15\n", + "[11-04 17:08:34][INFO] jax_fem: Solve took 3.71282696723938 [s]\n", + "[11-04 17:08:34][INFO] jax_fem: max of dofs = 0.6289275992677923\n", + "[11-04 17:08:34][INFO] jax_fem: min of dofs = -2.014257972473981\n", + "[11-04 17:08:36][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 17:08:36][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 17:08:36][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 17:08:37][DEBUG] jax_fem: Done pre-computations, took 1.543102502822876 [s]\n", + "[11-04 17:08:37][INFO] jax_fem: Solving a problem with 2934 cells, 4798x3 = 14394 dofs.\n", + "[11-04 17:08:37][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 2934 elements.\n", + "(2934, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:08:41][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 17:08:41][DEBUG] jax_fem: Start timing\n", + "[11-04 17:08:41][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:08:42][DEBUG] jax_fem: Function split_and_compute_cell took 0.5385 seconds\n", + "[11-04 17:08:44][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 17:08:44][DEBUG] jax_fem: Before, l_2 res = 81.38529443741841, relative l_2 res = 1.0\n", + "[11-04 17:08:44][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 17:08:44][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 17:08:44][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:08:44][DEBUG] jax_fem: Function split_and_compute_cell took 0.0326 seconds\n", + "[11-04 17:08:44][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32055,), indices shape = (32055,), indptr shape = (14395,), b shape = (14394,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:08:45][DEBUG] jax_fem: l_2 res = 2.1237323461511165e-13, relative l_2 res = 2.609479219595587e-15\n", + "[11-04 17:08:45][INFO] jax_fem: Solve took 3.5591561794281006 [s]\n", + "[11-04 17:08:45][INFO] jax_fem: max of dofs = 0.6289275992677923\n", + "[11-04 17:08:45][INFO] jax_fem: min of dofs = -2.014257972473981\n", + "[11-04 17:08:47][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 17:08:47][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:08:47][DEBUG] jax_fem: Function split_and_compute_cell took 0.0334 seconds\n", + "[11-04 17:08:47][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 17:08:48][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32055,), indices shape = (32055,), indptr shape = (14395,), b shape = (14394,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:08:48][DEBUG] jax_fem: Computing cell residual...\n", + "[11-04 17:08:49][DEBUG] jax_fem: Function split_and_compute_cell took 0.4914 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 47, Loss: 430.39\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:08:59][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 17:08:59][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 17:08:59][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 17:09:00][DEBUG] jax_fem: Done pre-computations, took 1.351137399673462 [s]\n", + "[11-04 17:09:00][INFO] jax_fem: Solving a problem with 2934 cells, 4796x3 = 14388 dofs.\n", + "[11-04 17:09:00][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-04 17:09:02][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 17:09:02][DEBUG] jax_fem: Start timing\n", + "[11-04 17:09:02][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 2934 elements.\n", + "(2934, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:09:03][DEBUG] jax_fem: Function split_and_compute_cell took 0.3383 seconds\n", + "[11-04 17:09:04][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 17:09:05][DEBUG] jax_fem: Before, l_2 res = 81.38529443741842, relative l_2 res = 1.0\n", + "[11-04 17:09:05][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 17:09:05][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 17:09:05][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:09:05][DEBUG] jax_fem: Function split_and_compute_cell took 0.0371 seconds\n", + "[11-04 17:09:05][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32049,), indices shape = (32049,), indptr shape = (14389,), b shape = (14388,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:09:05][DEBUG] jax_fem: l_2 res = 1.9774566987192605e-13, relative l_2 res = 2.4297469369479696e-15\n", + "[11-04 17:09:05][INFO] jax_fem: Solve took 3.049081563949585 [s]\n", + "[11-04 17:09:05][INFO] jax_fem: max of dofs = 0.634086923927134\n", + "[11-04 17:09:06][INFO] jax_fem: min of dofs = -1.9919503378140244\n", + "[11-04 17:09:07][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 17:09:07][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 17:09:07][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 17:09:09][DEBUG] jax_fem: Done pre-computations, took 1.537379503250122 [s]\n", + "[11-04 17:09:09][INFO] jax_fem: Solving a problem with 2934 cells, 4796x3 = 14388 dofs.\n", + "[11-04 17:09:09][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-04 17:09:11][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 17:09:11][DEBUG] jax_fem: Start timing\n", + "[11-04 17:09:11][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 2934 elements.\n", + "(2934, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:09:12][DEBUG] jax_fem: Function split_and_compute_cell took 0.3267 seconds\n", + "[11-04 17:09:13][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 17:09:13][DEBUG] jax_fem: Before, l_2 res = 81.38529443741842, relative l_2 res = 1.0\n", + "[11-04 17:09:13][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 17:09:14][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 17:09:14][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:09:14][DEBUG] jax_fem: Function split_and_compute_cell took 0.0317 seconds\n", + "[11-04 17:09:14][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32049,), indices shape = (32049,), indptr shape = (14389,), b shape = (14388,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:09:14][DEBUG] jax_fem: l_2 res = 1.9774566987192605e-13, relative l_2 res = 2.4297469369479696e-15\n", + "[11-04 17:09:14][INFO] jax_fem: Solve took 2.9492619037628174 [s]\n", + "[11-04 17:09:14][INFO] jax_fem: max of dofs = 0.634086923927134\n", + "[11-04 17:09:14][INFO] jax_fem: min of dofs = -1.9919503378140244\n", + "[11-04 17:09:17][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 17:09:17][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:09:17][DEBUG] jax_fem: Function split_and_compute_cell took 0.0330 seconds\n", + "[11-04 17:09:17][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 17:09:17][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 17:09:17][DEBUG] jax_fem: Computing cell residual...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32049,), indices shape = (32049,), indptr shape = (14389,), b shape = (14388,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:09:17][DEBUG] jax_fem: Function split_and_compute_cell took 0.3768 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 48, Loss: 426.57\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:09:28][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 17:09:28][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 17:09:28][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 17:09:29][DEBUG] jax_fem: Done pre-computations, took 1.3943109512329102 [s]\n", + "[11-04 17:09:29][INFO] jax_fem: Solving a problem with 2871 cells, 4727x3 = 14181 dofs.\n", + "[11-04 17:09:29][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 2871 elements.\n", + "(2871, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:09:33][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 17:09:33][DEBUG] jax_fem: Start timing\n", + "[11-04 17:09:33][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:09:34][DEBUG] jax_fem: Function split_and_compute_cell took 0.6028 seconds\n", + "[11-04 17:09:36][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 17:09:36][DEBUG] jax_fem: Before, l_2 res = 81.38529443741842, relative l_2 res = 1.0\n", + "[11-04 17:09:36][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 17:09:36][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 17:09:36][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:09:36][DEBUG] jax_fem: Function split_and_compute_cell took 0.0366 seconds\n", + "[11-04 17:09:36][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (31842,), indices shape = (31842,), indptr shape = (14182,), b shape = (14181,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:09:37][DEBUG] jax_fem: l_2 res = 2.1446882037901773e-13, relative l_2 res = 2.6352281682034643e-15\n", + "[11-04 17:09:37][INFO] jax_fem: Solve took 3.649704933166504 [s]\n", + "[11-04 17:09:37][INFO] jax_fem: max of dofs = 0.640338963238068\n", + "[11-04 17:09:37][INFO] jax_fem: min of dofs = -1.9687183060358118\n", + "[11-04 17:09:39][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 17:09:39][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 17:09:39][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 17:09:40][DEBUG] jax_fem: Done pre-computations, took 1.567568063735962 [s]\n", + "[11-04 17:09:40][INFO] jax_fem: Solving a problem with 2871 cells, 4727x3 = 14181 dofs.\n", + "[11-04 17:09:40][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 2871 elements.\n", + "(2871, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:09:44][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 17:09:44][DEBUG] jax_fem: Start timing\n", + "[11-04 17:09:44][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:09:45][DEBUG] jax_fem: Function split_and_compute_cell took 0.5729 seconds\n", + "[11-04 17:09:47][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 17:09:47][DEBUG] jax_fem: Before, l_2 res = 81.38529443741842, relative l_2 res = 1.0\n", + "[11-04 17:09:47][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 17:09:47][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 17:09:47][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:09:47][DEBUG] jax_fem: Function split_and_compute_cell took 0.0314 seconds\n", + "[11-04 17:09:47][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (31842,), indices shape = (31842,), indptr shape = (14182,), b shape = (14181,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:09:48][DEBUG] jax_fem: l_2 res = 2.1446882037901773e-13, relative l_2 res = 2.6352281682034643e-15\n", + "[11-04 17:09:48][INFO] jax_fem: Solve took 3.651829719543457 [s]\n", + "[11-04 17:09:48][INFO] jax_fem: max of dofs = 0.640338963238068\n", + "[11-04 17:09:48][INFO] jax_fem: min of dofs = -1.9687183060358118\n", + "[11-04 17:09:50][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 17:09:50][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:09:50][DEBUG] jax_fem: Function split_and_compute_cell took 0.0317 seconds\n", + "[11-04 17:09:50][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 17:09:51][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (31842,), indices shape = (31842,), indptr shape = (14182,), b shape = (14181,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:09:51][DEBUG] jax_fem: Computing cell residual...\n", + "[11-04 17:09:52][DEBUG] jax_fem: Function split_and_compute_cell took 0.5022 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 49, Loss: 422.82\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:10:02][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 17:10:02][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 17:10:02][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 17:10:04][DEBUG] jax_fem: Done pre-computations, took 1.3450312614440918 [s]\n", + "[11-04 17:10:04][INFO] jax_fem: Solving a problem with 2962 cells, 4852x3 = 14556 dofs.\n", + "[11-04 17:10:04][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-04 17:10:06][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 17:10:06][DEBUG] jax_fem: Start timing\n", + "[11-04 17:10:06][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 2962 elements.\n", + "(2962, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:10:06][DEBUG] jax_fem: Function split_and_compute_cell took 0.3357 seconds\n", + "[11-04 17:10:08][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 17:10:08][DEBUG] jax_fem: Before, l_2 res = 79.86923046348153, relative l_2 res = 1.0\n", + "[11-04 17:10:08][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 17:10:08][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 17:10:08][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:10:08][DEBUG] jax_fem: Function split_and_compute_cell took 0.0368 seconds\n", + "[11-04 17:10:08][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32433,), indices shape = (32433,), indptr shape = (14557,), b shape = (14556,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:10:09][DEBUG] jax_fem: l_2 res = 2.2019212068101568e-13, relative l_2 res = 2.756908003285367e-15\n", + "[11-04 17:10:09][INFO] jax_fem: Solve took 2.8522937297821045 [s]\n", + "[11-04 17:10:09][INFO] jax_fem: max of dofs = 0.6465875337244206\n", + "[11-04 17:10:09][INFO] jax_fem: min of dofs = -2.1077160422216275\n", + "[11-04 17:10:11][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-04 17:10:11][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-04 17:10:11][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-04 17:10:12][DEBUG] jax_fem: Done pre-computations, took 1.551452875137329 [s]\n", + "[11-04 17:10:12][INFO] jax_fem: Solving a problem with 2962 cells, 4852x3 = 14556 dofs.\n", + "[11-04 17:10:12][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-04 17:10:15][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-04 17:10:15][DEBUG] jax_fem: Start timing\n", + "[11-04 17:10:15][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup completed with mesh of 2962 elements.\n", + "(2962, 1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:10:15][DEBUG] jax_fem: Function split_and_compute_cell took 0.3371 seconds\n", + "[11-04 17:10:16][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 17:10:17][DEBUG] jax_fem: Before, l_2 res = 79.86923046348153, relative l_2 res = 1.0\n", + "[11-04 17:10:17][DEBUG] jax_fem: Solving linear system...\n", + "[11-04 17:10:17][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 17:10:17][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:10:17][DEBUG] jax_fem: Function split_and_compute_cell took 0.0308 seconds\n", + "[11-04 17:10:17][DEBUG] jax_fem: Creating sparse matrix with scipy...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32433,), indices shape = (32433,), indptr shape = (14557,), b shape = (14556,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:10:17][DEBUG] jax_fem: l_2 res = 2.2019212068101568e-13, relative l_2 res = 2.756908003285367e-15\n", + "[11-04 17:10:18][INFO] jax_fem: Solve took 2.855729103088379 [s]\n", + "[11-04 17:10:18][INFO] jax_fem: max of dofs = 0.6465875337244206\n", + "[11-04 17:10:18][INFO] jax_fem: min of dofs = -2.1077160422216275\n", + "[11-04 17:10:20][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-04 17:10:20][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-04 17:10:20][DEBUG] jax_fem: Function split_and_compute_cell took 0.0320 seconds\n", + "[11-04 17:10:20][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-04 17:10:20][DEBUG] jax_fem: Scipy Solver - Solving linear system with jax spsolve\n", + "[11-04 17:10:21][DEBUG] jax_fem: Computing cell residual...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "data shape = (32433,), indices shape = (32433,), indptr shape = (14557,), b shape = (14556,)\n", + "TFRT_CPU_0\n", + "TFRT_CPU_0\n", + "cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-04 17:10:21][DEBUG] jax_fem: Function split_and_compute_cell took 0.3954 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 50, Loss: 444.61\n" + ] + } + ], + "source": [ + "import optax\n", + "\n", + "optmizer = optax.adam(learning_rate=0.02)\n", + "opt_state = optmizer.init(initial_params)\n", + "\n", + "params = initial_params.copy()\n", + "loss_hist = []\n", + "params_hist = []\n", + "\n", + "grad_fn = jax.value_and_grad(loss)\n", + "\n", + "for i in range(50):\n", + " loss_value, grads = grad_fn(params, van_neumann_mask, dirichlet_mask)\n", + "\n", + " updates, opt_state = optmizer.update(\n", + " grads, opt_state, params, value=loss_value, grad=grads, value_fn=loss\n", + " )\n", + " params = optax.apply_updates(params, updates)\n", + "\n", + " # Ensure parameters are within bounds\n", + " params = params.at[..., 1].set(\n", + " jnp.clip(params[..., 1], -Ly / 2 + bar_radius, Ly / 2 - bar_radius)\n", + " )\n", + "\n", + " # Clip the z-coordinates to be within the bar radius\n", + " params = params.at[..., 2].set(\n", + " jnp.clip(params[..., 2], -Lz / 2 + bar_radius, Lz / 2 - bar_radius)\n", + " )\n", + "\n", + " loss_hist.append(loss_value)\n", + " params_hist.append(params)\n", + "\n", + " print(f\"Iteration {i + 1}, Loss: {loss_value:.2f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "ab08ef4e", + "metadata": {}, + "source": [ + "Lets plot the compliance as a function of the optimization steps. We can see that the compliance is decreasing smoothly, indicating that the optimization is working as expected. " + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "id": "4bb8824e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(loss_hist)\n", + "plt.yscale(\"log\") \n", + "plt.xlabel(\"Optimization Iteration\")\n", + "plt.ylabel(\"Compliance\")\n", + "plt.title(\"Compliance over Optimization\");" + ] + }, + { + "cell_type": "markdown", + "id": "54896b4f", + "metadata": {}, + "source": [ + "We can also trace the y coordinates of the vertices over the optimization steps. This gives us an idea of how the design variables are changing during the optimization process." + ] + }, + { + "cell_type": "code", + "execution_count": 104, + "id": "d5db1d27", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "param_hist_tensor = jnp.array(params_hist)\n", + "\n", + "plt.figure(figsize=(10, 5))\n", + "\n", + "for chain in range(n_chains):\n", + " for edge in range(n_edges_per_chain + 1):\n", + " plt.plot(\n", + " param_hist_tensor[:, chain, edge, 1].T, label=f\"Chain {chain}, Edge {edge} y\"\n", + " )\n", + " plt.plot(\n", + " param_hist_tensor[:, chain, edge, 2].T, label=f\"Chain {chain}, Edge {edge} z\"\n", + " )\n", + "\n", + "plt.xlabel(\"Optimization Iteration\")\n", + "plt.ylabel(\"Y-Position\");" + ] + }, + { + "cell_type": "markdown", + "id": "e92c46a6", + "metadata": {}, + "source": [ + "## Step 3: Visualize results\n", + "\n", + "After optimization, the structure has been adjusted to assume a more stable configuration under the given load. The design variables have been tuned to achieve this goal, reducing the compliance of the structure from around 10,000 to about 200.\n", + "\n", + "Here is the final optimized structure:" + ] + }, + { + "cell_type": "markdown", + "id": "5029dabb", + "metadata": {}, + "source": [ + "We generate a video of the optimization process to visualize how the structure evolves over time." + ] + }, + { + "cell_type": "code", + "execution_count": 105, + "id": "118e8ded", + "metadata": {}, + "outputs": [], + "source": [ + "from matplotlib import animation\n", + "\n", + "# repeat the last frame a few times to show the final result\n", + "params_hist = params_hist + [params] * 20\n", + "\n", + "fig = plt.figure(figsize=(7, 4))\n", + "\n", + "ims = []\n", + "for params in params_hist:\n", + " sdf = apply_tesseract(\n", + " design_tess,\n", + " {\n", + " \"bar_params\": params,\n", + " \"bar_radius\": bar_radius,\n", + " \"Lx\": Lx,\n", + " \"Ly\": Ly,\n", + " \"Lz\": Lz,\n", + " \"Nx\": Nx,\n", + " \"Ny\": Ny,\n", + " \"Nz\": Nz,\n", + " \"epsilon\": 1e-3,\n", + " },\n", + " )[\"sdf\"]\n", + "\n", + " rho = sdf_to_rho(sdf)\n", + "\n", + " im = plt.imshow(\n", + " rho[:, :, Nz // 2].T, origin=\"lower\", cmap=\"viridis\", vmin=0, vmax=1\n", + " )\n", + " ims.append([im])\n", + "\n", + "ani = animation.ArtistAnimation(fig, ims, interval=10, blit=True, repeat_delay=2)\n", + "plt.close(fig)\n", + "\n", + "ani.save(\"rho_optim.gif\", writer=\"pillow\", fps=10)" + ] + }, + { + "cell_type": "code", + "execution_count": 106, + "id": "930d61c8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
\n", + " \n", + "
\n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + "
\n", + "
\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 106, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.display import HTML\n", + "\n", + "HTML(ani.to_jshtml(fps=10, embed_frames=True))" + ] + }, + { + "cell_type": "code", + "execution_count": 107, + "id": "ba66b536", + "metadata": {}, + "outputs": [ + { + "ename": "FileNotFoundError", + "evalue": "[Errno 2] No such file or directory: 'img/mesh_optim_000.png'", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mFileNotFoundError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[107]\u001b[39m\u001b[32m, line 29\u001b[39m\n\u001b[32m 22\u001b[39m faces = surface_mesh[\u001b[33m\"\u001b[39m\u001b[33mfaces\u001b[39m\u001b[33m\"\u001b[39m][:num_faces]\n\u001b[32m 24\u001b[39m mesh = {\n\u001b[32m 25\u001b[39m \u001b[33m\"\u001b[39m\u001b[33mpoints\u001b[39m\u001b[33m\"\u001b[39m: points,\n\u001b[32m 26\u001b[39m \u001b[33m\"\u001b[39m\u001b[33mfaces\u001b[39m\u001b[33m\"\u001b[39m: faces,\n\u001b[32m 27\u001b[39m }\n\u001b[32m---> \u001b[39m\u001b[32m29\u001b[39m \u001b[43mplot_mesh\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmesh\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msave_path\u001b[49m\u001b[43m=\u001b[49m\u001b[33;43mf\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mimg/mesh_optim_\u001b[39;49m\u001b[38;5;132;43;01m{\u001b[39;49;00m\u001b[43mi\u001b[49m\u001b[38;5;132;43;01m:\u001b[39;49;00m\u001b[33;43m03d\u001b[39;49m\u001b[38;5;132;43;01m}\u001b[39;49;00m\u001b[33;43m.png\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[82]\u001b[39m\u001b[32m, line 89\u001b[39m, in \u001b[36mplot_mesh\u001b[39m\u001b[34m(mesh, save_path)\u001b[39m\n\u001b[32m 75\u001b[39m ax.quiver(\n\u001b[32m 76\u001b[39m Lx / \u001b[32m2\u001b[39m,\n\u001b[32m 77\u001b[39m \u001b[32m0\u001b[39m,\n\u001b[32m (...)\u001b[39m\u001b[32m 84\u001b[39m arrow_length_ratio=\u001b[32m0.3\u001b[39m,\n\u001b[32m 85\u001b[39m )\n\u001b[32m 87\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m save_path:\n\u001b[32m 88\u001b[39m \u001b[38;5;66;03m# avoid showing the plot in notebook\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m89\u001b[39m \u001b[43mplt\u001b[49m\u001b[43m.\u001b[49m\u001b[43msavefig\u001b[49m\u001b[43m(\u001b[49m\u001b[43msave_path\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 90\u001b[39m plt.close(fig)\n", + "\u001b[36mFile \u001b[39m\u001b[32m/anaconda/envs/fem/lib/python3.13/site-packages/matplotlib/pyplot.py:1250\u001b[39m, in \u001b[36msavefig\u001b[39m\u001b[34m(*args, **kwargs)\u001b[39m\n\u001b[32m 1247\u001b[39m fig = gcf()\n\u001b[32m 1248\u001b[39m \u001b[38;5;66;03m# savefig default implementation has no return, so mypy is unhappy\u001b[39;00m\n\u001b[32m 1249\u001b[39m \u001b[38;5;66;03m# presumably this is here because subclasses can return?\u001b[39;00m\n\u001b[32m-> \u001b[39m\u001b[32m1250\u001b[39m res = \u001b[43mfig\u001b[49m\u001b[43m.\u001b[49m\u001b[43msavefig\u001b[49m\u001b[43m(\u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;66;03m# type: ignore[func-returns-value]\u001b[39;00m\n\u001b[32m 1251\u001b[39m fig.canvas.draw_idle() \u001b[38;5;66;03m# Need this if 'transparent=True', to reset colors.\u001b[39;00m\n\u001b[32m 1252\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m res\n", + "\u001b[36mFile \u001b[39m\u001b[32m/anaconda/envs/fem/lib/python3.13/site-packages/matplotlib/figure.py:3490\u001b[39m, in \u001b[36mFigure.savefig\u001b[39m\u001b[34m(self, fname, transparent, **kwargs)\u001b[39m\n\u001b[32m 3488\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m ax \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m.axes:\n\u001b[32m 3489\u001b[39m _recursively_make_axes_transparent(stack, ax)\n\u001b[32m-> \u001b[39m\u001b[32m3490\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mcanvas\u001b[49m\u001b[43m.\u001b[49m\u001b[43mprint_figure\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfname\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m/anaconda/envs/fem/lib/python3.13/site-packages/matplotlib/backend_bases.py:2186\u001b[39m, in \u001b[36mFigureCanvasBase.print_figure\u001b[39m\u001b[34m(self, filename, dpi, facecolor, edgecolor, orientation, format, bbox_inches, pad_inches, bbox_extra_artists, backend, **kwargs)\u001b[39m\n\u001b[32m 2182\u001b[39m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[32m 2183\u001b[39m \u001b[38;5;66;03m# _get_renderer may change the figure dpi (as vector formats\u001b[39;00m\n\u001b[32m 2184\u001b[39m \u001b[38;5;66;03m# force the figure dpi to 72), so we need to set it again here.\u001b[39;00m\n\u001b[32m 2185\u001b[39m \u001b[38;5;28;01mwith\u001b[39;00m cbook._setattr_cm(\u001b[38;5;28mself\u001b[39m.figure, dpi=dpi):\n\u001b[32m-> \u001b[39m\u001b[32m2186\u001b[39m result = \u001b[43mprint_method\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 2187\u001b[39m \u001b[43m \u001b[49m\u001b[43mfilename\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 2188\u001b[39m \u001b[43m \u001b[49m\u001b[43mfacecolor\u001b[49m\u001b[43m=\u001b[49m\u001b[43mfacecolor\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 2189\u001b[39m \u001b[43m \u001b[49m\u001b[43medgecolor\u001b[49m\u001b[43m=\u001b[49m\u001b[43medgecolor\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 2190\u001b[39m \u001b[43m \u001b[49m\u001b[43morientation\u001b[49m\u001b[43m=\u001b[49m\u001b[43morientation\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 2191\u001b[39m \u001b[43m \u001b[49m\u001b[43mbbox_inches_restore\u001b[49m\u001b[43m=\u001b[49m\u001b[43m_bbox_inches_restore\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 2192\u001b[39m \u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 2193\u001b[39m \u001b[38;5;28;01mfinally\u001b[39;00m:\n\u001b[32m 2194\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m bbox_inches \u001b[38;5;129;01mand\u001b[39;00m restore_bbox:\n", + "\u001b[36mFile \u001b[39m\u001b[32m/anaconda/envs/fem/lib/python3.13/site-packages/matplotlib/backend_bases.py:2042\u001b[39m, in \u001b[36mFigureCanvasBase._switch_canvas_and_return_print_method..\u001b[39m\u001b[34m(*args, **kwargs)\u001b[39m\n\u001b[32m 2038\u001b[39m optional_kws = { \u001b[38;5;66;03m# Passed by print_figure for other renderers.\u001b[39;00m\n\u001b[32m 2039\u001b[39m \u001b[33m\"\u001b[39m\u001b[33mdpi\u001b[39m\u001b[33m\"\u001b[39m, \u001b[33m\"\u001b[39m\u001b[33mfacecolor\u001b[39m\u001b[33m\"\u001b[39m, \u001b[33m\"\u001b[39m\u001b[33medgecolor\u001b[39m\u001b[33m\"\u001b[39m, \u001b[33m\"\u001b[39m\u001b[33morientation\u001b[39m\u001b[33m\"\u001b[39m,\n\u001b[32m 2040\u001b[39m \u001b[33m\"\u001b[39m\u001b[33mbbox_inches_restore\u001b[39m\u001b[33m\"\u001b[39m}\n\u001b[32m 2041\u001b[39m skip = optional_kws - {*inspect.signature(meth).parameters}\n\u001b[32m-> \u001b[39m\u001b[32m2042\u001b[39m print_method = functools.wraps(meth)(\u001b[38;5;28;01mlambda\u001b[39;00m *args, **kwargs: \u001b[43mmeth\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 2043\u001b[39m \u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43m{\u001b[49m\u001b[43mk\u001b[49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mv\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mk\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mv\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m.\u001b[49m\u001b[43mitems\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mk\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01mnot\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mskip\u001b[49m\u001b[43m}\u001b[49m\u001b[43m)\u001b[49m)\n\u001b[32m 2044\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m: \u001b[38;5;66;03m# Let third-parties do as they see fit.\u001b[39;00m\n\u001b[32m 2045\u001b[39m print_method = meth\n", + "\u001b[36mFile \u001b[39m\u001b[32m/anaconda/envs/fem/lib/python3.13/site-packages/matplotlib/backends/backend_agg.py:481\u001b[39m, in \u001b[36mFigureCanvasAgg.print_png\u001b[39m\u001b[34m(self, filename_or_obj, metadata, pil_kwargs)\u001b[39m\n\u001b[32m 434\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mprint_png\u001b[39m(\u001b[38;5;28mself\u001b[39m, filename_or_obj, *, metadata=\u001b[38;5;28;01mNone\u001b[39;00m, pil_kwargs=\u001b[38;5;28;01mNone\u001b[39;00m):\n\u001b[32m 435\u001b[39m \u001b[38;5;250m \u001b[39m\u001b[33;03m\"\"\"\u001b[39;00m\n\u001b[32m 436\u001b[39m \u001b[33;03m Write the figure to a PNG file.\u001b[39;00m\n\u001b[32m 437\u001b[39m \n\u001b[32m (...)\u001b[39m\u001b[32m 479\u001b[39m \u001b[33;03m *metadata*, including the default 'Software' key.\u001b[39;00m\n\u001b[32m 480\u001b[39m \u001b[33;03m \"\"\"\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m481\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_print_pil\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfilename_or_obj\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mpng\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mpil_kwargs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmetadata\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m/anaconda/envs/fem/lib/python3.13/site-packages/matplotlib/backends/backend_agg.py:430\u001b[39m, in \u001b[36mFigureCanvasAgg._print_pil\u001b[39m\u001b[34m(self, filename_or_obj, fmt, pil_kwargs, metadata)\u001b[39m\n\u001b[32m 425\u001b[39m \u001b[38;5;250m\u001b[39m\u001b[33;03m\"\"\"\u001b[39;00m\n\u001b[32m 426\u001b[39m \u001b[33;03mDraw the canvas, then save it using `.image.imsave` (to which\u001b[39;00m\n\u001b[32m 427\u001b[39m \u001b[33;03m*pil_kwargs* and *metadata* are forwarded).\u001b[39;00m\n\u001b[32m 428\u001b[39m \u001b[33;03m\"\"\"\u001b[39;00m\n\u001b[32m 429\u001b[39m FigureCanvasAgg.draw(\u001b[38;5;28mself\u001b[39m)\n\u001b[32m--> \u001b[39m\u001b[32m430\u001b[39m \u001b[43mmpl\u001b[49m\u001b[43m.\u001b[49m\u001b[43mimage\u001b[49m\u001b[43m.\u001b[49m\u001b[43mimsave\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 431\u001b[39m \u001b[43m \u001b[49m\u001b[43mfilename_or_obj\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mbuffer_rgba\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mformat\u001b[39;49m\u001b[43m=\u001b[49m\u001b[43mfmt\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43morigin\u001b[49m\u001b[43m=\u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mupper\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m 432\u001b[39m \u001b[43m \u001b[49m\u001b[43mdpi\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mfigure\u001b[49m\u001b[43m.\u001b[49m\u001b[43mdpi\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmetadata\u001b[49m\u001b[43m=\u001b[49m\u001b[43mmetadata\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mpil_kwargs\u001b[49m\u001b[43m=\u001b[49m\u001b[43mpil_kwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m/anaconda/envs/fem/lib/python3.13/site-packages/matplotlib/image.py:1657\u001b[39m, in \u001b[36mimsave\u001b[39m\u001b[34m(fname, arr, vmin, vmax, cmap, format, origin, dpi, metadata, pil_kwargs)\u001b[39m\n\u001b[32m 1655\u001b[39m pil_kwargs.setdefault(\u001b[33m\"\u001b[39m\u001b[33mformat\u001b[39m\u001b[33m\"\u001b[39m, \u001b[38;5;28mformat\u001b[39m)\n\u001b[32m 1656\u001b[39m pil_kwargs.setdefault(\u001b[33m\"\u001b[39m\u001b[33mdpi\u001b[39m\u001b[33m\"\u001b[39m, (dpi, dpi))\n\u001b[32m-> \u001b[39m\u001b[32m1657\u001b[39m \u001b[43mimage\u001b[49m\u001b[43m.\u001b[49m\u001b[43msave\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfname\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mpil_kwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m/anaconda/envs/fem/lib/python3.13/site-packages/PIL/Image.py:2566\u001b[39m, in \u001b[36mImage.save\u001b[39m\u001b[34m(self, fp, format, **params)\u001b[39m\n\u001b[32m 2564\u001b[39m fp = builtins.open(filename, \u001b[33m\"\u001b[39m\u001b[33mr+b\u001b[39m\u001b[33m\"\u001b[39m)\n\u001b[32m 2565\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m-> \u001b[39m\u001b[32m2566\u001b[39m fp = \u001b[43mbuiltins\u001b[49m\u001b[43m.\u001b[49m\u001b[43mopen\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfilename\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mw+b\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[32m 2567\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m 2568\u001b[39m fp = cast(IO[\u001b[38;5;28mbytes\u001b[39m], fp)\n", + "\u001b[31mFileNotFoundError\u001b[39m: [Errno 2] No such file or directory: 'img/mesh_optim_000.png'" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# lets visualize the 3d meshes over the optimization\n", + "for i, params in enumerate(params_hist):\n", + " design_out = design_tess.apply(\n", + " {\n", + " \"bar_params\": params,\n", + " \"bar_radius\": bar_radius,\n", + " \"Lx\": Lx,\n", + " \"Ly\": Ly,\n", + " \"Lz\": Lz,\n", + " \"Nx\": Nx,\n", + " \"Ny\": Ny,\n", + " \"Nz\": Nz,\n", + " \"epsilon\": 1e-3, # epsilon, only used for FD of the jacobian\n", + " }\n", + " )\n", + " surface_mesh = design_out[\"mesh\"]\n", + "\n", + " num_vertices = surface_mesh[\"n_points\"]\n", + " num_faces = surface_mesh[\"n_faces\"]\n", + "\n", + " points = surface_mesh[\"points\"][:num_vertices]\n", + " faces = surface_mesh[\"faces\"][:num_faces]\n", + "\n", + " mesh = {\n", + " \"points\": points,\n", + " \"faces\": faces,\n", + " }\n", + "\n", + " plot_mesh(mesh, save_path=f\"img/mesh_optim_{i:03d}.png\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2f430741", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "fem", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/ansys/design_tess_old copy/tesseract_api.py b/examples/ansys/design_tess_old copy/tesseract_api.py new file mode 100644 index 0000000..0eaf13f --- /dev/null +++ b/examples/ansys/design_tess_old copy/tesseract_api.py @@ -0,0 +1,384 @@ +from typing import Any + +import numpy as np +import pyvista as pv +import trimesh +from pydantic import BaseModel, Field +from pysdf import SDF +from tesseract_core.runtime import Array, Differentiable, Float32, Int32, ShapeDType + +# +# Schemata +# + + +class InputSchema(BaseModel): + """Input schema for bar geometry design and SDF generation.""" + + bar_params: Differentiable[ + Array[ + (None, None, 3), + Float32, + ] + ] = Field( + description=( + "Vertex positions of the bar geometry. " + "The shape is (num_bars, num_vertices, 3), where num_bars is the number of bars " + "and num_vertices is the number of vertices per bar. The last dimension represents " + "the x, y, z coordinates of each vertex." + ) + ) + + bar_radius: float = Field( + default=1.5, + description=("Radius of the bars in the geometry. "), + ) + + Lx: float = Field( + default=60.0, + description=("Length of the SDF box in the x direction. "), + ) + Ly: float = Field( + default=30.0, + description=("Length of the SDF box in the y direction. "), + ) + Lz: float = Field( + default=30.0, + description=("Length of the SDF box in the z direction. "), + ) + Nx: int = Field( + default=60, + description=("Number of elements in the x direction. "), + ) + Ny: int = Field( + default=30, + description=("Number of elements in the y direction. "), + ) + Nz: int = Field( + default=30, + description=("Number of elements in the z direction. "), + ) + epsilon: float = Field( + default=1e-5, + description=( + "Epsilon value for finite difference approximation of the Jacobian. " + ), + ) + normalize_jacobian: bool = Field( + default=False, + description=("Whether to normalize the Jacobian by the number of elements"), + ) + normalize_vjp: bool = Field( + default=False, + description=( + "Whether to normalize the vector-Jacobian product (VJP) to have a std of 1. " + ), + ) + + +class TriangularMesh(BaseModel): + """Triangular mesh representation with fixed-size arrays.""" + + points: Array[(None, 3), Float32] = Field(description="Array of vertex positions.") + faces: Array[(None, 3), Float32] = Field( + description="Array of triangular faces defined by indices into the points array." + ) + n_points: Int32 = Field( + default=0, description="Number of valid points in the points array." + ) + n_faces: Int32 = Field( + default=0, description="Number of valid faces in the faces array." + ) + + +class OutputSchema(BaseModel): + """Output schema for generated geometry and SDF field.""" + + mesh: TriangularMesh = Field( + description="Triangular mesh representation of the geometry" + ) + sdf: Differentiable[ + Array[ + (None, None, None), + Float32, + ] + ] = Field(description="SDF field of the geometry") + + +# +# Helper functions +# + + +def build_geometry( + params: np.ndarray, + radius: float, +) -> list[trimesh.Trimesh]: + """Build a pyvista geometry from the parameters. + + The parameters are expected to be of shape (n_chains, n_edges_per_chain + 1, 3), + """ + n_chains = params.shape[0] + geometry = [] + + for chain in range(n_chains): + tube = pv.Spline(points=params[chain]).tube( + radius=radius, capping=True, n_sides=30 + ) + tube = tube.triangulate() + tube = pyvista_to_trimesh(tube) + geometry.append(tube) + + return geometry + + +def pyvista_to_trimesh(mesh: pv.PolyData) -> trimesh.Trimesh: + """Convert a pyvista mesh to a trimesh style polygon mesh.""" + points = mesh.points + points_per_face = mesh.faces[0] + n_faces = mesh.faces.shape[0] // (points_per_face + 1) + + faces = mesh.faces.reshape(n_faces, (points_per_face + 1))[:, 1:] + + return trimesh.Trimesh(vertices=points, faces=faces) + + +def compute_sdf( + geometry: trimesh.Trimesh, + Lx: float, + Ly: float, + Lz: float, + Nx: int, + Ny: int, + Nz: int, +) -> np.ndarray: + """Create a pyvista plane that has the SDF values stored as a vertex attribute. + + The SDF field is computed based on the geometry defined by the parameters. + """ + x, y, z = np.meshgrid( + np.linspace(-Lx / 2, Lx / 2, Nx), + np.linspace(-Ly / 2, Ly / 2, Ny), + np.linspace(-Lz / 2, Lz / 2, Nz), + indexing="ij", + ) + + points, faces = geometry.vertices, geometry.faces + + sdf_function = SDF(points, faces) + + grid_points = np.vstack((x.ravel(), y.ravel(), z.ravel())).T + sdf_values = sdf_function(grid_points).astype(np.float32) + + sd_field = sdf_values.reshape((Nx, Ny, Nz)) + + return -sd_field + + +def apply_fn( + params: np.ndarray, + radius: float, + Lx: float, + Ly: float, + Lz: float, + Nx: int, + Ny: int, + Nz: int, +) -> tuple[np.ndarray, trimesh.Trimesh]: + """Get the sdf values of a the geometry defined by the parameters as a 2D array.""" + geometries = build_geometry( + params, + radius=radius, + ) + + # convert each geometry in a trimesh style mesh and combine them + base = geometries[0] + + for geom in geometries[1:]: + base = base.union(geom) + + sd_field = compute_sdf( + base, + Lx=Lx, + Ly=Ly, + Lz=Lz, + Nx=Nx, + Ny=Ny, + Nz=Nz, + ) + + return sd_field, base + + +def jac_sdf_wrt_params( + params: np.ndarray, + radius: float, + Lx: float, + Ly: float, + Lz: float, + Nx: int, + Ny: int, + Nz: int, + epsilon: float, +) -> np.ndarray: + """Compute the Jacobian of the SDF values with respect to the parameters. + + The Jacobian is computed by finite differences. + The shape of the Jacobian is (n_chains, n_edges_per_chain + 1, 3, Nx, Ny). + """ + n_chains = params.shape[0] + n_edges_per_chain = params.shape[1] - 1 + + jac = np.zeros( + ( + n_chains, + n_edges_per_chain + 1, + 3, # number of dimensions (x, y, z) + Nx, + Ny, + Nz, + ) + ) + + sd_field_base, _ = apply_fn( + params, + radius=radius, + Lx=Lx, + Ly=Ly, + Lz=Lz, + Nx=Nx, + Ny=Ny, + Nz=Nz, + ) + + for chain in range(n_chains): + for vertex in range(0, n_edges_per_chain + 1): + # we only care about the y and z coordinate + for i in [1, 2]: + params_eps = params.copy() + params_eps[chain, vertex, i] += epsilon + + sdf_epsilon, _ = apply_fn( + params_eps, + radius=radius, + Lx=Lx, + Ly=Ly, + Lz=Lz, + Nx=Nx, + Ny=Ny, + Nz=Nz, + ) + jac[chain, vertex, i] = (sdf_epsilon - sd_field_base) / epsilon + + return jac + + +# +# Tesseract endpoints +# + +N_POINTS = 1000 +N_FACES = 2000 + + +def apply(inputs: InputSchema) -> OutputSchema: + """Generate mesh and SDF from bar geometry parameters. + + Args: + inputs: Input schema containing bar geometry parameters. + + Returns: + Output schema with generated mesh and SDF field. + """ + sdf, mesh = apply_fn( + inputs.bar_params, + radius=inputs.bar_radius, + Lx=inputs.Lx, + Ly=inputs.Ly, + Lz=inputs.Lz, + Nx=inputs.Nx, + Ny=inputs.Ny, + Nz=inputs.Nz, + ) + points = np.zeros((N_POINTS, 3), dtype=np.float32) + faces = np.zeros((N_FACES, 3), dtype=np.float32) + + points[: mesh.vertices.shape[0], :] = mesh.vertices.astype(np.float32) + faces[: mesh.faces.shape[0], :] = mesh.faces.astype(np.int32) + + return OutputSchema( + sdf=sdf, + mesh=TriangularMesh( + points=points, + faces=faces, + n_points=mesh.vertices.shape[0], + n_faces=mesh.faces.shape[0], + ), + ) + + +def vector_jacobian_product( + inputs: InputSchema, + vjp_inputs: set[str], + vjp_outputs: set[str], + cotangent_vector: dict[str, Any], +) -> dict[str, Any]: + """Compute vector-Jacobian product for backpropagation. + + Args: + inputs: Input schema containing bar geometry parameters. + vjp_inputs: Set of input variable names for gradient computation. + vjp_outputs: Set of output variable names for gradient computation. + cotangent_vector: Cotangent vectors for the specified outputs. + + Returns: + Dictionary containing VJP for the specified inputs. + """ + assert vjp_inputs == {"bar_params"} + assert vjp_outputs == {"sdf"} + + jac = jac_sdf_wrt_params( + inputs.bar_params, + radius=inputs.bar_radius, + Lx=inputs.Lx, + Ly=inputs.Ly, + Lz=inputs.Lz, + Nx=inputs.Nx, + Ny=inputs.Ny, + Nz=inputs.Nz, + epsilon=inputs.epsilon, + ) + if inputs.normalize_jacobian: + n_elements = inputs.Nx * inputs.Ny * inputs.Nz + jac = jac / n_elements + # Reduce the cotangent vector to the shape of the Jacobian, to compute VJP by hand + vjp = np.einsum("ijklmn,lmn->ijk", jac, cotangent_vector["sdf"]).astype(np.float32) + if inputs.normalize_vjp: + vjp_std = np.std(vjp) + if vjp_std > 0: + vjp = vjp / vjp_std + + return {"bar_params": vjp} + + +def abstract_eval(abstract_inputs: InputSchema) -> dict: + """Calculate output shape of apply from the shape of its inputs. + + Args: + abstract_inputs: Input schema with parameter shapes. + + Returns: + Dictionary describing output shapes and dtypes. + """ + return { + "sdf": ShapeDType( + shape=(abstract_inputs.Nx, abstract_inputs.Ny, abstract_inputs.Nz), + dtype="float32", + ), + "mesh": { + "points": ShapeDType(shape=(N_POINTS, 3), dtype="float32"), + "faces": ShapeDType(shape=(N_FACES, 3), dtype="float32"), + "n_points": ShapeDType(shape=(), dtype="int32"), + "n_faces": ShapeDType(shape=(), dtype="int32"), + }, + } diff --git a/examples/ansys/design_tess_old copy/tesseract_config.yaml b/examples/ansys/design_tess_old copy/tesseract_config.yaml new file mode 100644 index 0000000..770d719 --- /dev/null +++ b/examples/ansys/design_tess_old copy/tesseract_config.yaml @@ -0,0 +1,11 @@ +name: design-tube-sdf +version: "0.2.0" +description: | + Tesseract that generates a gridded signed distance function (SDF) for a set of shape parameters. + + Parameters are expected to define the control points and radii of piecewise linear tubes in 3D space. + + Has a VJP endpoint defined that uses finite differences under the hood. + +build_config: + target_platform: "linux/x86_64" diff --git a/examples/ansys/design_tess_old copy/tesseract_requirements.txt b/examples/ansys/design_tess_old copy/tesseract_requirements.txt new file mode 100644 index 0000000..f95b514 --- /dev/null +++ b/examples/ansys/design_tess_old copy/tesseract_requirements.txt @@ -0,0 +1,5 @@ +numpy==1.26.4 +pyvista==0.45.2 +manifold3d==3.2.1 +trimesh==4.9.0 +pysdf==0.1.9 diff --git a/examples/ansys/fem_shapeopt_mesh.vtk b/examples/ansys/fem_shapeopt_mesh.vtk new file mode 100644 index 0000000..150c58e Binary files /dev/null and b/examples/ansys/fem_shapeopt_mesh.vtk differ diff --git a/examples/ansys/fem_shapeopt_mesh1.vtk b/examples/ansys/fem_shapeopt_mesh1.vtk new file mode 100644 index 0000000..8f03a99 Binary files /dev/null and b/examples/ansys/fem_shapeopt_mesh1.vtk differ diff --git a/examples/ansys/fem_tess/tesseract_api.py b/examples/ansys/fem_tess/tesseract_api.py new file mode 100644 index 0000000..1256f3d --- /dev/null +++ b/examples/ansys/fem_tess/tesseract_api.py @@ -0,0 +1,352 @@ +import os +from collections.abc import Callable +from typing import Any + +import jax +import jax.numpy as jnp +import meshio +from jax_fem.generate_mesh import Mesh + +# Import JAX-FEM specific modules +from jax_fem.problem import Problem +from jax_fem.solver import ad_wrapper +from pydantic import BaseModel, Field +from tesseract_core.runtime import Array, Differentiable, Float32, Int32, ShapeDType +from tesseract_core.runtime.tree_transforms import filter_func, flatten_with_paths + +crt_file_path = os.path.dirname(__file__) +data_dir = os.path.join(crt_file_path, "data") +# +# Schemata +# + + +class HexMesh(BaseModel): + """Hexahedral mesh representation.""" + + points: Array[(None, 3), Float32] = Field(description="Array of vertex positions.") + faces: Array[(None, 8), Int32] = Field( + description="Array of hexahedral faces defined by indices into the points array." + ) + n_points: Int32 = Field( + default=0, description="Number of valid points in the points array." + ) + n_faces: Int32 = Field( + default=0, description="Number of valid faces in the faces array." + ) + + +class InputSchema(BaseModel): + """Input schema for topology optimization using hexahedral mesh.""" + + rho: Differentiable[ + Array[ + ( + None, + None, + ), + Float32, + ] + ] = Field(description="2D density field for topology optimization") + van_neumann_mask: Array[(None,), Int32] = Field( + description="Mask for van Neumann boundary conditions", + ) + van_neumann_values: Array[(None, None), Float32] = Field( + description="Values for van Neumann boundary conditions", + ) + dirichlet_mask: Array[(None,), Int32] = Field( + description="Mask for Dirichlet boundary conditions", + ) + dirichlet_values: Array[(None,), Float32] = Field( + description="Values for Dirichlet boundary conditions", + ) + hex_mesh: HexMesh = Field( + description="Hexahedral mesh representation of the geometry", + ) + + +class OutputSchema(BaseModel): + """Output schema for topology optimization using hexahedral mesh.""" + + compliance: Differentiable[ + Array[ + (), + Float32, + ] + ] = Field(description="Compliance of the structure, a measure of stiffness") + + +# displacement: Array[ +# (None, 3), +# Float32, +# ] = Field(description="Nodal displacement field") + +# +# Helper functions +# + + +# Define constitutive relationship +# Adapted from JAX-FEM +# https://github.com/deepmodeling/jax-fem/blob/1bdbf060bb32951d04ed9848c238c9a470fee1b4/demos/topology_optimization/example.py +class Elasticity(Problem): + """Linear elasticity problem with custom constitutive law.""" + + def custom_init(self, van_neumann_value_fns: list[Callable]) -> None: + """Initialize custom problem parameters. + + Args: + van_neumann_value_fns: List of functions for van Neumann boundary conditions. + """ + self.fe = self.fes[0] + self.fe.flex_inds = jnp.arange(len(self.fe.cells)) + + self.van_neumann_value_fns = van_neumann_value_fns + + def get_tensor_map(self) -> Callable: + """Get the stress-strain constitutive relationship tensor map. + + Returns: + Callable that computes stress from strain gradient and density. + """ + + def stress(u_grad, theta): + Emax = 70.0e3 + Emin = 1e-3 * Emax + penal = 3.0 + + E = Emin + (Emax - Emin) * theta[0] ** penal + + nu = 0.3 + mu = E / (2.0 * (1.0 + nu)) + lmbda = E * nu / ((1 + nu) * (1 - 2 * nu)) + + epsilon = 0.5 * (u_grad + u_grad.T) + + sigma = lmbda * jnp.trace(epsilon) * jnp.eye(self.dim) + 2.0 * mu * epsilon + return sigma + + return stress + + def get_surface_maps(self) -> list[Callable]: + """Get surface traction boundary condition functions. + + Returns: + List of van Neumann boundary condition value functions. + """ + return self.van_neumann_value_fns + + def set_params(self, params: jnp.ndarray) -> None: + """Set density parameters for topology optimization. + + Args: + params: Density field array for the flexible elements. + """ + # Override base class method. + full_params = jnp.ones((self.fe.num_cells, params.shape[1])) + full_params = full_params.at[self.fe.flex_inds].set(params) + thetas = jnp.repeat(full_params[:, None, :], self.fe.num_quads, axis=1) + self.full_params = full_params + self.internal_vars = [thetas] + + def compute_compliance(self, sol: jnp.ndarray) -> jnp.ndarray: + """Compute structural compliance via surface integral. + + Args: + sol: Solution displacement field. + + Returns: + Compliance value (scalar). + """ + # Surface integral + boundary_inds = self.boundary_inds_list[0] + _, nanson_scale = self.fe.get_face_shape_grads(boundary_inds) + u_face = ( + sol[self.fe.cells][boundary_inds[:, 0]][:, None, :, :] + * self.fe.face_shape_vals[boundary_inds[:, 1]][:, :, :, None] + ) + u_face = jnp.sum(u_face, axis=2) + subset_quad_points = self.physical_surface_quad_points[0] + neumann_fn = self.get_surface_maps()[0] + traction = -jax.vmap(jax.vmap(neumann_fn))(u_face, subset_quad_points) + val = jnp.sum(traction * u_face * nanson_scale[:, :, None]) + return val + + +# Memoize the setup function to avoid expensive recomputation +# @lru_cache(maxsize=1) +def setup( + pts: jnp.ndarray = None, + cells: jnp.ndarray = None, + dirichlet_mask: jnp.ndarray = None, + dirichlet_values: jnp.ndarray = None, + van_neumann_mask: jnp.ndarray = None, + van_neumann_values: jnp.ndarray = None, +) -> tuple[Elasticity, Callable]: + """Setup the elasticity problem and its differentiable solver. + + Args: + pts: Optional array of mesh vertex positions for custom mesh. + cells: Optional array of hexahedral cell definitions for custom mesh. + dirichlet_mask: Mask array for Dirichlet boundary conditions. + dirichlet_values: Values array for Dirichlet boundary conditions. + van_neumann_mask: Mask array for van Neumann boundary conditions. + van_neumann_values: Values array for van Neumann boundary conditions. + + Returns: + Tuple of (problem, fwd_pred) where problem is the configured Elasticity + problem instance and fwd_pred is the differentiable forward solver. + """ + ele_type = "HEX8" + meshio_mesh = meshio.Mesh(points=pts, cells={"hexahedron": cells}) + mesh = Mesh(pts, meshio_mesh.cells_dict["hexahedron"]) + + def bc_factory( + masks: jnp.ndarray, + values: jnp.ndarray, + is_van_neumann: bool = False, + ) -> tuple[list[Callable], list[Callable]]: + location_functions = [] + value_functions = [] + + for i in range(values.shape[0]): + # Create a factory that captures the current value of i + def make_location_fn(idx): + def location_fn(point, index): + return ( + jnp.sum( + jax.lax.dynamic_index_in_dim( + masks, index, 0, keepdims=False + ) + ) + == idx + 1 + ).astype(jnp.bool_) + + return location_fn + + def make_value_fn(idx): + def value_fn(point): + return values[idx] + + return value_fn + + def make_value_fn_vn(idx): + def value_fn_vn(u, x): + return values[idx] + + return value_fn_vn + + location_functions.append(make_location_fn(i)) + value_functions.append( + make_value_fn_vn(i) if is_van_neumann else make_value_fn(i) + ) + + return location_functions, value_functions + + dirichlet_mask = jnp.array(dirichlet_mask) + van_neumann_mask = jnp.array(van_neumann_mask) + + dirichlet_location_fns, dirichlet_value_fns = bc_factory( + dirichlet_mask, dirichlet_values + ) + + van_neumann_locations, van_neumann_value_fns = bc_factory( + van_neumann_mask, van_neumann_values, is_van_neumann=True + ) + + dirichlet_bc_info = [dirichlet_location_fns * 3, [0, 1, 2], dirichlet_value_fns * 3] + + location_fns = van_neumann_locations + + # Define forward problem + problem = Elasticity( + mesh, + vec=3, + dim=3, + ele_type=ele_type, + dirichlet_bc_info=dirichlet_bc_info, + location_fns=location_fns, + additional_info=(van_neumann_value_fns,), + # additional_info=([0.1],), + ) + + # Apply the automatic differentiation wrapper + # This is a critical step that makes the problem solver differentiable + fwd_pred = ad_wrapper( + problem, + solver_options={"umfpack_solver": {}}, + adjoint_solver_options={"umfpack_solver": {}}, + ) + return problem, fwd_pred + + +def apply_fn(inputs: dict) -> dict: + """Compute the compliance of the structure given a density field. + + Args: + inputs: Dictionary containing input parameters and density field. + + Returns: + Dictionary containing the compliance of the structure. + """ + # no stop grads + problem, fwd_pred = setup( + pts=inputs["hex_mesh"]["points"][: inputs["hex_mesh"]["n_points"]], + cells=inputs["hex_mesh"]["faces"][: inputs["hex_mesh"]["n_faces"]], + dirichlet_mask=inputs["dirichlet_mask"], + dirichlet_values=inputs["dirichlet_values"], + van_neumann_mask=inputs["van_neumann_mask"], + van_neumann_values=inputs["van_neumann_values"], + ) + + rho = inputs["rho"][: inputs["hex_mesh"]["n_faces"]] + + sol_list = fwd_pred(rho) + compliance = problem.compute_compliance(sol_list[0]) + + return {"compliance": compliance.astype(jnp.float32)} + + +# +# Tesseract endpoints +# + + +def apply(inputs: InputSchema) -> OutputSchema: + """Compute the compliance of the structure given a density field.""" + return apply_fn(inputs.model_dump()) + + +def vector_jacobian_product( + inputs: InputSchema, + vjp_inputs: set[str], + vjp_outputs: set[str], + cotangent_vector: dict[str, Any], +) -> dict[str, Any]: + """Compute vector-Jacobian product for specified inputs and outputs. + + Args: + inputs: InputSchema instance containing input parameters and density field. + vjp_inputs: Set of input variable names for which to compute gradients. + vjp_outputs: Set of output variable names with respect to which to compute gradients. + cotangent_vector: Dictionary containing cotangent vectors for the specified outputs. + + Returns: + Dictionary containing the vector-Jacobian product for the specified inputs. + """ + assert vjp_inputs == {"rho"} + assert vjp_outputs == {"compliance"} + + inputs = inputs.model_dump() + + filtered_apply = filter_func(apply_fn, inputs, vjp_outputs) + _, vjp_func = jax.vjp( + filtered_apply, flatten_with_paths(inputs, include_paths=vjp_inputs) + ) + out = vjp_func(cotangent_vector)[0] + return out + + +def abstract_eval(abstract_inputs: InputSchema) -> dict: + """Calculate output shape of apply from the shape of its inputs.""" + return {"compliance": ShapeDType(shape=(), dtype="float32")} diff --git a/examples/ansys/fem_tess/tesseract_config.yaml b/examples/ansys/fem_tess/tesseract_config.yaml new file mode 100644 index 0000000..603452b --- /dev/null +++ b/examples/ansys/fem_tess/tesseract_config.yaml @@ -0,0 +1,17 @@ +name: structure-jax-fem +version: "0.1.0" +description: | + Tesseract that wraps jax-fem for structural analysis. + + Accepts a gridded density field as input and computes the compliance of the structure. + The density field is expected to be a 3D numpy array with values between 0 and 1, + where 1 represents solid material and 0 represents void. + +build_config: + target_platform: "native" + # conda-forge has binaries for gmsh and friends, even on ARM64 + base_image: "condaforge/miniforge3:latest" + requirements: + provider: conda + extra_packages: + - libgl1 diff --git a/examples/ansys/fem_tess/tesseract_environment.yaml b/examples/ansys/fem_tess/tesseract_environment.yaml new file mode 100644 index 0000000..44026b1 --- /dev/null +++ b/examples/ansys/fem_tess/tesseract_environment.yaml @@ -0,0 +1,21 @@ +name: jax-fem-env +channels: + - conda-forge +dependencies: + - python==3.12 + - numpy==2.3.0 + - scipy==1.15.2 + - matplotlib==3.10.3 + - meshio==5.3.5 + - petsc4py==3.23.3 + - fenics==2019.1.0 + - gmsh==4.13.1 + - python-gmsh==4.13.1 + - pip + - pip: + - setuptools + - wheel + - fenics-basix==0.9.0 + - pyfiglet==1.0.3 + - jax[cpu]==0.5.3 + - jax-fem==0.0.9 diff --git a/examples/ansys/gf.py b/examples/ansys/gf.py new file mode 100644 index 0000000..d293a9a --- /dev/null +++ b/examples/ansys/gf.py @@ -0,0 +1,10 @@ +import imageio + +images = [] + +for i in range(3): + filename = f"tmp_img/mesh_optim_{i:03d}.png" + images.append(imageio.imread(filename)) + print(f"Added {filename} to gif.") +# make sure the gif repeats forever +imageio.mimsave("mesh_optim.gif", images, fps=10, loop=0) diff --git a/examples/ansys/mesh_optim.gif b/examples/ansys/mesh_optim.gif new file mode 100644 index 0000000..13896aa Binary files /dev/null and b/examples/ansys/mesh_optim.gif differ diff --git a/examples/ansys/meshing_tess/tesseract_api.py b/examples/ansys/meshing_tess/tesseract_api.py new file mode 100644 index 0000000..933a347 --- /dev/null +++ b/examples/ansys/meshing_tess/tesseract_api.py @@ -0,0 +1,513 @@ +from typing import Any + +import jax.numpy as jnp + +# import numpy as jnp +from jax.scipy.interpolate import RegularGridInterpolator +from pydantic import BaseModel, Field +from scipy.interpolate import griddata +from tesseract_core.runtime import Array, Differentiable, Float32, Int32, ShapeDType + +# +# Schemata +# + + +class InputSchema(BaseModel): + """Input schema for hexahedral mesh generation and field interpolation.""" + + field_values: Differentiable[ + Array[ + (None, None, None), + Float32, + ] + ] = Field( + description=("Values defined on a regular grid that are to be differentiated.") + ) + sizing_field: Array[ + (None, None, None), + Float32, + ] = Field( + description=( + "Sizing field values defined on a regular grid for mesh adaptation." + ) + ) + domain_size: tuple[float, float, float] = Field( + description=("Size of the domain in x, y, z directions.") + ) + + max_points: int = Field( + default=10000, + description=("Maximum number of points in the output hex mesh. "), + ) + + max_cells: int = Field( + default=10000, + description=("Maximum number of hexahedral cells in the output hex mesh. "), + ) + + max_subdivision_levels: int = Field( + default=5, + description=("Maximum number of subdivision levels for the hex mesh. "), + ) + + +class HexMesh(BaseModel): + """Hexagonal mesh representation.""" + + points: Array[(None, 3), Float32] = Field(description="Array of vertex positions.") + faces: Array[(None, 8), Int32] = Field( + description="Array of hexahedral faces defined by indices into the points array." + ) + n_points: Int32 = Field( + default=0, description="Number of valid points in the points array." + ) + n_faces: Int32 = Field( + default=0, description="Number of valid faces in the faces array." + ) + + +class OutputSchema(BaseModel): + """Output schema for hexahedral mesh generation and field interpolation.""" + + mesh: HexMesh = Field(description="Hexagonal mesh representation of the geometry") + mesh_cell_values: Differentiable[ + Array[ + (None,), + Float32, + ] + ] = Field(description="Cell-centered values defined on the hexahedral mesh.") + + +# +# Helper functions +# +def create_single_hex( + Lx: float, + Ly: float, + Lz: float, +) -> tuple[jnp.ndarray, jnp.ndarray]: + """Create a single HEX8 mesh of a cuboid domain.""" + # Define the 8 corner points of the hexahedron + points = jnp.array( + [ + [-Lx / 2, -Ly / 2, -Lz / 2], # Point 0 + [Lx / 2, -Ly / 2, -Lz / 2], # Point 1 + [Lx / 2, Ly / 2, -Lz / 2], # Point 2 + [-Lx / 2, Ly / 2, -Lz / 2], # Point 3 + [-Lx / 2, -Ly / 2, Lz / 2], # Point 4 + [Lx / 2, -Ly / 2, Lz / 2], # Point 5 + [Lx / 2, Ly / 2, Lz / 2], # Point 6 + [-Lx / 2, Ly / 2, Lz / 2], # Point 7 + ], + dtype=jnp.float32, + ) + + # Define the hexahedron cell using the point indices + hex_cells = jnp.array( + [ + [0, 1, 2, 3, 4, 5, 6, 7] # Single HEX8 element + ], + dtype=jnp.int32, + ) + + return points, hex_cells + + +def vectorized_subdivide_hex_mesh( + hex_cells: jnp.ndarray, # (n_hex, 8) + pts_coords: jnp.ndarray, # (n_points, 3) + mask: jnp.ndarray, # (n_hex,) boolean array indicating which hexes to subdivide + split_x: bool = True, + split_y: bool = True, + split_z: bool = True, +) -> tuple[jnp.ndarray, jnp.ndarray]: + """Vectorized subdivision of HEX8 mesh. + + This method introduces duplicates of points that should later be merged. + + Hexahedron is constructed as follows: + + 7 -------- 6 + /| /| + 4 -------- 5 | + | | | | + | 3 -------|-2 + |/ |/ + 0 -------- 1 + + Axis orientation: + + z y + | / + |/____ x + + """ + # compute sizes + n_hex_to_subdiv = mask.sum() + n_hex_each_hex = (split_x + 1) * (split_y + 1) * (split_z + 1) + n_points_per_hex = 8 + # 8 corners per new hex, 8 new hexes per old hex + n_new_pts = n_points_per_hex * n_hex_each_hex * n_hex_to_subdiv + n_new_cells = n_hex_each_hex * n_hex_to_subdiv + + new_pts_coords = jnp.zeros((n_new_pts, 3), dtype=pts_coords.dtype) + new_hex_cells = jnp.zeros((n_new_cells, 8), dtype=hex_cells.dtype) + + # get sizes of hexes to subdivide + hex_sizes = jnp.abs(pts_coords[hex_cells[mask, 6]] - pts_coords[hex_cells[mask, 0]]) + # Ceneter points of shape (n_hex_to_subdiv, 3) + center_points = jnp.mean(pts_coords[hex_cells[mask]], axis=1) + + # Build cell offset tensor + # that is the offset of a hex center to each of the new hex centers + cell_offsets = jnp.zeros((1, n_hex_each_hex, 3), dtype=jnp.float32) + index = 0 + for ix in range(split_x + 1): + for iy in range(split_y + 1): + for iz in range(split_z + 1): + cell_offsets = cell_offsets.at[0, index].set( + jnp.array( + [ + (0.25 - ix * 0.5) if split_x else 0.0, + (0.25 - iy * 0.5) if split_y else 0.0, + (0.25 - iz * 0.5) if split_z else 0.0, + ] + ).T + ) + index += 1 + + # We now repeat the cell offsets and scale them by the corresponding hex sizes + # Hence we have a cell_offset tensor of shape (n_hex_to_subdiv, n_hex_each_hex, 3) + cell_offsets = cell_offsets.repeat(n_hex_to_subdiv, axis=0) * hex_sizes.reshape( + (n_hex_to_subdiv, 1, 3) + ).repeat(n_hex_each_hex, axis=1) + + # Build point offset tensor + # that is the offset of a hex center to each of the new hex points + offset_x = 0.25 if split_x else 0.5 + offset_y = 0.25 if split_y else 0.5 + offset_z = 0.25 if split_z else 0.5 + point_offsets = jnp.array( + [ + [-offset_x, -offset_y, -offset_z], + [offset_x, -offset_y, -offset_z], + [offset_x, offset_y, -offset_z], + [-offset_x, offset_y, -offset_z], + [-offset_x, -offset_y, offset_z], + [offset_x, -offset_y, offset_z], + [offset_x, offset_y, offset_z], + [-offset_x, offset_y, offset_z], + ] + ) + + # Repeat the point offsets and scale them by the corresponding hex sizes + # -> point_offset tensor of shape (n_hex_to_subdiv, n_points_per_hex, 3) + point_offsets = point_offsets.reshape((1, n_points_per_hex, 3)).repeat( + hex_sizes.shape[0], axis=0 + ) * hex_sizes.reshape((n_hex_to_subdiv, 1, 3)).repeat(n_points_per_hex, axis=1) + + # Repeat the two offsets at an additional axis to get all combinations + cell_offsets = cell_offsets.reshape((n_hex_to_subdiv, n_hex_each_hex, 1, 3)).repeat( + n_points_per_hex, axis=2 + ) + point_offsets = point_offsets.reshape( + (n_hex_to_subdiv, 1, n_points_per_hex, 3) + ).repeat(n_hex_each_hex, axis=1) + + # Compute total offset relative to old hex center + # -> (n_hex_to_subdiv, n_hex_each_hex, n_points_per_hex, 3) + total_offsets = cell_offsets + point_offsets + + # lets reshape the center points to broadcast + center_points = ( + center_points.reshape((n_hex_to_subdiv, 1, 1, 3)) + .repeat(n_hex_each_hex, axis=1) + .repeat(n_points_per_hex, axis=2) + ) + + # Directly compute new point coordinates and reshape + new_pts_coords = (center_points + total_offsets).reshape((n_new_pts, 3)) + # Compute new hex cell indices + new_hex_cells = jnp.linspace(0, n_new_pts - 1, n_new_pts, dtype=jnp.int32).reshape( + (n_new_cells, n_points_per_hex) + ) + + def reindex_and_mask( + coords: jnp.ndarray, cells: jnp.ndarray, keep_mask: jnp.ndarray + ) -> tuple[jnp.ndarray, jnp.ndarray]: + """Reindex points and cells based on mask.""" + # map mask to points + point_mask = jnp.zeros(coords.shape[0], dtype=jnp.float32) + point_mask = point_mask.at[cells.flatten()].add(keep_mask.repeat(8)) + + # Reindex new points and cells based on mask + index_offset = jnp.cumsum(jnp.logical_not(point_mask)) + cells = cells - index_offset.at[cells.flatten()].get().reshape(cells.shape) + + # apply mask to keep only subdivided hexes + coords = coords.at[point_mask > 0].get() + cells = cells.at[keep_mask].get() + + return coords, cells + + old_pts_coords, old_hex_cells = reindex_and_mask( + pts_coords, hex_cells, jnp.logical_not(mask) + ) + + old_hex_cells = old_hex_cells + new_pts_coords.shape[0] + + combined_pts_coords = jnp.vstack([new_pts_coords, old_pts_coords]) + combined_hex_cells = jnp.vstack([new_hex_cells, old_hex_cells]) + + return combined_pts_coords, combined_hex_cells + + +def remove_duplicate_points( + pts_coords: jnp.ndarray, hex_cells: jnp.ndarray +) -> tuple[jnp.ndarray, jnp.ndarray]: + """Remove duplicate points from the mesh and update hex cell indices.""" + unique_pts, inverse_indices = jnp.unique(pts_coords, axis=0, return_inverse=True) + updated_hex_cells = inverse_indices[hex_cells] + + return unique_pts, updated_hex_cells + + +def recursive_subdivide_hex_mesh( + hex_cells: jnp.ndarray, + pts_coords: jnp.ndarray, + sizing_field: jnp.ndarray, + levels: int, + Lx: float, + Ly: float, + Lz: float, +) -> tuple[jnp.ndarray, jnp.ndarray]: + """Recursively (unrolled) subdivide HEX8 mesh. + + Args: + hex_cells: Initial hexahedral cells. + pts_coords: Initial points coordinates. + sizing_field: Sizing field values on a regular grid. + levels: Maximum number of subdivision levels. + Lx: Length of the domain in x direction. + Ly: Length of the domain in y direction. + Lz: Length of the domain in z direction. + + Returns: + Subdivided points and hex cells. + """ + xs = jnp.linspace(-Lx / 2, Lx / 2, sizing_field.shape[0]) + ys = jnp.linspace(-Ly / 2, Ly / 2, sizing_field.shape[1]) + zs = jnp.linspace(-Lz / 2, Lz / 2, sizing_field.shape[2]) + + interpolator = RegularGridInterpolator( + (xs, ys, zs), sizing_field, method="nearest", bounds_error=False, fill_value=-1 + ) + + for i in range(levels): + voxel_sizes = jnp.abs(pts_coords[hex_cells[:, 6]] - pts_coords[hex_cells[:, 0]]) + + # voxel_center_points = jnp.mean(pts_coords[hex_cells], axis=1) + sizing_values_pts = interpolator(pts_coords) + voxel_sizing_min = jnp.min(sizing_values_pts[hex_cells], axis=1) + + subdivision_mask = jnp.max(voxel_sizes, axis=-1) > voxel_sizing_min + + if not jnp.any(subdivision_mask): + print(f"No more subdivisions needed at level {i}.") + break + + split_x = ( + voxel_sizes[subdivision_mask, :].max() + / voxel_sizes[subdivision_mask, 0].mean() + < 2 + ) + split_y = ( + voxel_sizes[subdivision_mask, :].max() + / voxel_sizes[subdivision_mask, 1].mean() + < 2 + ) + split_z = ( + voxel_sizes[subdivision_mask, :].max() + / voxel_sizes[subdivision_mask, 2].mean() + < 2 + ) + + pts_coords, hex_cells = vectorized_subdivide_hex_mesh( + hex_cells, + pts_coords, + subdivision_mask, + split_x=split_x, + split_y=split_y, + split_z=split_z, + ) + + pts_coords, hex_cells = remove_duplicate_points(pts_coords, hex_cells) + + return pts_coords, hex_cells + + +# @lru_cache(maxsize=1) +def generate_mesh( + Lx: float, + Ly: float, + Lz: float, + sizing_field: jnp.ndarray, + max_levels: int, +) -> tuple[jnp.ndarray, jnp.ndarray]: + """Generate adapted HEX8 mesh based on sizing field. + + Args: + Lx: Length of the domain in x direction. + Ly: Length of the domain in y direction. + Lz: Length of the domain in z direction. + sizing_field: Sizing field values on a regular grid. + max_levels: Maximum number of subdivision levels. + + Returns: + points: (n_points, 3) array of vertex positions. + hex_cells: (n_hex, 8) array of hexahedron cell indices. + """ + initial_pts, initial_hex_cells = create_single_hex(Lx, Ly, Lz) + + pts, cells = recursive_subdivide_hex_mesh( + initial_hex_cells, + initial_pts, + sizing_field, + levels=max_levels, + Lx=Lx, + Ly=Ly, + Lz=Lz, + ) + + return pts, cells + + +def apply(inputs: InputSchema) -> OutputSchema: + """Generate hexahedral mesh and interpolate field values onto cell centers. + + Args: + inputs: InputSchema, inputs to the function. + + Returns: + OutputSchema, outputs of the function. + """ + Lx = inputs.domain_size[0] + Ly = inputs.domain_size[1] + Lz = inputs.domain_size[2] + pts, cells = generate_mesh( + Lx=Lx, + Ly=Ly, + Lz=Lz, + sizing_field=inputs.sizing_field, + max_levels=inputs.max_subdivision_levels, + ) + + pts_padded = jnp.zeros((inputs.max_points, 3), dtype=pts.dtype) + pts_padded = pts_padded.at[: pts.shape[0], :].set(pts) + cells_padded = jnp.zeros((inputs.max_cells, 8), dtype=cells.dtype) + cells_padded = cells_padded.at[: cells.shape[0], :].set(cells) + + xs = jnp.linspace(-Lx / 2, Lx / 2, inputs.field_values.shape[0]) + ys = jnp.linspace(-Ly / 2, Ly / 2, inputs.field_values.shape[1]) + zs = jnp.linspace(-Lz / 2, Lz / 2, inputs.field_values.shape[2]) + + interpolator = RegularGridInterpolator( + (xs, ys, zs), + inputs.field_values, + method="linear", + bounds_error=False, + fill_value=-1, + ) + + cell_centers = jnp.mean(pts[cells], axis=1) + + cell_values = interpolator(cell_centers) + + cell_values_padded = jnp.zeros((inputs.max_cells,), dtype=cell_values.dtype) + cell_values_padded = cell_values_padded.at[: cell_values.shape[0]].set(cell_values) + + return OutputSchema( + mesh=HexMesh( + points=pts_padded.astype(jnp.float32), + faces=cells_padded.astype(jnp.int32), + n_points=pts.shape[0], + n_faces=cells.shape[0], + ), + mesh_cell_values=cell_values_padded, + ) + + +def vector_jacobian_product( + inputs: InputSchema, + vjp_inputs: set[str], + vjp_outputs: set[str], + cotangent_vector: dict[str, Any], +) -> dict[str, Any]: + """Compute vector-Jacobian product for the apply function. + + Our cotangent gradient is defined on the cells centers + we need to backpropagate it to the field values defined on the regular grid + this can be done using interpolation + We need to have the mesh cell center positions here, so instead of recomputing the mesh, + lets use the cached mesh from the last forward pass + print(generate_mesh.cache_info()) + + Args: + inputs: InputSchema, inputs to the apply function. + vjp_inputs: set of input variable names for which to compute the VJP. + vjp_outputs: set of output variable names for which the cotangent vector is provided. + cotangent_vector: dict mapping output variable names to their cotangent vectors. + + Returns: + dict mapping input variable names to their VJP results. + """ + assert vjp_inputs == {"field_values"} + assert vjp_outputs == {"mesh_cell_values"} + + Lx = inputs.domain_size[0] + Ly = inputs.domain_size[1] + Lz = inputs.domain_size[2] + + pts, cells = generate_mesh( + Lx=Lx, + Ly=Ly, + Lz=Lz, + sizing_field=inputs.sizing_field, + max_levels=inputs.max_subdivision_levels, + ) + + cell_centers = jnp.mean(pts[cells], axis=1) + + xs = jnp.linspace(-Lx / 2, Lx / 2, inputs.field_values.shape[0]) + ys = jnp.linspace(-Ly / 2, Ly / 2, inputs.field_values.shape[1]) + zs = jnp.linspace(-Lz / 2, Lz / 2, inputs.field_values.shape[2]) + xs, ys, zs = jnp.meshgrid(xs, ys, zs, indexing="ij") + + field_cotangent_vector = griddata( + cell_centers, + cotangent_vector["mesh_cell_values"][: cells.shape[0]], + (xs, ys, zs), + method="nearest", + # fill_value=0.0, + ) + + return {"field_values": jnp.array(field_cotangent_vector).astype(jnp.float32)} + + +def abstract_eval(abstract_inputs: InputSchema) -> dict[str, ShapeDType]: + """Calculate output shape of apply from the shape of its inputs.""" + return { + "mesh_cell_values": ShapeDType( + shape=(abstract_inputs.max_cells,), + dtype="float32", + ), + "mesh": { + "points": ShapeDType( + shape=(abstract_inputs.max_points, 3), dtype="float32" + ), + "faces": ShapeDType(shape=(abstract_inputs.max_cells, 8), dtype="int32"), + "n_points": ShapeDType(shape=(), dtype="int32"), + "n_faces": ShapeDType(shape=(), dtype="int32"), + }, + } diff --git a/examples/ansys/meshing_tess/tesseract_config.yaml b/examples/ansys/meshing_tess/tesseract_config.yaml new file mode 100644 index 0000000..6cc5dfa --- /dev/null +++ b/examples/ansys/meshing_tess/tesseract_config.yaml @@ -0,0 +1,7 @@ +name: meshing +version: "0.1.0" +description: | + Tesseract for differentibale adaptive meshing of hexahedral meshes. + +build_config: + target_platform: "linux/x86_64" diff --git a/examples/ansys/meshing_tess/tesseract_requirements.txt b/examples/ansys/meshing_tess/tesseract_requirements.txt new file mode 100644 index 0000000..f95b514 --- /dev/null +++ b/examples/ansys/meshing_tess/tesseract_requirements.txt @@ -0,0 +1,5 @@ +numpy==1.26.4 +pyvista==0.45.2 +manifold3d==3.2.1 +trimesh==4.9.0 +pysdf==0.1.9 diff --git a/examples/ansys/optim_bars.ipynb b/examples/ansys/optim_bars.ipynb new file mode 100644 index 0000000..639232c --- /dev/null +++ b/examples/ansys/optim_bars.ipynb @@ -0,0 +1,5293 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "62c62e53", + "metadata": {}, + "source": [ + "# Parametric shape optimization with differentiable FEM simulation\n", + "\n", + "## Introduction\n", + "\n", + "In this notebook, we explore the optimization of a parametric structure made of a linear elastic material.\n", + "\n", + "We denote the design space as a function $g$ that maps the design variables to a signed distance field. Then, we can then define the density field $\\rho(\\mathbf{x})$ as a function of a signed distance field (SDF) value $g(\\mathbf{x})$. For adaptive meshing, we define a sizing field $h(\\mathbf{x})$ as a function of the SDF value as well.\n", + "We introduce an adpative differentiable mesher $m$ that takes the sizing field and returns a hex mesh. Finally we denote the differentiable finite element method (FEM) solver as $f$, which takes the density field and the hex mesh as input and returns the structure's compliance. Therefore, the optimization problem can be formulated as follows:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\min_{\\theta} f(m(g(\\theta)), \\rho(g(\\theta))).\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Here, $\\theta$ is the vector of design variables." + ] + }, + { + "cell_type": "markdown", + "id": "e3e34d41", + "metadata": {}, + "source": [ + "## Setup" + ] + }, + { + "cell_type": "code", + "execution_count": 201, + "id": "5f5b8544", + "metadata": {}, + "outputs": [], + "source": [ + "# Install additional requirements for this notebook\n", + "# %pip install -r requirements.txt -q --isolated" + ] + }, + { + "cell_type": "code", + "execution_count": 202, + "id": "c367fd3b", + "metadata": {}, + "outputs": [], + "source": [ + "# import tesseract_core\n", + "\n", + "# tesseract_core.build_tesseract(\"design_tess\", \"latest\")\n", + "# tesseract_core.build_tesseract(\"fem_tess\", \"latest\")\n", + "# tesseract_core.build_tesseract(\"meshing_tess\", \"latest\")\n", + "# print(\"Tesseract built successfully.\")" + ] + }, + { + "cell_type": "markdown", + "id": "e771cce1", + "metadata": {}, + "source": [ + "## Design Space Tesseract" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "64ebfb56", + "metadata": {}, + "outputs": [], + "source": [ + "import jax\n", + "import jax.numpy as jnp\n", + "import matplotlib.pyplot as plt\n", + "from tesseract_core import Tesseract\n", + "from tesseract_core.runtime.experimental import TesseractReference\n", + "\n", + "from tesseract_jax import apply_tesseract" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "8a407fb1", + "metadata": {}, + "outputs": [], + "source": [ + "# design_tess = Tesseract.from_image(\"design-tube-sdf\")\n", + "# design_tess.serve()\n", + "design_tess = Tesseract.from_tesseract_api(\"sdf_fd_tess/tesseract_api.py\")\n", + "bar_3d_tess = Tesseract.from_tesseract_api(\"bars_3d_tess/tesseract_api.py\")" + ] + }, + { + "cell_type": "markdown", + "id": "bb2d05dd", + "metadata": {}, + "source": [ + "Now we can setup the parameters for the design space and apply the design Tesseract. The Tesseract constructs a 3D geometry using PyVista and computes its signed distance field (SDF)." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "0fdeb653", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "ERROR:2025-11-17 14:53:20,055:jax._src.xla_bridge:473: Jax plugin configuration error: Exception when calling jax_plugins.xla_cuda12.initialize()\n", + "Traceback (most recent call last):\n", + " File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/xla_bridge.py\", line 471, in discover_pjrt_plugins\n", + " plugin_module.initialize()\n", + " ~~~~~~~~~~~~~~~~~~~~~~~~^^\n", + " File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax_plugins/xla_cuda12/__init__.py\", line 328, in initialize\n", + " _check_cuda_versions(raise_on_first_error=True)\n", + " ~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax_plugins/xla_cuda12/__init__.py\", line 285, in _check_cuda_versions\n", + " local_device_count = cuda_versions.cuda_device_count()\n", + "RuntimeError: jaxlib/cuda/versions_helpers.cc:113: operation cuInit(0) failed: CUDA_ERROR_SYSTEM_DRIVER_MISMATCH\n", + "WARNING:2025-11-17 14:53:20,073:jax._src.xla_bridge:850: An NVIDIA GPU may be present on this machine, but a CUDA-enabled jaxlib is not installed. Falling back to cpu.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-10. -2.5 0. -3.3333328 -2.5 0.\n", + " 3.333334 -2.5 0. 10. -2.5 0.\n", + " -10. 0. 0. -3.3333328 0. 0.\n", + " 3.333334 0. 0. 10. 0. 0.\n", + " -10. 2.5 0. -3.3333328 2.5 0.\n", + " 3.333334 2.5 0. 10. 2.5 0. ]\n", + "Number of vertices: 360\n", + "Number of faces: 708\n", + "SDF shape: (200, 100, 100)\n" + ] + } + ], + "source": [ + "n_chains = 3\n", + "n_edges_per_chain = 3\n", + "bar_radius = 0.7\n", + "\n", + "Lx, Ly, Lz = 20.0, 10.0, 10.0\n", + "Nx, Ny, Nz = 200, 100, 100\n", + "\n", + "# Initialize chain parameter array\n", + "initial_params = jnp.zeros((n_chains, n_edges_per_chain + 1, 3), dtype=jnp.float32)\n", + "\n", + "for chain in range(n_chains):\n", + " initial_params = initial_params.at[chain, :, 0].set(\n", + " jnp.linspace(-Lx / 2, Lx / 2, n_edges_per_chain + 1)\n", + " )\n", + "\n", + " initial_params = initial_params.at[chain, :, 1].set(\n", + " (chain + 1) / (n_chains + 1) * Ly - Ly / 2\n", + " )\n", + "\n", + "initial_params = initial_params.flatten()\n", + "\n", + "print(initial_params)\n", + "\n", + "normalization_factors = jnp.ones_like(initial_params, dtype=jnp.float32)\n", + "normalization_bias = jnp.zeros_like(initial_params, dtype=jnp.float32)\n", + "\n", + "\n", + "design_inputs = {\n", + " \"non_differentiable_parameters\": jnp.array([bar_radius], dtype=jnp.float32),\n", + " \"static_parameters\": [n_chains, n_edges_per_chain + 1],\n", + " \"string_parameters\": [],\n", + " \"mesh_tesseract\": TesseractReference(bar_3d_tess),\n", + " \"grid_size\": [Lx, Ly, Lz],\n", + " \"grid_elements\": [Nx, Ny, Nz],\n", + " \"epsilon\": 1e-2, # epsilon, only used for FD of the jacobian\n", + " \"grid_center\": [0.0, 0.0, 0.0],\n", + " \"max_points\": 2000,\n", + " \"max_faces\": 4000,\n", + " \"normalization_factors\": normalization_factors,\n", + " \"normalization_bias\": normalization_bias,\n", + "}\n", + "\n", + "design_out = design_tess.apply(\n", + " {\n", + " \"differentiable_parameters\": initial_params,\n", + " **design_inputs,\n", + " }\n", + ")\n", + "sdf = design_out[\"sdf\"]\n", + "surface_mesh = design_out[\"mesh\"]\n", + "\n", + "num_vertices = surface_mesh[\"n_points\"]\n", + "num_faces = surface_mesh[\"n_faces\"]\n", + "\n", + "print(f\"Number of vertices: {num_vertices}\")\n", + "print(f\"Number of faces: {num_faces}\")\n", + "\n", + "points = surface_mesh[\"points\"][:num_vertices]\n", + "faces = surface_mesh[\"faces\"][:num_faces]\n", + "\n", + "mesh = {\n", + " \"points\": points,\n", + " \"faces\": faces,\n", + "}\n", + "\n", + "print(\"SDF shape:\", sdf.shape)" + ] + }, + { + "cell_type": "markdown", + "id": "ad5503fb", + "metadata": {}, + "source": [ + "To better understand what's going on, let's import some internal functions from the design Tesseract, and visualize the structure and its SDF field." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "760cf3ee", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def plot_mesh(mesh: dict, save_path: str | None = None) -> None:\n", + " \"\"\"Plot a 3D triangular mesh with boundary conditions visualization.\n", + "\n", + " Args:\n", + " mesh: Dictionary containing 'points' and 'faces' arrays.\n", + " save_path: Optional path to save the plot as an image file.\n", + " \"\"\"\n", + " fig = plt.figure(figsize=(10, 8))\n", + " ax = fig.add_subplot(111, projection=\"3d\")\n", + " ax.plot_trisurf(\n", + " mesh[\"points\"][:, 0],\n", + " mesh[\"points\"][:, 1],\n", + " mesh[\"points\"][:, 2],\n", + " triangles=mesh[\"faces\"],\n", + " alpha=0.7,\n", + " antialiased=True,\n", + " color=\"lightblue\",\n", + " edgecolor=\"black\",\n", + " )\n", + "\n", + " # plane on x=0 to visualize dirichlet boundary\n", + " yy, zz = jnp.meshgrid(\n", + " jnp.linspace(-Ly / 2, Ly / 2, 10), jnp.linspace(-Ly / 2, Ly / 2, 10)\n", + " )\n", + " xx = -jnp.ones_like(yy) * Lx / 2\n", + " ax.plot_surface(xx, yy, zz, alpha=0.4, color=\"green\")\n", + "\n", + " ax.set_xlim(-Lx / 2, Lx / 2)\n", + " ax.set_ylim(-Ly / 2, Ly / 2)\n", + " ax.set_zlim(-Lz / 2, Lz / 2)\n", + "\n", + " # x axis label\n", + " ax.set_xlabel(\"X\")\n", + " ax.set_ylabel(\"Y\")\n", + " ax.set_zlabel(\"Z\")\n", + "\n", + " # green arrow on bottom right to indicate force direction\n", + " ax.quiver(\n", + " Lx / 2,\n", + " 0,\n", + " -Lz / 2,\n", + " 0,\n", + " 0,\n", + " 1,\n", + " length=1.0,\n", + " color=\"green\",\n", + " arrow_length_ratio=0.3,\n", + " )\n", + "\n", + " if save_path:\n", + " # avoid showing the plot in notebook\n", + " plt.savefig(save_path)\n", + " plt.close(fig)\n", + "\n", + "\n", + "plot_mesh(mesh)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "85a4ee0e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from mpl_toolkits.axes_grid1 import make_axes_locatable\n", + "\n", + "\n", + "def plot_grid_slice(field_slice, extent, ax, title, xlabel, ylabel):\n", + " im = ax.imshow(field_slice.T, extent=extent, origin=\"lower\")\n", + " ax.set_title(title)\n", + " ax.set_xlabel(xlabel)\n", + " ax.set_ylabel(ylabel)\n", + " # add colorbar\n", + " divider = make_axes_locatable(ax)\n", + " cax = divider.append_axes(\"right\", size=\"5%\", pad=0.1)\n", + " plt.colorbar(im, cax=cax, orientation=\"vertical\")\n", + " return im\n", + "\n", + "\n", + "def plot_grid(field, Lx, Ly, Lz, Nx, Ny, Nz):\n", + " _, axs = plt.subplots(1, 3, figsize=(15, 5))\n", + "\n", + " plot_grid_slice(\n", + " field[Nx // 2, :, :],\n", + " extent=(-Ly / 2, Ly / 2, -Lz / 2, Lz / 2),\n", + " ax=axs[0],\n", + " title=\"SDF slice at x=0\",\n", + " xlabel=\"y\",\n", + " ylabel=\"z\",\n", + " )\n", + " plot_grid_slice(\n", + " field[:, Ny // 2, :],\n", + " extent=(-Lx / 2, Lx / 2, -Lz / 2, Lz / 2),\n", + " ax=axs[1],\n", + " title=\"SDF slice at y=0\",\n", + " xlabel=\"x\",\n", + " ylabel=\"z\",\n", + " )\n", + " plot_grid_slice(\n", + " field[:, :, Nz // 2],\n", + " extent=(-Lx / 2, Lx / 2, -Ly / 2, Ly / 2),\n", + " ax=axs[2],\n", + " title=\"SDF slice at z=0\",\n", + " xlabel=\"x\",\n", + " ylabel=\"y\",\n", + " )\n", + "\n", + "\n", + "plot_grid(sdf, Lx, Ly, Lz, Nx, Ny, Nz)" + ] + }, + { + "cell_type": "markdown", + "id": "c03f1667", + "metadata": {}, + "source": [ + "Lets test the gradient of the design Tesseract" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "7d008a70", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Computing Jacobian...\n", + "Gradient shape: (36,)\n" + ] + } + ], + "source": [ + "primal, vjp_fun = jax.vjp(\n", + " lambda params: apply_tesseract(\n", + " design_tess,\n", + " {\n", + " \"differentiable_parameters\": params.flatten(),\n", + " **design_inputs,\n", + " },\n", + " )[\"sdf\"],\n", + " initial_params,\n", + ")\n", + "\n", + "grad = vjp_fun(jax.numpy.ones((Nx, Ny, Nz), dtype=jax.numpy.float32))[0]\n", + "\n", + "print(\"Gradient shape:\", grad.shape)" + ] + }, + { + "cell_type": "markdown", + "id": "3c307b15", + "metadata": {}, + "source": [ + "And figure out an approate epsilon for finite difference based Jacobian computation." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "c781713f", + "metadata": {}, + "outputs": [], + "source": [ + "# # Lets figure out a good epsilon value for FD jacobian computation\n", + "# epsilons = jnp.logspace(-6, 0, 6)\n", + "# mean_grads = []\n", + "# std_grads = []\n", + "\n", + "# for i in range(len(epsilons)):\n", + "# eps = epsilons[i]\n", + "# primal, vjp_fun = jax.vjp(\n", + "# lambda params, eps=eps: apply_tesseract(\n", + "# design_tess,\n", + "# {\n", + "# \"differentiable_parameters\": params.flatten(),\n", + "# \"non_differentiable_parameters\": jnp.array(\n", + "# [bar_radius], dtype=jnp.float32\n", + "# ),\n", + "# \"static_parameters\": [n_chains, n_edges_per_chain + 1],\n", + "# \"string_parameters\": [],\n", + "# \"mesh_tesseract\": TesseractReference(bar_3d_tess),\n", + "# \"grid_size\": [Lx, Ly, Lz],\n", + "# \"grid_elements\": [Nx, Ny, Nz],\n", + "# \"grid_center\": [0.0, 0.0, 0.0],\n", + "# \"epsilon\": eps.item(), # epsilon, only used for FD of the jacobian\n", + "# \"normalize_jacobian\": True,\n", + "# },\n", + "# )[\"sdf\"],\n", + "# initial_params,\n", + "# )\n", + "\n", + "# grad = vjp_fun(jnp.ones((Nx, Ny, Nz), dtype=jnp.float32))[0]\n", + "\n", + "# mean_grads.append(jnp.mean(jnp.abs(grad)))\n", + "# std_grads.append(jnp.std(grad))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "db2b5929", + "metadata": {}, + "outputs": [], + "source": [ + "# plt.figure(figsize=(8, 6))\n", + "# plt.plot(epsilons, mean_grads, marker=\"o\")\n", + "# plt.plot(epsilons, std_grads, marker=\"x\")\n", + "# plt.xlabel(\"Epsilon\")\n", + "# plt.xscale(\"log\")\n", + "# plt.yscale(\"log\")\n", + "# plt.ylabel(\"Mean Absolute Gradient\")\n", + "# plt.title(\"Effect of Epsilon on Gradient Magnitude\")\n", + "# plt.grid(True)\n", + "# plt.legend([\"Mean Gradient\", \"Std Dev of Gradient\"])" + ] + }, + { + "cell_type": "markdown", + "id": "6a23263e", + "metadata": {}, + "source": [ + "## Density and Sizing Field" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "798defb2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "rho min: 6.239625508897007e-05, rho max: 0.7989268898963928\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def sdf_to_rho(\n", + " sdf: jnp.ndarray, scale: float = 2.0, offset: float = 0.1\n", + ") -> jnp.ndarray:\n", + " \"\"\"Convert signed distance function to material density using sigmoid.\n", + "\n", + " Args:\n", + " sdf: Signed distance function values.\n", + " scale: Sigmoid steepness (higher = sharper transition).\n", + " offset: SDF value where density = 0.5.\n", + "\n", + " Returns:\n", + " Material density field in [0,1].\n", + " \"\"\"\n", + " return 1 / (1 + jnp.exp(scale * sdf - offset))\n", + "\n", + "\n", + "rho = sdf_to_rho(sdf, scale=2)\n", + "\n", + "plot_grid(rho, Lx, Ly, Lz, Nx, Ny, Nz)\n", + "print(f\"rho min: {jnp.min(rho)}, rho max: {jnp.max(rho)}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "0d271c6c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sizing field min: 0.625, max: 2.499988079071045\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def sizing_field(\n", + " sdf: jnp.ndarray, min_size: float = 0.1, max_size: float = 1.0, scale: float = 2.0\n", + ") -> jnp.ndarray:\n", + " \"\"\"Generate a sizing field from the signed distance function.\n", + "\n", + " The field is low (size = min_size) near the structure (sdf=0) and high (size = max_size) far from it.\n", + "\n", + " Args:\n", + " sdf: Signed distance function values.\n", + " min_size: Minimum element size near the structure.\n", + " max_size: Maximum element size far from the structure.\n", + " scale: Controls the transition steepness.\n", + "\n", + " Returns:\n", + " Sizing field values.\n", + " \"\"\"\n", + "\n", + " def gauss(x: jnp.ndarray, mu: float, sigma: float) -> jnp.ndarray:\n", + " return jnp.exp(-0.5 * ((x - mu) / sigma) ** 2)\n", + "\n", + " normalized_sdf = 1 - gauss(sdf, 0.0, 1.0 / scale)\n", + " return min_size + (max_size - min_size) * normalized_sdf\n", + "\n", + "\n", + "sizing = sizing_field(sdf, min_size=Lx / 32, max_size=Lx / 8, scale=1.0)\n", + "plot_grid(sizing, Lx, Ly, Lz, Nx, Ny, Nz)\n", + "print(f\"Sizing field min: {sizing.min()}, max: {sizing.max()}\")" + ] + }, + { + "cell_type": "markdown", + "id": "ea9c3450", + "metadata": {}, + "source": [ + "## Adpative Hex Meshing Tesseract" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "44a48a0c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mesh points: 5201, Mesh faces: 4160\n" + ] + } + ], + "source": [ + "mesher = Tesseract.from_tesseract_api(\"meshing_tess/tesseract_api.py\")\n", + "\n", + "mesher_out = apply_tesseract(\n", + " mesher,\n", + " {\n", + " \"domain_size\": [Lx, Ly, Lz],\n", + " \"sizing_field\": sizing, # jnp.ones_like(sdf) * (Lx / 10),\n", + " # \"sizing_field\": jnp.ones_like(sdf) * (Lx / 10),\n", + " \"field_values\": rho,\n", + " \"max_subdivision_levels\": 5,\n", + " \"max_points\": 7000,\n", + " \"max_cells\": 7000,\n", + " },\n", + ")\n", + "print(\n", + " f\"Mesh points: {mesher_out['mesh']['n_points']}, Mesh faces: {mesher_out['mesh']['n_faces']}\"\n", + ")\n", + "pts = mesher_out[\"mesh\"][\"points\"][: mesher_out[\"mesh\"][\"n_points\"]]\n", + "hex_cells = mesher_out[\"mesh\"][\"faces\"][: mesher_out[\"mesh\"][\"n_faces\"]]\n", + "\n", + "adaptive_mesh = mesher_out[\"mesh\"]" + ] + }, + { + "cell_type": "markdown", + "id": "af4b280f", + "metadata": {}, + "source": [ + "Lets check the gradient of the meshing Tesseract" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "26b3ac20", + "metadata": {}, + "outputs": [], + "source": [ + "# max_points = 5000\n", + "# max_cells = 5000\n", + "\n", + "# primal, vjp_fun = jax.vjp(\n", + "# lambda rho: apply_tesseract(\n", + "# mesher,\n", + "# {\n", + "# \"domain_size\": [Lx, Ly, Lz],\n", + "# \"sizing_field\": sizing, # jnp.ones_like(sdf) * (Lx / 10),\n", + "# \"field_values\": rho,\n", + "# \"max_subdivision_levels\": 4,\n", + "# \"max_points\": max_points,\n", + "# \"max_cells\": max_cells,\n", + "# },\n", + "# )[\"mesh_cell_values\"],\n", + "# rho,\n", + "# )\n", + "\n", + "# grad = vjp_fun(jax.numpy.ones((max_cells), dtype=jax.numpy.float32) * 0.5)[0]\n", + "\n", + "# print(\"Gradient shape:\", grad.shape)\n", + "# print(f\"Max grad: {jnp.max(grad)}, Min grad: {jnp.min(grad)}\")" + ] + }, + { + "cell_type": "markdown", + "id": "ea467c93", + "metadata": {}, + "source": [ + "Lets examine the produced mesh by exporting it to a VTK file and visualizing it in Paraview." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "692f2b4f", + "metadata": {}, + "outputs": [], + "source": [ + "# # Lets export it to a .vtk using pyvista\n", + "# import pyvista as pv\n", + "\n", + "\n", + "# def hex_to_pyvista(pts: np.ndarray, faces: np.ndarray) -> pv.UnstructuredGrid:\n", + "# \"\"\"Convert hex mesh defined by points and faces into a PyVista UnstructuredGrid.\n", + "\n", + "# Args:\n", + "# pts: Array of point coordinates, shape (N, 3).\n", + "# faces: Array of hexahedral cell connectivity, shape (M, 8).\n", + "\n", + "# Returns:\n", + "# PyVista mesh representing the hexahedral grid.\n", + "# \"\"\"\n", + "# # Define the cell type for hexahedrons (VTK_HEXAHEDRON = 12)\n", + "# cell_type = pv.CellType.HEXAHEDRON\n", + "# cell_types = np.array([cell_type] * faces.shape[0], dtype=np.uint8)\n", + "\n", + "# # Prepare the cells array: [number_of_points, i0, i1, i2, i3, i4, i5, i6, i7]\n", + "# n_cells = faces.shape[0]\n", + "# cells = np.empty((n_cells, 9), dtype=np.int64)\n", + "# cells[:, 0] = 8 # Each cell has 8 points\n", + "# cells[:, 1:9] = faces\n", + "\n", + "# # Flatten the cells array for PyVista\n", + "# cells = cells.flatten()\n", + "\n", + "# return pv.UnstructuredGrid(cells, cell_types, pts)\n", + "\n", + "\n", + "# # convert arrays to numpy\n", + "# pts_np = np.array(adaptive_mesh[\"points\"])\n", + "# cells_np = np.array(adaptive_mesh[\"faces\"])\n", + "\n", + "# hex_mesh = hex_to_pyvista(pts_np, cells_np)\n", + "\n", + "# print(hex_mesh)\n", + "\n", + "# hex_mesh.save(\"fem_shapeopt_mesh.vtk\")" + ] + }, + { + "cell_type": "markdown", + "id": "2ad04a2f", + "metadata": {}, + "source": [ + "## Boundary Conditions" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "9ea51a40", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Lets setup the boundary conditions\n", + "\n", + "\n", + "def get_boundary_masks(mesh: dict, Lx: float, Lz: float):\n", + " \"\"\"Get boundary condition masks for the adaptive mesh.\n", + "\n", + " Args:\n", + " mesh: Dictionary containing 'points' array.\n", + " Lx: Size of the domain in x-direction.\n", + " Lz: Size of the domain in z-direction.\n", + "\n", + " Returns:\n", + " dirichlet_mask: Boolean array for Dirichlet boundary condition.\n", + " van_neumann_mask: Boolean array for Van Neumann boundary condition.\n", + " \"\"\"\n", + " pts = mesh[\"points\"]\n", + "\n", + " dirichlet_mask = pts[:, 0] <= -Lx / 2 + 1e-5\n", + " van_neumann_mask = jnp.logical_and(\n", + " jnp.isclose(pts[:, 0], Lx / 2, atol=Lz / 6),\n", + " jnp.isclose(pts[:, 2], -Lz / 2, atol=Lz / 6),\n", + " )\n", + "\n", + " return dirichlet_mask, van_neumann_mask\n", + "\n", + "\n", + "dirichlet_mask, van_neumann_mask = get_boundary_masks(adaptive_mesh, Lx, Lz)\n", + "\n", + "fig, axs = plt.subplots(1, 2, subplot_kw={\"projection\": \"3d\"}, figsize=(12, 6))\n", + "# set the colormap to Set1\n", + "plt.suptitle(\"Boundary Conditions\")\n", + "# remove the axis ticks\n", + "colors = jnp.where(dirichlet_mask[: adaptive_mesh[\"n_points\"]], 0.1, 0.2)\n", + "\n", + "pts = adaptive_mesh[\"points\"][: adaptive_mesh[\"n_points\"]]\n", + "\n", + "axs[0].scatter(\n", + " pts[:, 0],\n", + " pts[:, 1],\n", + " pts[:, 2],\n", + " c=jnp.where(dirichlet_mask[: adaptive_mesh[\"n_points\"]], 0.1, 0.2),\n", + " s=10,\n", + " alpha=1.0,\n", + " cmap=\"Set1\",\n", + ")\n", + "axs[0].set_title(\"Dirichlet Boundary (x = -Lx/2)\")\n", + "\n", + "axs[1].scatter(\n", + " pts[:, 0],\n", + " pts[:, 1],\n", + " pts[:, 2],\n", + " c=jnp.where(van_neumann_mask[: adaptive_mesh[\"n_points\"]], 0.1, 0.2),\n", + " s=10,\n", + " alpha=1.0,\n", + " cmap=\"Set1\",\n", + ")\n", + "axs[1].set_title(\"Van Neumann Boundary (x = Lx/2)\")\n", + "\n", + "# convert to int arrays for tesseract input\n", + "dirichlet_mask = dirichlet_mask.astype(jnp.int32)\n", + "van_neumann_mask = van_neumann_mask.astype(jnp.int32)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "b4aea57f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " __ ___ ___ ___ _______ _______ .___ ___. \n", + " | | / \\ \\ \\ / / | ____|| ____|| \\/ | \n", + " | | / ^ \\ \\ V / ______ | |__ | |__ | \\ / | \n", + ".--. | | / /_\\ \\ > < |______| | __| | __| | |\\/| | \n", + "| `--' | / _____ \\ / . \\ | | | |____ | | | | \n", + " \\______/ /__/ \\__\\ /__/ \\__\\ |__| |_______||__| |__| \n", + " \n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-17 14:53:47][INFO] jax_fem: pyamgx not installed. AMGX solver disabled.\n" + ] + } + ], + "source": [ + "# fem_tess = Tesseract.from_image(\"structure-jax-fem\")\n", + "# fem_tess.serve()\n", + "\n", + "fem_tess = Tesseract.from_tesseract_api(\"fem_tess/tesseract_api.py\")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "28ba72f2", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-17 14:53:48][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-17 14:53:48][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-17 14:53:48][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-17 14:53:49][DEBUG] jax_fem: Done pre-computations, took 1.4070985317230225 [s]\n", + "[11-17 14:53:49][INFO] jax_fem: Solving a problem with 4160 cells, 5201x3 = 15603 dofs.\n", + "[11-17 14:53:49][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-17 14:53:50][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-17 14:53:50][DEBUG] jax_fem: Start timing\n", + "[11-17 14:53:51][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-17 14:53:51][DEBUG] jax_fem: Function split_and_compute_cell took 0.2803 seconds\n", + "[11-17 14:53:52][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-17 14:53:52][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-17 14:53:52][DEBUG] jax_fem: Solving linear system...\n", + "[11-17 14:53:52][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-17 14:54:00][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 3.409329576844143e-09\n", + "[11-17 14:54:00][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-17 14:54:00][DEBUG] jax_fem: Function split_and_compute_cell took 0.0428 seconds\n", + "[11-17 14:54:00][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-17 14:54:01][DEBUG] jax_fem: l_2 res = 3.409319835425802e-09, relative l_2 res = 1.9614403960638103e-11\n", + "[11-17 14:54:01][INFO] jax_fem: Solve took 10.174116373062134 [s]\n", + "[11-17 14:54:01][INFO] jax_fem: max of dofs = 8.514672626427979\n", + "[11-17 14:54:01][INFO] jax_fem: min of dofs = -29.57627341066549\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Compliance: 27264.8770\n" + ] + } + ], + "source": [ + "compliance = apply_tesseract(\n", + " fem_tess,\n", + " {\n", + " \"rho\": jnp.expand_dims(mesher_out[\"mesh_cell_values\"], axis=-1),\n", + " \"hex_mesh\": adaptive_mesh,\n", + " \"dirichlet_mask\": dirichlet_mask,\n", + " \"dirichlet_values\": jnp.array([0.0]),\n", + " \"van_neumann_mask\": van_neumann_mask,\n", + " \"van_neumann_values\": jnp.array([[0.0, 0.0, 10.0]]),\n", + " },\n", + ")[\"compliance\"]\n", + "print(f\"Compliance: {compliance:.4f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "a5955e0a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# lets make a scatter plot of the mesh cell values as colors\n", + "fig, ax = plt.subplots(1, 1, figsize=(8, 6), subplot_kw={\"projection\": \"3d\"})\n", + "pts_coords = mesher_out[\"mesh\"][\"points\"][: mesher_out[\"mesh\"][\"n_points\"]]\n", + "hex_cells = mesher_out[\"mesh\"][\"faces\"][: mesher_out[\"mesh\"][\"n_faces\"]]\n", + "center_points = jnp.mean(pts_coords[hex_cells], axis=1)\n", + "rho_mesh = mesher_out[\"mesh_cell_values\"][: mesher_out[\"mesh\"][\"n_faces\"]]\n", + "scat = ax.scatter(\n", + " center_points[:, 0],\n", + " center_points[:, 1],\n", + " center_points[:, 2],\n", + " c=rho_mesh,\n", + " s=20,\n", + " # alpha=rho+0.3,\n", + " alpha=0.5,\n", + " cmap=\"viridis\",\n", + ")\n", + "# colorbar\n", + "cbar = plt.colorbar(scat, ax=ax, pad=0.1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f4247b2a", + "metadata": {}, + "outputs": [], + "source": [ + "from typing import TypeVar\n", + "\n", + "T = TypeVar(\"T\")\n", + "\n", + "\n", + "def stop_grads_int(x: T) -> T:\n", + " \"\"\"Stops gradient computation.\n", + "\n", + " We cannot use jax.lax.stop_gradient directly because Tesseract meshes are\n", + " nested dictionaries with arrays and integers, and jax.lax.stop_gradient\n", + " does not support integers.\n", + "\n", + " Args:\n", + " x: Input value.\n", + "\n", + " Returns:\n", + " Value with stopped gradients.\n", + " \"\"\"\n", + "\n", + " def stop(x):\n", + " return jax._src.ad_util.stop_gradient_p.bind(x)\n", + "\n", + " return jax.tree_util.tree_map(stop, x)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4bbe1040", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-08 12:21:08][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:21:08][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:21:08][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-08 12:21:09][DEBUG] jax_fem: Done pre-computations, took 0.6961874961853027 [s]\n", + "[11-08 12:21:09][INFO] jax_fem: Solving a problem with 4160 cells, 5201x3 = 15603 dofs.\n", + "[11-08 12:21:09][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:21:09][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:21:09][DEBUG] jax_fem: Start timing\n", + "[11-08 12:21:09][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:21:09][DEBUG] jax_fem: Function split_and_compute_cell took 0.2093 seconds\n", + "[11-08 12:21:09][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:21:09][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:21:09][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:21:09][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:21:16][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 3.264575616719758e-09\n", + "[11-08 12:21:16][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:21:17][DEBUG] jax_fem: Function split_and_compute_cell took 0.0508 seconds\n", + "[11-08 12:21:17][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:21:17][DEBUG] jax_fem: l_2 res = 3.272919265847397e-09, relative l_2 res = 1.8829668001174264e-11\n", + "[11-08 12:21:17][INFO] jax_fem: Solve took 8.012604475021362 [s]\n", + "[11-08 12:21:17][INFO] jax_fem: max of dofs = 8.51467338026988\n", + "[11-08 12:21:17][INFO] jax_fem: min of dofs = -29.576276078505884\n", + "[11-08 12:21:17][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:21:17][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:21:17][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:21:18][DEBUG] jax_fem: Done pre-computations, took 1.637765884399414 [s]\n", + "[11-08 12:21:18][INFO] jax_fem: Solving a problem with 4160 cells, 5201x3 = 15603 dofs.\n", + "[11-08 12:21:18][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:21:20][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:21:20][DEBUG] jax_fem: Start timing\n", + "[11-08 12:21:20][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:21:20][DEBUG] jax_fem: Function split_and_compute_cell took 0.3202 seconds\n", + "[11-08 12:21:22][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:21:22][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:21:22][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:21:22][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:21:29][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 3.264575616719758e-09\n", + "[11-08 12:21:29][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:21:29][DEBUG] jax_fem: Function split_and_compute_cell took 0.0405 seconds\n", + "[11-08 12:21:29][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:21:29][DEBUG] jax_fem: l_2 res = 3.272919265847397e-09, relative l_2 res = 1.8829668001174264e-11\n", + "[11-08 12:21:29][INFO] jax_fem: Solve took 9.561524868011475 [s]\n", + "[11-08 12:21:30][INFO] jax_fem: max of dofs = 8.51467338026988\n", + "[11-08 12:21:30][INFO] jax_fem: min of dofs = -29.576276078505884\n", + "[11-08 12:21:30][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-08 12:21:30][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:21:30][DEBUG] jax_fem: Function split_and_compute_cell took 0.0410 seconds\n", + "[11-08 12:21:30][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:21:30][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:21:38][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 9.12233207137359e-08\n", + "[11-08 12:21:39][DEBUG] jax_fem: Computing cell residual...\n", + "[11-08 12:21:39][DEBUG] jax_fem: Function split_and_compute_cell took 0.2990 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Grad shape: (7000, 1)\n" + ] + } + ], + "source": [ + "# # get the gradient of the loss w.r.t. rho\n", + "# grad_loss = jax.grad(loss)\n", + "# grad = grad_loss(\n", + "# jnp.expand_dims(mesher_out[\"mesh_cell_values\"], axis=-1), adaptive_mesh\n", + "# )\n", + "# print(\"Grad shape:\", grad.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 221, + "id": "7ee399e9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Voxel center points shape: (4160, 3)\n", + "4160\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 221, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# print a 3D point cloud of the gradient field\n", + "fig, ax = plt.subplots(1, 1, subplot_kw={\"projection\": \"3d\"}, figsize=(8, 8))\n", + "pts_coords = mesher_out[\"mesh\"][\"points\"][: mesher_out[\"mesh\"][\"n_points\"]]\n", + "hex_cells = mesher_out[\"mesh\"][\"faces\"][: mesher_out[\"mesh\"][\"n_faces\"]]\n", + "voxel_center_points = jnp.mean(pts_coords[hex_cells], axis=1)\n", + "print(\"Voxel center points shape:\", voxel_center_points.shape)\n", + "print(mesher_out[\"mesh\"][\"n_faces\"])\n", + "sc = ax.scatter(\n", + " voxel_center_points[:, 0],\n", + " voxel_center_points[:, 1],\n", + " voxel_center_points[:, 2],\n", + " c=grad[: mesher_out[\"mesh\"][\"n_faces\"], 0],\n", + " cmap=\"viridis\",\n", + " alpha=1.0,\n", + ")\n", + "# lets add a colorbar\n", + "plt.colorbar(sc, ax=ax, label=\"Gradient of Compliance w.r.t. rho\")" + ] + }, + { + "cell_type": "code", + "execution_count": 222, + "id": "c33ef4c0", + "metadata": {}, + "outputs": [], + "source": [ + "max_points = 9000\n", + "max_cells = 9000\n", + "\n", + "\n", + "def loss(\n", + " rho: jnp.ndarray,\n", + ") -> float:\n", + " \"\"\"Compute structural compliance for given bar parameters.\n", + "\n", + " Args:\n", + " rho: Bar parameter array with shape (n_chains, n_nodes, 3).\n", + "\n", + " Returns:\n", + " Structural compliance (scalar). Lower values indicate better performance.\n", + " \"\"\"\n", + " sizing = sizing_field(sdf, min_size=Lx / 32, max_size=Lx / 8, scale=1.0)\n", + "\n", + " sizing = jax.lax.stop_gradient(sizing)\n", + "\n", + " mesher_out = apply_tesseract(\n", + " mesher,\n", + " {\n", + " \"domain_size\": [Lx, Ly, Lz],\n", + " \"sizing_field\": sizing, # jnp.ones_like(sdf) * (Lx / 10),\n", + " \"field_values\": rho,\n", + " \"max_subdivision_levels\": 5,\n", + " \"max_points\": max_points,\n", + " \"max_cells\": max_cells,\n", + " },\n", + " )\n", + "\n", + " mesh = stop_grads_int(mesher_out[\"mesh\"])\n", + "\n", + " dirichlet_mask, van_neumann_mask = get_boundary_masks(mesh, Lx, Lz)\n", + "\n", + " van_neumann_mask = jax.lax.stop_gradient(van_neumann_mask)\n", + " dirichlet_mask = jax.lax.stop_gradient(dirichlet_mask)\n", + " dirichlet_values = jnp.array([0.0])\n", + " van_neumann_values = jnp.array([[0.0, 0.0, 10.0]])\n", + "\n", + " # Instead of passing all inputs and trying to stop_gradient on them,\n", + " # we need to wrap the tesseract call to only allow gradients w.r.t. rho\n", + " c = apply_tesseract(\n", + " fem_tess,\n", + " {\n", + " \"rho\": jnp.expand_dims(mesher_out[\"mesh_cell_values\"], axis=-1),\n", + " \"hex_mesh\": mesh,\n", + " \"dirichlet_mask\": dirichlet_mask,\n", + " \"dirichlet_values\": dirichlet_values,\n", + " \"van_neumann_mask\": van_neumann_mask,\n", + " \"van_neumann_values\": van_neumann_values,\n", + " },\n", + " )[\"compliance\"]\n", + "\n", + " return c" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "66e4c3bc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(200, 100, 100)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-08 12:21:41][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:21:41][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:21:41][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:21:42][DEBUG] jax_fem: Done pre-computations, took 0.7540175914764404 [s]\n", + "[11-08 12:21:42][INFO] jax_fem: Solving a problem with 4160 cells, 5201x3 = 15603 dofs.\n", + "[11-08 12:21:42][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:21:42][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:21:42][DEBUG] jax_fem: Start timing\n", + "[11-08 12:21:42][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:21:43][DEBUG] jax_fem: Function split_and_compute_cell took 0.2220 seconds\n", + "[11-08 12:21:43][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:21:43][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:21:43][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:21:43][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:21:51][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 3.264575616719758e-09\n", + "[11-08 12:21:51][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:21:51][DEBUG] jax_fem: Function split_and_compute_cell took 0.0509 seconds\n", + "[11-08 12:21:51][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:21:51][DEBUG] jax_fem: l_2 res = 3.272919265847397e-09, relative l_2 res = 1.8829668001174264e-11\n", + "[11-08 12:21:51][INFO] jax_fem: Solve took 8.511950731277466 [s]\n", + "[11-08 12:21:51][INFO] jax_fem: max of dofs = 8.51467338026988\n", + "[11-08 12:21:51][INFO] jax_fem: min of dofs = -29.576276078505884\n", + "[11-08 12:21:51][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:21:51][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:21:51][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:21:52][DEBUG] jax_fem: Done pre-computations, took 0.7568955421447754 [s]\n", + "[11-08 12:21:52][INFO] jax_fem: Solving a problem with 4160 cells, 5201x3 = 15603 dofs.\n", + "[11-08 12:21:52][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:21:52][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:21:52][DEBUG] jax_fem: Start timing\n", + "[11-08 12:21:52][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:21:52][DEBUG] jax_fem: Function split_and_compute_cell took 0.2112 seconds\n", + "[11-08 12:21:52][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:21:52][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:21:52][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:21:52][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:22:00][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 3.264575616719758e-09\n", + "[11-08 12:22:00][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:22:00][DEBUG] jax_fem: Function split_and_compute_cell took 0.0421 seconds\n", + "[11-08 12:22:00][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:22:00][DEBUG] jax_fem: l_2 res = 3.272919265847397e-09, relative l_2 res = 1.8829668001174264e-11\n", + "[11-08 12:22:00][INFO] jax_fem: Solve took 8.42286491394043 [s]\n", + "[11-08 12:22:00][INFO] jax_fem: max of dofs = 8.51467338026988\n", + "[11-08 12:22:00][INFO] jax_fem: min of dofs = -29.576276078505884\n", + "[11-08 12:22:00][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-08 12:22:00][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:22:00][DEBUG] jax_fem: Function split_and_compute_cell took 0.0393 seconds\n", + "[11-08 12:22:00][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:22:00][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:22:09][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 9.12233207137359e-08\n", + "[11-08 12:22:09][DEBUG] jax_fem: Computing cell residual...\n", + "[11-08 12:22:09][DEBUG] jax_fem: Function split_and_compute_cell took 0.2075 seconds\n" + ] + } + ], + "source": [ + "# get grads of loss w.r.t. rho\n", + "grad_loss = jax.grad(loss)\n", + "print(rho.shape)\n", + "grad = grad_loss(rho)" + ] + }, + { + "cell_type": "code", + "execution_count": 224, + "id": "5e7e6212", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Grad min: -308.64954 Grad max: -8.065023e-06\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot the grad field\n", + "plot_grid(grad, Lx, Ly, Lz, Nx, Ny, Nz)\n", + "print(\"Grad min:\", jnp.min(grad), \"Grad max:\", jnp.max(grad))" + ] + }, + { + "cell_type": "code", + "execution_count": 225, + "id": "0ddca0dd", + "metadata": {}, + "outputs": [], + "source": [ + "max_points = 9000\n", + "max_cells = 9000\n", + "\n", + "\n", + "def loss(\n", + " params: jnp.ndarray,\n", + ") -> float:\n", + " \"\"\"Compute structural compliance for given bar parameters.\n", + "\n", + " Args:\n", + " params: Bar parameter array with shape (n_chains, n_nodes, 3).\n", + "\n", + " Returns:\n", + " Structural compliance (scalar). Lower values indicate better performance.\n", + " \"\"\"\n", + " # Generate signed distance field from design parameters\n", + " sdf = apply_tesseract(\n", + " design_tess,\n", + " {\n", + " \"differentiable_parameters\": params.flatten(),\n", + " \"non_differentiable_parameters\": jnp.array([bar_radius], dtype=jnp.float32),\n", + " \"static_parameters\": [n_chains, n_edges_per_chain + 1],\n", + " \"string_parameters\": [],\n", + " \"mesh_tesseract\": TesseractReference(bar_3d_tess),\n", + " \"grid_size\": [Lx, Ly, Lz],\n", + " \"grid_elements\": [Nx, Ny, Nz],\n", + " \"grid_center\": [0.0, 0.0, 0.0],\n", + " \"epsilon\": 1e-2, # epsilon, only used for FD of the jacobian\n", + " \"normalize_jacobian\": True,\n", + " },\n", + " )[\"sdf\"]\n", + "\n", + " # Convert SDF to material density distribution\n", + " rho = sdf_to_rho(sdf, scale=2)\n", + "\n", + " sizing = sizing_field(sdf, min_size=Lx / 32, max_size=Lx / 8, scale=1.0)\n", + " sizing = jax.lax.stop_gradient(sizing)\n", + "\n", + " mesher_out = apply_tesseract(\n", + " mesher,\n", + " {\n", + " \"domain_size\": [Lx, Ly, Lz],\n", + " \"sizing_field\": sizing, # jnp.ones_like(sdf) * (Lx / 10),\n", + " \"field_values\": rho,\n", + " \"max_subdivision_levels\": 5,\n", + " \"max_points\": max_points,\n", + " \"max_cells\": max_cells,\n", + " },\n", + " )\n", + "\n", + " mesh = stop_grads_int(mesher_out[\"mesh\"])\n", + "\n", + " dirichlet_mask, van_neumann_mask = get_boundary_masks(mesh, Lx, Lz)\n", + "\n", + " van_neumann_mask = jax.lax.stop_gradient(van_neumann_mask)\n", + " dirichlet_mask = jax.lax.stop_gradient(dirichlet_mask)\n", + " dirichlet_values = jnp.array([0.0])\n", + " van_neumann_values = jnp.array([[0.0, 0.0, Lz]])\n", + "\n", + " # Instead of passing all inputs and trying to stop_gradient on them,\n", + " # we need to wrap the tesseract call to only allow gradients w.r.t. rho\n", + " c = apply_tesseract(\n", + " fem_tess,\n", + " {\n", + " \"rho\": jnp.expand_dims(mesher_out[\"mesh_cell_values\"], axis=-1),\n", + " \"hex_mesh\": mesh,\n", + " \"dirichlet_mask\": dirichlet_mask,\n", + " \"dirichlet_values\": dirichlet_values,\n", + " \"van_neumann_mask\": van_neumann_mask,\n", + " \"van_neumann_values\": van_neumann_values,\n", + " },\n", + " )[\"compliance\"]\n", + "\n", + " return c" + ] + }, + { + "cell_type": "code", + "execution_count": 227, + "id": "39e30381", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-08 12:36:25][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:36:25][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:36:25][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:36:27][DEBUG] jax_fem: Done pre-computations, took 1.554999828338623 [s]\n", + "[11-08 12:36:27][INFO] jax_fem: Solving a problem with 4160 cells, 5201x3 = 15603 dofs.\n", + "[11-08 12:36:27][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:36:29][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:36:29][DEBUG] jax_fem: Start timing\n", + "[11-08 12:36:29][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:36:29][DEBUG] jax_fem: Function split_and_compute_cell took 0.2935 seconds\n", + "[11-08 12:36:30][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:36:30][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:36:30][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:36:30][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:36:38][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 3.264575616719758e-09\n", + "[11-08 12:36:38][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:36:38][DEBUG] jax_fem: Function split_and_compute_cell took 0.0455 seconds\n", + "[11-08 12:36:38][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:36:38][DEBUG] jax_fem: l_2 res = 3.272919265847397e-09, relative l_2 res = 1.8829668001174264e-11\n", + "[11-08 12:36:38][INFO] jax_fem: Solve took 9.720175743103027 [s]\n", + "[11-08 12:36:38][INFO] jax_fem: max of dofs = 8.51467338026988\n", + "[11-08 12:36:38][INFO] jax_fem: min of dofs = -29.576276078505884\n", + "[11-08 12:36:38][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:36:38][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:36:38][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:36:40][DEBUG] jax_fem: Done pre-computations, took 1.681823492050171 [s]\n", + "[11-08 12:36:40][INFO] jax_fem: Solving a problem with 4160 cells, 5201x3 = 15603 dofs.\n", + "[11-08 12:36:40][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:36:42][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:36:42][DEBUG] jax_fem: Start timing\n", + "[11-08 12:36:42][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:36:42][DEBUG] jax_fem: Function split_and_compute_cell took 0.3043 seconds\n", + "[11-08 12:36:43][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:36:44][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:36:44][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:36:44][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:36:51][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 3.264575616719758e-09\n", + "[11-08 12:36:51][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:36:51][DEBUG] jax_fem: Function split_and_compute_cell took 0.0421 seconds\n", + "[11-08 12:36:51][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:36:51][DEBUG] jax_fem: l_2 res = 3.272919265847397e-09, relative l_2 res = 1.8829668001174264e-11\n", + "[11-08 12:36:51][INFO] jax_fem: Solve took 9.679048776626587 [s]\n", + "[11-08 12:36:52][INFO] jax_fem: max of dofs = 8.51467338026988\n", + "[11-08 12:36:52][INFO] jax_fem: min of dofs = -29.576276078505884\n", + "[11-08 12:36:52][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-08 12:36:52][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:36:52][DEBUG] jax_fem: Function split_and_compute_cell took 0.0424 seconds\n", + "[11-08 12:36:52][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:36:52][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:37:00][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 9.12233207137359e-08\n", + "[11-08 12:37:01][DEBUG] jax_fem: Computing cell residual...\n", + "[11-08 12:37:01][DEBUG] jax_fem: Function split_and_compute_cell took 0.3125 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[[ 0.01899523 0.00196882 -0.0089694 ]\n", + " [ 0.01164134 0.02515115 0.00290267]\n", + " [-0.02124063 0.0256153 -0.00640046]\n", + " [ 0.00700069 0.0124695 0.05051221]]\n", + "\n", + " [[ 0.07890753 -0.00422941 -0.03070007]\n", + " [ 0.01189242 0.01156801 -0.00089641]\n", + " [ 0.00400817 0.01009749 0.00434989]\n", + " [ 0.01410518 -0.02055056 0.0237901 ]]\n", + "\n", + " [[ 0.06170753 0.01239049 0.00150104]\n", + " [-0.02841221 -0.00400391 -0.01013712]\n", + " [-0.00622546 0.00723882 0.00670222]\n", + " [ 0.01712167 -0.02102223 0.03451986]]]\n", + "[[[-10. -2.5 0. ]\n", + " [ -3.3333333 -2.5 0. ]\n", + " [ 3.3333333 -2.5 0. ]\n", + " [ 10. -2.5 0. ]]\n", + "\n", + " [[-10. 0. 0. ]\n", + " [ -3.3333333 0. 0. ]\n", + " [ 3.3333333 0. 0. ]\n", + " [ 10. 0. 0. ]]\n", + "\n", + " [[-10. 2.5 0. ]\n", + " [ -3.3333333 2.5 0. ]\n", + " [ 3.3333333 2.5 0. ]\n", + " [ 10. 2.5 0. ]]]\n", + "Iteration 1, Loss: 27264.88\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-08 12:37:17][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:37:17][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:37:17][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:37:18][DEBUG] jax_fem: Done pre-computations, took 0.7009620666503906 [s]\n", + "[11-08 12:37:18][INFO] jax_fem: Solving a problem with 4160 cells, 5201x3 = 15603 dofs.\n", + "[11-08 12:37:18][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:37:18][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:37:18][DEBUG] jax_fem: Start timing\n", + "[11-08 12:37:18][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:37:18][DEBUG] jax_fem: Function split_and_compute_cell took 0.2177 seconds\n", + "[11-08 12:37:18][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:37:19][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:37:19][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:37:19][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:37:26][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 3.074040233579528e-09\n", + "[11-08 12:37:26][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:37:26][DEBUG] jax_fem: Function split_and_compute_cell took 0.0469 seconds\n", + "[11-08 12:37:26][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:37:26][DEBUG] jax_fem: l_2 res = 3.1076084105180677e-09, relative l_2 res = 1.7878606190599632e-11\n", + "[11-08 12:37:26][INFO] jax_fem: Solve took 7.994807243347168 [s]\n", + "[11-08 12:37:26][INFO] jax_fem: max of dofs = 8.446287141432128\n", + "[11-08 12:37:26][INFO] jax_fem: min of dofs = -29.392228896688216\n", + "[11-08 12:37:26][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:37:26][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:37:26][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:37:27][DEBUG] jax_fem: Done pre-computations, took 0.7081711292266846 [s]\n", + "[11-08 12:37:27][INFO] jax_fem: Solving a problem with 4160 cells, 5201x3 = 15603 dofs.\n", + "[11-08 12:37:27][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:37:27][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:37:27][DEBUG] jax_fem: Start timing\n", + "[11-08 12:37:27][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:37:27][DEBUG] jax_fem: Function split_and_compute_cell took 0.2072 seconds\n", + "[11-08 12:37:27][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:37:27][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:37:27][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:37:27][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:37:35][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 3.074040233579528e-09\n", + "[11-08 12:37:35][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:37:35][DEBUG] jax_fem: Function split_and_compute_cell took 0.0427 seconds\n", + "[11-08 12:37:35][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:37:35][DEBUG] jax_fem: l_2 res = 3.1076084105180677e-09, relative l_2 res = 1.7878606190599632e-11\n", + "[11-08 12:37:35][INFO] jax_fem: Solve took 7.906204700469971 [s]\n", + "[11-08 12:37:35][INFO] jax_fem: max of dofs = 8.446287141432128\n", + "[11-08 12:37:35][INFO] jax_fem: min of dofs = -29.392228896688216\n", + "[11-08 12:37:35][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-08 12:37:35][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:37:35][DEBUG] jax_fem: Function split_and_compute_cell took 0.0428 seconds\n", + "[11-08 12:37:35][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:37:35][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:37:43][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 7.855194279748649e-08\n", + "[11-08 12:37:43][DEBUG] jax_fem: Computing cell residual...\n", + "[11-08 12:37:43][DEBUG] jax_fem: Function split_and_compute_cell took 0.2094 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[[ 0.04017434 0.01038555 0.02745632]\n", + " [-0.00155285 0.0233067 0.02943626]\n", + " [ 0.00039035 0.01562764 0.00267481]\n", + " [ 0.00306202 0.01239819 0.03616833]]\n", + "\n", + " [[ 0.05114243 0.00909514 -0.0636365 ]\n", + " [-0.00093578 0.00870469 -0.05789008]\n", + " [-0.00091619 0.00089945 0.00181935]\n", + " [ 0.00275201 0.00050949 0.03281608]]\n", + "\n", + " [[ 0.01749633 -0.01354546 0.02892786]\n", + " [ 0.00136672 -0.00911396 0.0149522 ]\n", + " [ 0.00120515 -0.01834559 0.001857 ]\n", + " [-0.00317813 -0.01285999 0.03756133]]]\n", + "[[[-10. -2.5999994 0.09999989]\n", + " [ -3.3333333 -2.6 -0.09999966]\n", + " [ 3.3333333 -2.6 0.09999985]\n", + " [ 10. -2.6 -0.09999998]]\n", + "\n", + " [[-10. 0.09999977 0.09999998]\n", + " [ -3.3333333 -0.09999992 0.09999888]\n", + " [ 3.3333333 -0.0999999 -0.09999978]\n", + " [ 10. 0.09999996 -0.09999996]]\n", + "\n", + " [[-10. 2.4 -0.09999933]\n", + " [ -3.3333333 2.5999997 0.0999999 ]\n", + " [ 3.3333333 2.4 -0.09999986]\n", + " [ 10. 2.6 -0.09999997]]]\n", + "Iteration 2, Loss: 27113.76\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-08 12:38:01][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:38:01][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:38:01][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:38:02][DEBUG] jax_fem: Done pre-computations, took 1.2866437435150146 [s]\n", + "[11-08 12:38:02][INFO] jax_fem: Solving a problem with 4237 cells, 5290x3 = 15870 dofs.\n", + "[11-08 12:38:02][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:38:04][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:38:04][DEBUG] jax_fem: Start timing\n", + "[11-08 12:38:04][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:38:04][DEBUG] jax_fem: Function split_and_compute_cell took 0.5290 seconds\n", + "[11-08 12:38:05][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:38:05][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:38:05][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:38:05][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:38:13][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 4.208094921551083e-09\n", + "[11-08 12:38:13][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:38:13][DEBUG] jax_fem: Function split_and_compute_cell took 0.0456 seconds\n", + "[11-08 12:38:13][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:38:13][DEBUG] jax_fem: l_2 res = 4.234960306283575e-09, relative l_2 res = 2.4364455731487354e-11\n", + "[11-08 12:38:13][INFO] jax_fem: Solve took 9.600411176681519 [s]\n", + "[11-08 12:38:13][INFO] jax_fem: max of dofs = 8.38304701900947\n", + "[11-08 12:38:13][INFO] jax_fem: min of dofs = -29.345370618898116\n", + "[11-08 12:38:13][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:38:13][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:38:13][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:38:15][DEBUG] jax_fem: Done pre-computations, took 1.4846253395080566 [s]\n", + "[11-08 12:38:15][INFO] jax_fem: Solving a problem with 4237 cells, 5290x3 = 15870 dofs.\n", + "[11-08 12:38:15][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:38:17][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:38:17][DEBUG] jax_fem: Start timing\n", + "[11-08 12:38:17][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:38:17][DEBUG] jax_fem: Function split_and_compute_cell took 0.5664 seconds\n", + "[11-08 12:38:18][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:38:18][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:38:18][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:38:18][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:38:26][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 4.208094921551083e-09\n", + "[11-08 12:38:26][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:38:26][DEBUG] jax_fem: Function split_and_compute_cell took 0.0429 seconds\n", + "[11-08 12:38:26][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:38:26][DEBUG] jax_fem: l_2 res = 4.234960306283575e-09, relative l_2 res = 2.4364455731487354e-11\n", + "[11-08 12:38:27][INFO] jax_fem: Solve took 9.972349166870117 [s]\n", + "[11-08 12:38:27][INFO] jax_fem: max of dofs = 8.38304701900947\n", + "[11-08 12:38:27][INFO] jax_fem: min of dofs = -29.345370618898116\n", + "[11-08 12:38:27][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-08 12:38:27][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:38:27][DEBUG] jax_fem: Function split_and_compute_cell took 0.0429 seconds\n", + "[11-08 12:38:27][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:38:27][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:38:36][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 8.451524902729663e-08\n", + "[11-08 12:38:36][DEBUG] jax_fem: Computing cell residual...\n", + "[11-08 12:38:37][DEBUG] jax_fem: Function split_and_compute_cell took 0.5034 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[[ 5.0624557e-02 1.2588941e-02 6.8030179e-02]\n", + " [-2.7068462e-03 5.9231729e-03 7.1793966e-02]\n", + " [ 7.3624548e-04 5.9944489e-03 5.5818371e-03]\n", + " [ 4.3309419e-03 7.8550614e-03 4.6492293e-02]]\n", + "\n", + " [[ 3.5045587e-02 1.0425949e-02 -1.4694609e-01]\n", + " [-4.0454254e-03 -5.3414786e-03 -1.4356166e-01]\n", + " [-7.5165438e-04 -4.4514981e-04 -8.0125900e-03]\n", + " [ 4.5546432e-05 1.6912824e-03 4.6377737e-02]]\n", + "\n", + " [[ 7.4982853e-03 -9.5857540e-03 7.4533030e-02]\n", + " [ 6.1230623e-04 -6.5251170e-03 6.8083644e-02]\n", + " [ 7.8837347e-04 -6.9759898e-03 1.1566899e-02]\n", + " [-2.9674967e-04 -8.1535028e-03 5.1658574e-02]]]\n", + "[[[-10. -2.6853611 0.05019076]\n", + " [ -3.3333333 -2.699467 -0.18041462]\n", + " [ 3.3333333 -2.6957104 0.13302684]\n", + " [ 10. -2.6997213 -0.19754961]]\n", + "\n", + " [[-10. 0.06086399 0.1958782 ]\n", + " [ -3.3333333 -0.19802925 0.17524211]\n", + " [ 3.3333333 -0.17315383 -0.19029894]\n", + " [ 10. 0.16496855 -0.1993115 ]]\n", + "\n", + " [[-10. 2.409681 -0.17757897]\n", + " [ -3.3333333 2.6948235 0.07604872]\n", + " [ 3.3333333 2.444524 -0.18422687]\n", + " [ 10. 2.6957445 -0.19986741]]]\n", + "Iteration 3, Loss: 26992.93\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-08 12:39:00][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:39:00][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:39:00][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:39:01][DEBUG] jax_fem: Done pre-computations, took 1.5696663856506348 [s]\n", + "[11-08 12:39:01][INFO] jax_fem: Solving a problem with 4307 cells, 5360x3 = 16080 dofs.\n", + "[11-08 12:39:01][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:39:03][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:39:03][DEBUG] jax_fem: Start timing\n", + "[11-08 12:39:03][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:39:04][DEBUG] jax_fem: Function split_and_compute_cell took 0.5659 seconds\n", + "[11-08 12:39:05][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:39:05][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:39:05][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:39:05][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:39:10][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 3.843028304523016e-09\n", + "[11-08 12:39:10][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:39:10][DEBUG] jax_fem: Function split_and_compute_cell took 0.0471 seconds\n", + "[11-08 12:39:10][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:39:11][DEBUG] jax_fem: l_2 res = 3.836037502178199e-09, relative l_2 res = 2.2069384161044302e-11\n", + "[11-08 12:39:11][INFO] jax_fem: Solve took 7.81036114692688 [s]\n", + "[11-08 12:39:11][INFO] jax_fem: max of dofs = 8.242839773588333\n", + "[11-08 12:39:11][INFO] jax_fem: min of dofs = -28.650297886367177\n", + "[11-08 12:39:11][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:39:11][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:39:11][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:39:13][DEBUG] jax_fem: Done pre-computations, took 1.7294156551361084 [s]\n", + "[11-08 12:39:13][INFO] jax_fem: Solving a problem with 4307 cells, 5360x3 = 16080 dofs.\n", + "[11-08 12:39:13][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:39:14][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:39:14][DEBUG] jax_fem: Start timing\n", + "[11-08 12:39:14][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:39:15][DEBUG] jax_fem: Function split_and_compute_cell took 0.5466 seconds\n", + "[11-08 12:39:16][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:39:16][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:39:16][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:39:16][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:39:22][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 3.843028304523016e-09\n", + "[11-08 12:39:22][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:39:22][DEBUG] jax_fem: Function split_and_compute_cell took 0.0420 seconds\n", + "[11-08 12:39:22][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:39:22][DEBUG] jax_fem: l_2 res = 3.836037502178199e-09, relative l_2 res = 2.2069384161044302e-11\n", + "[11-08 12:39:22][INFO] jax_fem: Solve took 7.803634881973267 [s]\n", + "[11-08 12:39:22][INFO] jax_fem: max of dofs = 8.242839773588333\n", + "[11-08 12:39:22][INFO] jax_fem: min of dofs = -28.650297886367177\n", + "[11-08 12:39:22][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-08 12:39:22][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:39:22][DEBUG] jax_fem: Function split_and_compute_cell took 0.0422 seconds\n", + "[11-08 12:39:22][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:39:23][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:39:32][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 9.593336713034826e-08\n", + "[11-08 12:39:32][DEBUG] jax_fem: Computing cell residual...\n", + "[11-08 12:39:32][DEBUG] jax_fem: Function split_and_compute_cell took 0.4842 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[[ 0.05114789 0.01350253 0.10281861]\n", + " [-0.0030652 -0.00371226 0.10993325]\n", + " [ 0.00080191 0.00867939 0.02040817]\n", + " [ 0.00449808 0.00814715 0.05855457]]\n", + "\n", + " [[ 0.0465537 -0.00334076 -0.22970234]\n", + " [-0.00637562 -0.00340137 -0.23017323]\n", + " [-0.00139338 -0.00468162 -0.03025203]\n", + " [ 0.00460197 0.0020474 0.05736996]]\n", + "\n", + " [[ 0.01044198 -0.00033944 0.12607533]\n", + " [ 0.00030434 0.00374517 0.11897764]\n", + " [ 0.00138242 -0.00393916 0.03147897]\n", + " [ 0.00075503 -0.00817031 0.06345124]]]\n", + "[[[-1.0000000e+01 -2.7763433e+00 -2.3306817e-02]\n", + " [-3.3333333e+00 -2.7858570e+00 -2.6278022e-01]\n", + " [ 3.3333333e+00 -2.7805274e+00 1.1299806e-01]\n", + " [ 1.0000000e+01 -2.7958436e+00 -2.9583949e-01]]\n", + "\n", + " [[-1.0000000e+01 -5.8550984e-03 2.8517026e-01]\n", + " [-3.3333333e+00 -2.4691561e-01 2.5586748e-01]\n", + " [ 3.3333333e+00 -2.2670838e-01 -1.7080219e-01]\n", + " [ 1.0000000e+01 2.0967264e-01 -2.9753909e-01]]\n", + "\n", + " [[-1.0000000e+01 2.4457259e+00 -2.5846982e-01]\n", + " [-3.3333333e+00 2.7908051e+00 9.8928809e-03]\n", + " [ 3.3333333e+00 2.4980850e+00 -2.7213788e-01]\n", + " [ 1.0000000e+01 2.7857945e+00 -2.9917920e-01]]]\n", + "Iteration 4, Loss: 26333.82\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-08 12:39:51][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:39:51][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:39:51][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:39:53][DEBUG] jax_fem: Done pre-computations, took 1.5143160820007324 [s]\n", + "[11-08 12:39:53][INFO] jax_fem: Solving a problem with 4237 cells, 5305x3 = 15915 dofs.\n", + "[11-08 12:39:53][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:39:53][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:39:53][DEBUG] jax_fem: Start timing\n", + "[11-08 12:39:53][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:39:53][DEBUG] jax_fem: Function split_and_compute_cell took 0.3546 seconds\n", + "[11-08 12:39:54][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:39:54][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:39:54][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:39:54][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:39:59][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 4.438864910544264e-09\n", + "[11-08 12:39:59][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:39:59][DEBUG] jax_fem: Function split_and_compute_cell took 0.0464 seconds\n", + "[11-08 12:39:59][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:39:59][DEBUG] jax_fem: l_2 res = 4.41722248831745e-09, relative l_2 res = 2.5413041442928325e-11\n", + "[11-08 12:39:59][INFO] jax_fem: Solve took 6.355456352233887 [s]\n", + "[11-08 12:39:59][INFO] jax_fem: max of dofs = 8.077647187623521\n", + "[11-08 12:39:59][INFO] jax_fem: min of dofs = -27.646594279550634\n", + "[11-08 12:39:59][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:39:59][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:39:59][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:40:01][DEBUG] jax_fem: Done pre-computations, took 1.715256690979004 [s]\n", + "[11-08 12:40:01][INFO] jax_fem: Solving a problem with 4237 cells, 5305x3 = 15915 dofs.\n", + "[11-08 12:40:01][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:40:01][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:40:01][DEBUG] jax_fem: Start timing\n", + "[11-08 12:40:01][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:40:02][DEBUG] jax_fem: Function split_and_compute_cell took 0.3594 seconds\n", + "[11-08 12:40:02][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:40:03][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:40:03][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:40:03][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:40:07][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 4.438864910544264e-09\n", + "[11-08 12:40:07][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:40:07][DEBUG] jax_fem: Function split_and_compute_cell took 0.0408 seconds\n", + "[11-08 12:40:07][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:40:07][DEBUG] jax_fem: l_2 res = 4.41722248831745e-09, relative l_2 res = 2.5413041442928325e-11\n", + "[11-08 12:40:08][INFO] jax_fem: Solve took 6.384528398513794 [s]\n", + "[11-08 12:40:08][INFO] jax_fem: max of dofs = 8.077647187623521\n", + "[11-08 12:40:08][INFO] jax_fem: min of dofs = -27.646594279550634\n", + "[11-08 12:40:08][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-08 12:40:08][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:40:08][DEBUG] jax_fem: Function split_and_compute_cell took 0.0418 seconds\n", + "[11-08 12:40:08][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:40:08][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:40:13][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 1.0557089354329544e-07\n", + "[11-08 12:40:13][DEBUG] jax_fem: Computing cell residual...\n", + "[11-08 12:40:14][DEBUG] jax_fem: Function split_and_compute_cell took 0.3304 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[[ 4.4337634e-02 6.3233525e-03 1.3611753e-01]\n", + " [-3.7382091e-03 -6.8176044e-03 1.5443964e-01]\n", + " [ 1.4335224e-03 -6.3586846e-04 3.0766610e-02]\n", + " [ 3.9461427e-03 7.0146117e-03 7.1779296e-02]]\n", + "\n", + " [[ 6.6075973e-02 5.7230322e-03 -2.7618754e-01]\n", + " [-8.2588429e-03 -4.3206420e-03 -2.8410736e-01]\n", + " [-3.4225364e-03 -2.2331434e-03 -5.0323967e-02]\n", + " [ 5.7112090e-03 2.3382108e-03 6.2023725e-02]]\n", + "\n", + " [[ 8.0970144e-03 -9.9208835e-04 1.4919837e-01]\n", + " [-2.2547762e-04 8.6412132e-03 1.4059347e-01]\n", + " [ 1.5003167e-03 4.5208714e-04 3.4453165e-02]\n", + " [ 2.7359182e-03 -8.8130068e-03 6.8823136e-02]]]\n", + "[[[-10. -2.870376 -0.10516566]\n", + " [ -3.3333333 -2.8499134 -0.3486892 ]\n", + " [ 3.3333333 -2.8629375 0.05360659]\n", + " [ 10. -2.8906407 -0.3946661 ]]\n", + "\n", + " [[-10. -0.04598214 0.3744035 ]\n", + " [ -3.3333333 -0.27349147 0.34046328]\n", + " [ 3.3333333 -0.24224328 -0.11101106]\n", + " [ 10. 0.24031264 -0.39555374]]\n", + "\n", + " [[-10. 2.476116 -0.342548 ]\n", + " [ -3.3333333 2.8482797 -0.06725045]\n", + " [ 3.3333333 2.5517657 -0.3534184 ]\n", + " [ 10. 2.873292 -0.3982084 ]]]\n", + "Iteration 5, Loss: 25385.36\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-08 12:40:33][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:40:33][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:40:33][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:40:34][DEBUG] jax_fem: Done pre-computations, took 1.4815270900726318 [s]\n", + "[11-08 12:40:34][INFO] jax_fem: Solving a problem with 4153 cells, 5224x3 = 15672 dofs.\n", + "[11-08 12:40:34][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:40:36][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:40:36][DEBUG] jax_fem: Start timing\n", + "[11-08 12:40:36][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:40:36][DEBUG] jax_fem: Function split_and_compute_cell took 0.5410 seconds\n", + "[11-08 12:40:37][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:40:37][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:40:37][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:40:38][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:40:41][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 3.377527178866896e-09\n", + "[11-08 12:40:41][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:40:41][DEBUG] jax_fem: Function split_and_compute_cell took 0.0475 seconds\n", + "[11-08 12:40:41][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:40:41][DEBUG] jax_fem: l_2 res = 3.307773071932397e-09, relative l_2 res = 1.9030187948001594e-11\n", + "[11-08 12:40:41][INFO] jax_fem: Solve took 5.666187524795532 [s]\n", + "[11-08 12:40:41][INFO] jax_fem: max of dofs = 7.7602421158987145\n", + "[11-08 12:40:41][INFO] jax_fem: min of dofs = -26.34704376873176\n", + "[11-08 12:40:41][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:40:41][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:40:41][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:40:43][DEBUG] jax_fem: Done pre-computations, took 1.6494953632354736 [s]\n", + "[11-08 12:40:43][INFO] jax_fem: Solving a problem with 4153 cells, 5224x3 = 15672 dofs.\n", + "[11-08 12:40:43][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:40:45][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:40:45][DEBUG] jax_fem: Start timing\n", + "[11-08 12:40:45][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:40:46][DEBUG] jax_fem: Function split_and_compute_cell took 0.5522 seconds\n", + "[11-08 12:40:47][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:40:47][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:40:47][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:40:47][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:40:50][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 3.377527178866896e-09\n", + "[11-08 12:40:50][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:40:50][DEBUG] jax_fem: Function split_and_compute_cell took 0.0438 seconds\n", + "[11-08 12:40:50][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:40:51][DEBUG] jax_fem: l_2 res = 3.307773071932397e-09, relative l_2 res = 1.9030187948001594e-11\n", + "[11-08 12:40:51][INFO] jax_fem: Solve took 5.865053415298462 [s]\n", + "[11-08 12:40:51][INFO] jax_fem: max of dofs = 7.7602421158987145\n", + "[11-08 12:40:51][INFO] jax_fem: min of dofs = -26.34704376873176\n", + "[11-08 12:40:51][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-08 12:40:51][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:40:51][DEBUG] jax_fem: Function split_and_compute_cell took 0.0427 seconds\n", + "[11-08 12:40:51][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:40:51][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:40:57][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 5.439328539237515e-08\n", + "[11-08 12:40:57][DEBUG] jax_fem: Computing cell residual...\n", + "[11-08 12:40:58][DEBUG] jax_fem: Function split_and_compute_cell took 0.4986 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[[ 0.03392076 0.00350314 0.16322812]\n", + " [-0.00399422 -0.01529674 0.18192433]\n", + " [ 0.00309062 -0.00651776 0.04196303]\n", + " [ 0.00455538 0.00358057 0.08169352]]\n", + "\n", + " [[ 0.08392046 -0.0100188 -0.3393073 ]\n", + " [-0.00823138 -0.00505803 -0.36186534]\n", + " [-0.00659159 0.00330544 -0.06834441]\n", + " [ 0.01169031 0.00390561 0.06620678]]\n", + "\n", + " [[ 0.0047429 -0.0047627 0.15861525]\n", + " [-0.00091736 0.00932063 0.18032871]\n", + " [ 0.00144123 0.00654629 0.03308798]\n", + " [ 0.00505475 -0.00579607 0.07707576]]]\n", + "[[[-10. -2.9617474 -0.19168371]\n", + " [ -3.3333333 -2.8925745 -0.43695658]\n", + " [ 3.3333333 -2.931315 -0.01947139]\n", + " [ 10. -2.9835837 -0.49374616]]\n", + "\n", + " [[-10. -0.09697458 0.46590132]\n", + " [ -3.3333333 -0.2808408 0.42890036]\n", + " [ 3.3333333 -0.24448968 -0.03848864]\n", + " [ 10. 0.25991645 -0.49408963]]\n", + "\n", + " [[-10. 2.504292 -0.43083414]\n", + " [ -3.3333333 2.8573368 -0.15133189]\n", + " [ 3.3333333 2.5958607 -0.44000292]\n", + " [ 10. 2.960109 -0.4975136 ]]]\n", + "Iteration 6, Loss: 24156.07\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-08 12:41:20][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:41:20][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:41:20][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:41:22][DEBUG] jax_fem: Done pre-computations, took 1.5037178993225098 [s]\n", + "[11-08 12:41:22][INFO] jax_fem: Solving a problem with 4006 cells, 5074x3 = 15222 dofs.\n", + "[11-08 12:41:22][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:41:23][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:41:23][DEBUG] jax_fem: Start timing\n", + "[11-08 12:41:24][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:41:24][DEBUG] jax_fem: Function split_and_compute_cell took 0.5906 seconds\n", + "[11-08 12:41:25][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:41:26][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:41:26][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:41:26][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:41:29][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 3.462303574101645e-09\n", + "[11-08 12:41:29][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:41:29][DEBUG] jax_fem: Function split_and_compute_cell took 0.0453 seconds\n", + "[11-08 12:41:29][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:41:29][DEBUG] jax_fem: l_2 res = 3.4171634587103612e-09, relative l_2 res = 1.9659529675749895e-11\n", + "[11-08 12:41:30][INFO] jax_fem: Solve took 6.053680419921875 [s]\n", + "[11-08 12:41:30][INFO] jax_fem: max of dofs = 7.352563712184762\n", + "[11-08 12:41:30][INFO] jax_fem: min of dofs = -24.814951165783473\n", + "[11-08 12:41:30][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:41:30][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:41:30][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:41:31][DEBUG] jax_fem: Done pre-computations, took 1.6762261390686035 [s]\n", + "[11-08 12:41:31][INFO] jax_fem: Solving a problem with 4006 cells, 5074x3 = 15222 dofs.\n", + "[11-08 12:41:31][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:41:33][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:41:33][DEBUG] jax_fem: Start timing\n", + "[11-08 12:41:33][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:41:34][DEBUG] jax_fem: Function split_and_compute_cell took 0.5496 seconds\n", + "[11-08 12:41:35][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:41:35][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:41:35][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:41:35][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:41:39][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 3.462303574101645e-09\n", + "[11-08 12:41:39][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:41:39][DEBUG] jax_fem: Function split_and_compute_cell took 0.0409 seconds\n", + "[11-08 12:41:39][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:41:39][DEBUG] jax_fem: l_2 res = 3.4171634587103612e-09, relative l_2 res = 1.9659529675749895e-11\n", + "[11-08 12:41:39][INFO] jax_fem: Solve took 5.915327310562134 [s]\n", + "[11-08 12:41:39][INFO] jax_fem: max of dofs = 7.352563712184762\n", + "[11-08 12:41:39][INFO] jax_fem: min of dofs = -24.814951165783473\n", + "[11-08 12:41:39][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-08 12:41:39][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:41:39][DEBUG] jax_fem: Function split_and_compute_cell took 0.0411 seconds\n", + "[11-08 12:41:39][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:41:39][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:41:44][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 6.71933799698232e-08\n", + "[11-08 12:41:45][DEBUG] jax_fem: Computing cell residual...\n", + "[11-08 12:41:45][DEBUG] jax_fem: Function split_and_compute_cell took 0.4532 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[[ 2.8335985e-02 -2.0389587e-03 1.7316924e-01]\n", + " [-5.4023322e-03 -2.2237049e-02 2.0540573e-01]\n", + " [-5.7777429e-06 -2.0721341e-02 5.3553812e-02]\n", + " [ 8.9091214e-04 1.8504403e-03 8.5024022e-02]]\n", + "\n", + " [[ 9.2203811e-02 -2.6666736e-03 -3.6831957e-01]\n", + " [-9.2070037e-03 2.3096857e-04 -4.0200573e-01]\n", + " [-6.2920139e-03 9.8996074e-04 -8.4402286e-02]\n", + " [ 1.1472437e-02 6.2506865e-03 6.8207815e-02]]\n", + "\n", + " [[ 3.0354948e-03 -2.9223242e-03 1.7783043e-01]\n", + " [-3.5717277e-04 3.4507286e-02 1.8686551e-01]\n", + " [ 1.5476600e-03 1.3234345e-02 4.6161100e-02]\n", + " [ 9.3930960e-03 -3.1242331e-03 7.7028222e-02]]]\n", + "[[[-10. -3.0473723 -0.28156394]\n", + " [ -3.3333333 -2.9059095 -0.5279008 ]\n", + " [ 3.3333333 -2.9785266 -0.09982472]\n", + " [ 10. -3.070713 -0.5931612 ]]\n", + "\n", + " [[-10. -0.10656632 0.5591268 ]\n", + " [ -3.3333333 -0.2716457 0.5197915 ]\n", + " [ 3.3333333 -0.26072693 0.04129941]\n", + " [ 10. 0.26697293 -0.59321713]]\n", + "\n", + " [[-10. 2.5394526 -0.52245826]\n", + " [ -3.3333333 2.8369765 -0.23943853]\n", + " [ 3.3333333 2.6169145 -0.53052557]\n", + " [ 10. 3.0434978 -0.597165 ]]]\n", + "Iteration 7, Loss: 22699.95\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-08 12:42:08][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:42:08][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:42:08][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:42:09][DEBUG] jax_fem: Done pre-computations, took 1.224306344985962 [s]\n", + "[11-08 12:42:09][INFO] jax_fem: Solving a problem with 3950 cells, 5015x3 = 15045 dofs.\n", + "[11-08 12:42:09][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:42:11][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:42:11][DEBUG] jax_fem: Start timing\n", + "[11-08 12:42:11][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:42:12][DEBUG] jax_fem: Function split_and_compute_cell took 0.5236 seconds\n", + "[11-08 12:42:12][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:42:12][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:42:12][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:42:13][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:42:19][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 3.469808201324728e-08\n", + "[11-08 12:42:19][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:42:19][DEBUG] jax_fem: Function split_and_compute_cell took 0.0452 seconds\n", + "[11-08 12:42:19][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:42:19][DEBUG] jax_fem: l_2 res = 3.477906676557334e-08, relative l_2 res = 2.0008995865556862e-10\n", + "[11-08 12:42:19][INFO] jax_fem: Solve took 8.216140747070312 [s]\n", + "[11-08 12:42:19][INFO] jax_fem: max of dofs = 145.9611491513351\n", + "[11-08 12:42:19][INFO] jax_fem: min of dofs = -393.8172729535031\n", + "[11-08 12:42:19][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:42:19][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:42:19][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:42:21][DEBUG] jax_fem: Done pre-computations, took 1.4270875453948975 [s]\n", + "[11-08 12:42:21][INFO] jax_fem: Solving a problem with 3950 cells, 5015x3 = 15045 dofs.\n", + "[11-08 12:42:21][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:42:22][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:42:22][DEBUG] jax_fem: Start timing\n", + "[11-08 12:42:23][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:42:23][DEBUG] jax_fem: Function split_and_compute_cell took 0.5341 seconds\n", + "[11-08 12:42:24][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:42:24][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:42:24][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:42:24][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:42:30][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 3.469808201324728e-08\n", + "[11-08 12:42:30][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:42:31][DEBUG] jax_fem: Function split_and_compute_cell took 0.0401 seconds\n", + "[11-08 12:42:31][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:42:31][DEBUG] jax_fem: l_2 res = 3.477906676557334e-08, relative l_2 res = 2.0008995865556862e-10\n", + "[11-08 12:42:31][INFO] jax_fem: Solve took 8.249773502349854 [s]\n", + "[11-08 12:42:31][INFO] jax_fem: max of dofs = 145.9611491513351\n", + "[11-08 12:42:31][INFO] jax_fem: min of dofs = -393.8172729535031\n", + "[11-08 12:42:31][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-08 12:42:31][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:42:31][DEBUG] jax_fem: Function split_and_compute_cell took 0.0410 seconds\n", + "[11-08 12:42:31][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:42:31][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:42:38][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 2.416089549438465e-06\n", + "[11-08 12:42:38][DEBUG] jax_fem: Computing cell residual...\n", + "[11-08 12:42:39][DEBUG] jax_fem: Function split_and_compute_cell took 0.4322 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[[-3.1625423e-01 -3.3890608e-01 -2.7140456e-01]\n", + " [ 3.7857604e-01 -1.7312322e+00 -1.2666842e+01]\n", + " [ 1.6644573e-01 -9.1089594e-01 -3.7190995e-01]\n", + " [ 1.0571563e+00 -7.8722010e+00 -1.2691480e+00]]\n", + "\n", + " [[ 3.0916939e+00 -5.0379598e-01 -1.7101021e+01]\n", + " [-9.8336691e-01 -1.1621790e+01 -1.8576664e+01]\n", + " [-6.4763683e-01 -7.2307765e-01 -3.5057762e+00]\n", + " [ 1.3241720e-01 -1.3727266e+00 -3.6094904e+00]]\n", + "\n", + " [[ 1.8811498e-02 -2.5198208e+01 3.2667446e+01]\n", + " [ 7.3858455e-04 -5.3299556e+00 4.8724186e+01]\n", + " [ 3.5504609e-01 8.8078845e-01 4.6640401e+00]\n", + " [-1.2236985e+00 7.1527100e-01 4.6291095e-01]]]\n", + "[[[-10. -3.117133 -0.3742803 ]\n", + " [ -3.3333333 -2.8911505 -0.62117535]\n", + " [ 3.3333333 -2.9863033 -0.18491492]\n", + " [ 10. -3.1504662 -0.69307154]]\n", + "\n", + " [[-10. -0.10782812 0.65419763]\n", + " [ -3.3333333 -0.26431042 0.6130359 ]\n", + " [ 3.3333333 -0.2789748 0.1261189 ]\n", + " [ 10. 0.25874722 -0.6928937 ]]\n", + "\n", + " [[-10. 2.5765903 -0.6164927 ]\n", + " [ -3.3333333 2.7845466 -0.3308912 ]\n", + " [ 3.3333333 2.6071684 -0.62331533]\n", + " [ 10. 3.1210334 -0.697232 ]]]\n", + "Iteration 8, Loss: 25798.65\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-08 12:43:01][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:43:01][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:43:01][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:43:02][DEBUG] jax_fem: Done pre-computations, took 1.2307031154632568 [s]\n", + "[11-08 12:43:02][INFO] jax_fem: Solving a problem with 3971 cells, 5039x3 = 15117 dofs.\n", + "[11-08 12:43:02][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:43:04][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:43:04][DEBUG] jax_fem: Start timing\n", + "[11-08 12:43:04][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:43:05][DEBUG] jax_fem: Function split_and_compute_cell took 0.5344 seconds\n", + "[11-08 12:43:05][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:43:05][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:43:05][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:43:05][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:43:09][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 3.0740527005928823e-09\n", + "[11-08 12:43:09][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:43:09][DEBUG] jax_fem: Function split_and_compute_cell took 0.0447 seconds\n", + "[11-08 12:43:09][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:43:09][DEBUG] jax_fem: l_2 res = 3.022435104378701e-09, relative l_2 res = 1.7388589496970187e-11\n", + "[11-08 12:43:09][INFO] jax_fem: Solve took 4.972477436065674 [s]\n", + "[11-08 12:43:09][INFO] jax_fem: max of dofs = 6.706220627148685\n", + "[11-08 12:43:09][INFO] jax_fem: min of dofs = -22.49447555462659\n", + "[11-08 12:43:09][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:43:09][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:43:09][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:43:10][DEBUG] jax_fem: Done pre-computations, took 1.4165713787078857 [s]\n", + "[11-08 12:43:10][INFO] jax_fem: Solving a problem with 3971 cells, 5039x3 = 15117 dofs.\n", + "[11-08 12:43:10][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:43:12][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:43:12][DEBUG] jax_fem: Start timing\n", + "[11-08 12:43:12][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:43:13][DEBUG] jax_fem: Function split_and_compute_cell took 0.5220 seconds\n", + "[11-08 12:43:13][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:43:14][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:43:14][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:43:14][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:43:17][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 3.0740527005928823e-09\n", + "[11-08 12:43:17][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:43:17][DEBUG] jax_fem: Function split_and_compute_cell took 0.0408 seconds\n", + "[11-08 12:43:17][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:43:17][DEBUG] jax_fem: l_2 res = 3.022435104378701e-09, relative l_2 res = 1.7388589496970187e-11\n", + "[11-08 12:43:17][INFO] jax_fem: Solve took 5.118162393569946 [s]\n", + "[11-08 12:43:17][INFO] jax_fem: max of dofs = 6.706220627148685\n", + "[11-08 12:43:17][INFO] jax_fem: min of dofs = -22.49447555462659\n", + "[11-08 12:43:17][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-08 12:43:17][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:43:18][DEBUG] jax_fem: Function split_and_compute_cell took 0.0417 seconds\n", + "[11-08 12:43:18][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:43:18][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:43:22][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 9.01084632005275e-08\n", + "[11-08 12:43:23][DEBUG] jax_fem: Computing cell residual...\n", + "[11-08 12:43:23][DEBUG] jax_fem: Function split_and_compute_cell took 0.4939 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[[ 2.77106706e-02 -4.10179980e-03 1.83378711e-01]\n", + " [-6.26405049e-03 -2.08330844e-02 2.23350510e-01]\n", + " [ 2.03536521e-03 -3.35365497e-02 5.09741195e-02]\n", + " [-3.80444154e-03 -1.67586852e-03 8.59473273e-02]]\n", + "\n", + " [[ 7.80801028e-02 -3.59519501e-03 -3.84880513e-01]\n", + " [-8.12745839e-03 -2.38798633e-02 -4.24808353e-01]\n", + " [-1.20546622e-02 -6.76075323e-03 -9.53642428e-02]\n", + " [ 1.11145424e-02 9.77213122e-03 6.56607524e-02]]\n", + "\n", + " [[ 7.14313006e-03 6.22406695e-03 1.94947019e-01]\n", + " [ 2.94359401e-04 4.36687805e-02 2.09810317e-01]\n", + " [ 1.38076930e-03 2.10948270e-02 5.47731668e-02]\n", + " [ 1.29368445e-02 8.92781478e-04 7.62769803e-02]]]\n", + "[[[-10. -3.0726347 -0.40232652]\n", + " [ -3.3333333 -2.8421626 -0.57473713]\n", + " [ 3.3333333 -2.9379652 -0.15260504]\n", + " [ 10. -3.101996 -0.65639234]]\n", + "\n", + " [[-10. -0.05923451 0.705944 ]\n", + " [ -3.3333333 -0.21563126 0.66463 ]\n", + " [ 3.3333333 -0.23057503 0.17738804]\n", + " [ 10. 0.3072945 -0.6476844 ]]\n", + "\n", + " [[-10. 2.6252878 -0.6659648 ]\n", + " [ -3.3333333 2.8328795 -0.3800973 ]\n", + " [ 3.3333333 2.5582683 -0.6732845 ]\n", + " [ 10. 3.0751915 -0.77206624]]]\n", + "Iteration 9, Loss: 20565.71\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-08 12:43:47][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:43:47][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:43:47][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:43:48][DEBUG] jax_fem: Done pre-computations, took 1.2221417427062988 [s]\n", + "[11-08 12:43:48][INFO] jax_fem: Solving a problem with 3999 cells, 5070x3 = 15210 dofs.\n", + "[11-08 12:43:48][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:43:49][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:43:49][DEBUG] jax_fem: Start timing\n", + "[11-08 12:43:49][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:43:50][DEBUG] jax_fem: Function split_and_compute_cell took 0.5491 seconds\n", + "[11-08 12:43:51][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:43:51][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:43:51][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:43:51][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:43:54][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 2.478463710995944e-09\n", + "[11-08 12:43:54][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:43:54][DEBUG] jax_fem: Function split_and_compute_cell took 0.0452 seconds\n", + "[11-08 12:43:54][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:43:54][DEBUG] jax_fem: l_2 res = 2.509883111801904e-09, relative l_2 res = 1.4439789642885604e-11\n", + "[11-08 12:43:54][INFO] jax_fem: Solve took 4.805090665817261 [s]\n", + "[11-08 12:43:54][INFO] jax_fem: max of dofs = 6.5424589214478885\n", + "[11-08 12:43:54][INFO] jax_fem: min of dofs = -22.020447835460544\n", + "[11-08 12:43:54][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:43:54][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:43:54][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:43:56][DEBUG] jax_fem: Done pre-computations, took 1.3980467319488525 [s]\n", + "[11-08 12:43:56][INFO] jax_fem: Solving a problem with 3999 cells, 5070x3 = 15210 dofs.\n", + "[11-08 12:43:56][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:43:57][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:43:57][DEBUG] jax_fem: Start timing\n", + "[11-08 12:43:57][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:43:58][DEBUG] jax_fem: Function split_and_compute_cell took 0.5623 seconds\n", + "[11-08 12:43:59][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:43:59][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:43:59][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:43:59][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:44:02][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 2.478463710995944e-09\n", + "[11-08 12:44:02][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:44:02][DEBUG] jax_fem: Function split_and_compute_cell took 0.0382 seconds\n", + "[11-08 12:44:02][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:44:02][DEBUG] jax_fem: l_2 res = 2.509883111801904e-09, relative l_2 res = 1.4439789642885604e-11\n", + "[11-08 12:44:02][INFO] jax_fem: Solve took 4.856095314025879 [s]\n", + "[11-08 12:44:02][INFO] jax_fem: max of dofs = 6.5424589214478885\n", + "[11-08 12:44:02][INFO] jax_fem: min of dofs = -22.020447835460544\n", + "[11-08 12:44:02][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-08 12:44:02][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:44:02][DEBUG] jax_fem: Function split_and_compute_cell took 0.0395 seconds\n", + "[11-08 12:44:02][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:44:03][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:44:07][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 6.384503974159948e-08\n", + "[11-08 12:44:08][DEBUG] jax_fem: Computing cell residual...\n", + "[11-08 12:44:08][DEBUG] jax_fem: Function split_and_compute_cell took 0.4577 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[[ 0.03405271 -0.00361089 0.18705574]\n", + " [-0.00547892 -0.02195137 0.21388084]\n", + " [ 0.00400987 -0.02680584 0.05640073]\n", + " [ 0.00096036 -0.00393811 0.08950314]]\n", + "\n", + " [[ 0.08826303 -0.00118288 -0.38273498]\n", + " [-0.01007776 -0.01040335 -0.4220902 ]\n", + " [-0.01198848 -0.01015246 -0.09465475]\n", + " [ 0.01773302 0.00976538 0.06113528]]\n", + "\n", + " [[ 0.0084476 0.00454003 0.19228113]\n", + " [ 0.0005708 0.04296708 0.21574546]\n", + " [ 0.00173168 0.02120327 0.05651861]\n", + " [ 0.01551613 0.00146194 0.08279873]]]\n", + "[[[-10. -3.0326607 -0.44467002]\n", + " [ -3.3333333 -2.7982159 -0.5344709 ]\n", + " [ 3.3333333 -2.8934352 -0.1306183 ]\n", + " [ 10. -3.05907 -0.62719655]]\n", + "\n", + " [[-10. -0.01586936 0.75282526]\n", + " [ -3.3333333 -0.17243241 0.7113934 ]\n", + " [ 3.3333333 -0.1872761 0.22406615]\n", + " [ 10. 0.3499364 -0.60853285]]\n", + "\n", + " [[-10. 2.6683927 -0.7100523 ]\n", + " [ -3.3333333 2.87528 -0.4238702 ]\n", + " [ 3.3333333 2.5138385 -0.7180863 ]\n", + " [ 10. 3.0345435 -0.84489965]]]\n", + "Iteration 10, Loss: 20035.60\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-08 12:44:32][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:44:32][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:44:32][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:44:33][DEBUG] jax_fem: Done pre-computations, took 1.2571463584899902 [s]\n", + "[11-08 12:44:33][INFO] jax_fem: Solving a problem with 4013 cells, 5084x3 = 15252 dofs.\n", + "[11-08 12:44:33][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:44:35][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:44:35][DEBUG] jax_fem: Start timing\n", + "[11-08 12:44:35][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:44:35][DEBUG] jax_fem: Function split_and_compute_cell took 0.5231 seconds\n", + "[11-08 12:44:36][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:44:36][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:44:36][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:44:36][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:44:44][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 4.463749845436448e-08\n", + "[11-08 12:44:44][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:44:44][DEBUG] jax_fem: Function split_and_compute_cell took 0.0447 seconds\n", + "[11-08 12:44:44][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:44:44][DEBUG] jax_fem: l_2 res = 4.4595821472135315e-08, relative l_2 res = 2.565674385318307e-10\n", + "[11-08 12:44:44][INFO] jax_fem: Solve took 9.739726066589355 [s]\n", + "[11-08 12:44:44][INFO] jax_fem: max of dofs = 24.514801674455086\n", + "[11-08 12:44:44][INFO] jax_fem: min of dofs = -62.57052802689247\n", + "[11-08 12:44:44][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:44:44][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:44:44][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:44:46][DEBUG] jax_fem: Done pre-computations, took 1.426882028579712 [s]\n", + "[11-08 12:44:46][INFO] jax_fem: Solving a problem with 4013 cells, 5084x3 = 15252 dofs.\n", + "[11-08 12:44:46][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:44:47][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:44:47][DEBUG] jax_fem: Start timing\n", + "[11-08 12:44:48][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:44:48][DEBUG] jax_fem: Function split_and_compute_cell took 0.5305 seconds\n", + "[11-08 12:44:49][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:44:49][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:44:49][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:44:49][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:44:57][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 4.463749845436448e-08\n", + "[11-08 12:44:57][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:44:57][DEBUG] jax_fem: Function split_and_compute_cell took 0.0394 seconds\n", + "[11-08 12:44:57][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:44:57][DEBUG] jax_fem: l_2 res = 4.4595821472135315e-08, relative l_2 res = 2.565674385318307e-10\n", + "[11-08 12:44:57][INFO] jax_fem: Solve took 9.392942190170288 [s]\n", + "[11-08 12:44:57][INFO] jax_fem: max of dofs = 24.514801674455086\n", + "[11-08 12:44:57][INFO] jax_fem: min of dofs = -62.57052802689247\n", + "[11-08 12:44:57][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-08 12:44:57][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:44:57][DEBUG] jax_fem: Function split_and_compute_cell took 0.0405 seconds\n", + "[11-08 12:44:57][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:44:57][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:45:06][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 1.2814018557815348e-06\n", + "[11-08 12:45:06][DEBUG] jax_fem: Computing cell residual...\n", + "[11-08 12:45:06][DEBUG] jax_fem: Function split_and_compute_cell took 0.4086 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[[-5.1729220e-01 5.3676959e-02 7.0664948e-01]\n", + " [-1.1994199e-01 2.3884709e+00 7.6503593e-01]\n", + " [-1.7039688e-02 7.6094186e-01 -8.3299410e-01]\n", + " [-1.2444597e+00 2.1189787e+00 -1.4190985e+00]]\n", + "\n", + " [[ 2.5509604e+01 4.1810632e+00 -4.8173405e+01]\n", + " [-1.2843980e+00 -4.9895477e+00 -4.1541092e+01]\n", + " [ 8.9189798e-01 -2.5114168e+01 -4.8551388e+00]\n", + " [ 1.4008677e+00 -1.2168118e+00 -1.1830724e+00]]\n", + "\n", + " [[-1.5103301e+00 2.9072712e+01 -7.1141582e+00]\n", + " [ 4.4674870e-01 1.1684677e+01 -1.0303010e+00]\n", + " [ 5.6169313e-01 3.1980193e+00 1.2433466e+01]\n", + " [-7.2622025e-01 3.5746098e+00 -2.1229509e+01]]]\n", + "[[[-10. -2.9965773 -0.49775138]\n", + " [ -3.3333333 -2.7585006 -0.49943292]\n", + " [ 3.3333333 -2.8524244 -0.11814842]\n", + " [ 10. -3.0208368 -0.6045667 ]]\n", + "\n", + " [[-10. 0.02284224 0.7956038 ]\n", + " [ -3.3333333 -0.13393746 0.7540829 ]\n", + " [ 3.3333333 -0.14807355 0.2668774 ]\n", + " [ 10. 0.38755542 -0.5744891 ]]\n", + "\n", + " [[-10. 2.706753 -0.74957395]\n", + " [ -3.3333333 2.9126387 -0.46304303]\n", + " [ 3.3333333 2.473163 -0.7585365 ]\n", + " [ 10. 2.9982648 -0.9166422 ]]]\n", + "Iteration 11, Loss: 33620.29\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-08 12:45:31][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:45:31][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:45:31][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:45:32][DEBUG] jax_fem: Done pre-computations, took 1.2443902492523193 [s]\n", + "[11-08 12:45:32][INFO] jax_fem: Solving a problem with 4020 cells, 5094x3 = 15282 dofs.\n", + "[11-08 12:45:32][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:45:34][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:45:34][DEBUG] jax_fem: Start timing\n", + "[11-08 12:45:34][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:45:34][DEBUG] jax_fem: Function split_and_compute_cell took 0.2867 seconds\n", + "[11-08 12:45:35][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:45:35][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:45:35][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:45:35][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:45:38][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 2.3816374901184058e-09\n", + "[11-08 12:45:38][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:45:38][DEBUG] jax_fem: Function split_and_compute_cell took 0.0458 seconds\n", + "[11-08 12:45:38][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:45:38][DEBUG] jax_fem: l_2 res = 2.356584390124716e-09, relative l_2 res = 1.3557835705216904e-11\n", + "[11-08 12:45:38][INFO] jax_fem: Solve took 4.831552982330322 [s]\n", + "[11-08 12:45:38][INFO] jax_fem: max of dofs = 6.175317911024396\n", + "[11-08 12:45:39][INFO] jax_fem: min of dofs = -20.968168035756463\n", + "[11-08 12:45:39][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:45:39][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:45:39][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:45:40][DEBUG] jax_fem: Done pre-computations, took 1.4444968700408936 [s]\n", + "[11-08 12:45:40][INFO] jax_fem: Solving a problem with 4020 cells, 5094x3 = 15282 dofs.\n", + "[11-08 12:45:40][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:45:42][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:45:42][DEBUG] jax_fem: Start timing\n", + "[11-08 12:45:42][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:45:42][DEBUG] jax_fem: Function split_and_compute_cell took 0.2907 seconds\n", + "[11-08 12:45:43][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:45:43][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:45:43][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:45:43][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:45:46][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 2.3816374901184058e-09\n", + "[11-08 12:45:46][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:45:46][DEBUG] jax_fem: Function split_and_compute_cell took 0.0408 seconds\n", + "[11-08 12:45:46][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:45:46][DEBUG] jax_fem: l_2 res = 2.356584390124716e-09, relative l_2 res = 1.3557835705216904e-11\n", + "[11-08 12:45:47][INFO] jax_fem: Solve took 4.8920204639434814 [s]\n", + "[11-08 12:45:47][INFO] jax_fem: max of dofs = 6.175317911024396\n", + "[11-08 12:45:47][INFO] jax_fem: min of dofs = -20.968168035756463\n", + "[11-08 12:45:47][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-08 12:45:47][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:45:47][DEBUG] jax_fem: Function split_and_compute_cell took 0.0407 seconds\n", + "[11-08 12:45:47][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:45:47][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:45:52][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 6.08566638087007e-08\n", + "[11-08 12:45:53][DEBUG] jax_fem: Computing cell residual...\n", + "[11-08 12:45:53][DEBUG] jax_fem: Function split_and_compute_cell took 0.3276 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[[ 3.7121832e-02 4.1418313e-03 1.8311103e-01]\n", + " [-9.3950862e-03 -2.3827655e-02 2.0732167e-01]\n", + " [ 1.6912085e-03 -3.1602021e-02 5.6604963e-02]\n", + " [ 2.0663629e-04 -4.8163952e-03 8.8859022e-02]]\n", + "\n", + " [[ 6.5115198e-02 -4.8396984e-04 -3.7719622e-01]\n", + " [-8.8858884e-03 -1.5717110e-02 -4.1886094e-01]\n", + " [-1.2431613e-02 -1.2201625e-02 -1.0059106e-01]\n", + " [ 1.0836769e-02 1.1370210e-02 5.5173766e-02]]\n", + "\n", + " [[ 7.4860905e-03 2.9815435e-03 1.9046505e-01]\n", + " [ 2.2922477e-03 4.4702332e-02 2.2731566e-01]\n", + " [ 3.2754706e-03 2.8970314e-02 6.4661242e-02]\n", + " [ 1.1862095e-02 6.2623591e-04 9.4709143e-02]]]\n", + "[[[-10. -2.9720614 -0.56328565]\n", + " [ -3.3333333 -2.7757168 -0.4710054 ]\n", + " [ 3.3333333 -2.854384 -0.07086337]\n", + " [ 10. -3.0000637 -0.5561762 ]]\n", + "\n", + " [[-10. -0.01964475 0.85264766]\n", + " [ -3.3333333 -0.08377819 0.81252664]\n", + " [ 3.3333333 -0.10012577 0.32735068]\n", + " [ 10. 0.44387633 -0.5309426 ]]\n", + "\n", + " [[-10. 2.693682 -0.7740823 ]\n", + " [ -3.3333333 2.8837454 -0.49705485]\n", + " [ 3.3333333 2.4182377 -0.8151964 ]\n", + " [ 10. 2.945858 -0.8712114 ]]]\n", + "Iteration 12, Loss: 18954.01\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-08 12:46:17][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:46:17][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:46:17][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:46:18][DEBUG] jax_fem: Done pre-computations, took 1.5593719482421875 [s]\n", + "[11-08 12:46:18][INFO] jax_fem: Solving a problem with 4118 cells, 5211x3 = 15633 dofs.\n", + "[11-08 12:46:18][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:46:20][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:46:20][DEBUG] jax_fem: Start timing\n", + "[11-08 12:46:20][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:46:21][DEBUG] jax_fem: Function split_and_compute_cell took 0.5923 seconds\n", + "[11-08 12:46:22][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:46:22][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:46:22][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:46:22][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:46:26][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 2.817040147328615e-09\n", + "[11-08 12:46:26][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:46:26][DEBUG] jax_fem: Function split_and_compute_cell took 0.0463 seconds\n", + "[11-08 12:46:26][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:46:26][DEBUG] jax_fem: l_2 res = 2.7921161432936358e-09, relative l_2 res = 1.606352486220771e-11\n", + "[11-08 12:46:26][INFO] jax_fem: Solve took 6.077598571777344 [s]\n", + "[11-08 12:46:26][INFO] jax_fem: max of dofs = 5.989856131535517\n", + "[11-08 12:46:26][INFO] jax_fem: min of dofs = -20.445991948636266\n", + "[11-08 12:46:26][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:46:26][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:46:26][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:46:28][DEBUG] jax_fem: Done pre-computations, took 1.668410062789917 [s]\n", + "[11-08 12:46:28][INFO] jax_fem: Solving a problem with 4118 cells, 5211x3 = 15633 dofs.\n", + "[11-08 12:46:28][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:46:29][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:46:29][DEBUG] jax_fem: Start timing\n", + "[11-08 12:46:30][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:46:30][DEBUG] jax_fem: Function split_and_compute_cell took 0.5929 seconds\n", + "[11-08 12:46:31][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:46:32][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:46:32][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:46:32][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:46:35][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 2.817040147328615e-09\n", + "[11-08 12:46:36][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:46:36][DEBUG] jax_fem: Function split_and_compute_cell took 0.0434 seconds\n", + "[11-08 12:46:36][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:46:36][DEBUG] jax_fem: l_2 res = 2.7921161432936358e-09, relative l_2 res = 1.606352486220771e-11\n", + "[11-08 12:46:36][INFO] jax_fem: Solve took 6.317601680755615 [s]\n", + "[11-08 12:46:36][INFO] jax_fem: max of dofs = 5.989856131535517\n", + "[11-08 12:46:36][INFO] jax_fem: min of dofs = -20.445991948636266\n", + "[11-08 12:46:36][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-08 12:46:36][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:46:36][DEBUG] jax_fem: Function split_and_compute_cell took 0.0427 seconds\n", + "[11-08 12:46:36][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:46:36][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:46:41][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 1.0564104198286437e-07\n", + "[11-08 12:46:41][DEBUG] jax_fem: Computing cell residual...\n", + "[11-08 12:46:42][DEBUG] jax_fem: Function split_and_compute_cell took 0.5339 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[[ 0.01865805 -0.0020242 0.172503 ]\n", + " [-0.01025364 -0.0337781 0.19307001]\n", + " [ 0.00449386 -0.03358318 0.05187621]\n", + " [-0.00226536 -0.00504411 0.08997976]]\n", + "\n", + " [[ 0.06822564 -0.00160139 -0.344243 ]\n", + " [-0.00764352 -0.01407029 -0.397283 ]\n", + " [-0.01375911 -0.00529344 -0.09765811]\n", + " [ 0.01449856 0.0121912 0.05197243]]\n", + "\n", + " [[ 0.01524612 0.01058264 0.19068168]\n", + " [ 0.00245078 0.04510973 0.2282935 ]\n", + " [ 0.00067756 0.02353533 0.06129372]\n", + " [ 0.01531567 0.00110894 0.09482747]]]\n", + "[[[-10. -2.9506423 -0.6305445 ]\n", + " [ -3.3333333 -2.7907772 -0.44628087]\n", + " [ 3.3333333 -2.8548956 -0.03141819]\n", + " [ 10. -2.9814072 -0.5149977 ]]\n", + "\n", + " [[-10. -0.05774044 0.9041468 ]\n", + " [ -3.3333333 -0.03873867 0.8653657 ]\n", + " [ 3.3333333 -0.05710492 0.38235953]\n", + " [ 10. 0.49409202 -0.4925754 ]]\n", + "\n", + " [[-10. 2.6819565 -0.79632723]\n", + " [ -3.3333333 2.8576722 -0.52777386]\n", + " [ 3.3333333 2.3685756 -0.86623454]\n", + " [ 10. 2.898853 -0.83067954]]]\n", + "Iteration 13, Loss: 18449.56\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-08 12:47:06][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:47:06][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:47:06][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:47:08][DEBUG] jax_fem: Done pre-computations, took 1.2730686664581299 [s]\n", + "[11-08 12:47:08][INFO] jax_fem: Solving a problem with 4202 cells, 5326x3 = 15978 dofs.\n", + "[11-08 12:47:08][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:47:09][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:47:09][DEBUG] jax_fem: Start timing\n", + "[11-08 12:47:09][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:47:10][DEBUG] jax_fem: Function split_and_compute_cell took 0.5540 seconds\n", + "[11-08 12:47:10][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:47:11][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:47:11][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:47:11][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:47:16][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 2.3860500275074608e-09\n", + "[11-08 12:47:16][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:47:16][DEBUG] jax_fem: Function split_and_compute_cell took 0.0464 seconds\n", + "[11-08 12:47:16][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:47:16][DEBUG] jax_fem: l_2 res = 2.405005020715915e-09, relative l_2 res = 1.3836407929088646e-11\n", + "[11-08 12:47:16][INFO] jax_fem: Solve took 6.912633419036865 [s]\n", + "[11-08 12:47:16][INFO] jax_fem: max of dofs = 5.816467099476184\n", + "[11-08 12:47:16][INFO] jax_fem: min of dofs = -19.960369739446957\n", + "[11-08 12:47:16][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:47:16][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:47:16][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:47:18][DEBUG] jax_fem: Done pre-computations, took 1.456014633178711 [s]\n", + "[11-08 12:47:18][INFO] jax_fem: Solving a problem with 4202 cells, 5326x3 = 15978 dofs.\n", + "[11-08 12:47:18][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:47:19][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:47:19][DEBUG] jax_fem: Start timing\n", + "[11-08 12:47:19][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:47:20][DEBUG] jax_fem: Function split_and_compute_cell took 0.5529 seconds\n", + "[11-08 12:47:21][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:47:21][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:47:21][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:47:21][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:47:26][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 2.3860500275074608e-09\n", + "[11-08 12:47:26][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:47:26][DEBUG] jax_fem: Function split_and_compute_cell took 0.0406 seconds\n", + "[11-08 12:47:26][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:47:26][DEBUG] jax_fem: l_2 res = 2.405005020715915e-09, relative l_2 res = 1.3836407929088646e-11\n", + "[11-08 12:47:26][INFO] jax_fem: Solve took 6.914340019226074 [s]\n", + "[11-08 12:47:26][INFO] jax_fem: max of dofs = 5.816467099476184\n", + "[11-08 12:47:26][INFO] jax_fem: min of dofs = -19.960369739446957\n", + "[11-08 12:47:26][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-08 12:47:26][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:47:26][DEBUG] jax_fem: Function split_and_compute_cell took 0.0413 seconds\n", + "[11-08 12:47:27][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:47:27][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:47:31][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 7.208252875397106e-08\n", + "[11-08 12:47:31][DEBUG] jax_fem: Computing cell residual...\n", + "[11-08 12:47:32][DEBUG] jax_fem: Function split_and_compute_cell took 0.5260 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[[ 0.00667372 -0.00058409 0.17127058]\n", + " [-0.01049605 -0.03979915 0.18433261]\n", + " [ 0.00415094 -0.03621181 0.0540384 ]\n", + " [-0.00907904 -0.00364329 0.08869904]]\n", + "\n", + " [[ 0.08637676 0.00299453 -0.32378313]\n", + " [-0.00699719 -0.01232405 -0.37970215]\n", + " [-0.01062504 -0.00479514 -0.09923894]\n", + " [ 0.01689126 0.01686907 0.05060479]]\n", + "\n", + " [[ 0.01734215 0.00952874 0.18035708]\n", + " [ 0.00324677 0.03674961 0.2313262 ]\n", + " [-0.0013375 0.02144313 0.06299715]\n", + " [ 0.01611598 0.00287515 0.09560968]]]\n", + "[[[-1.0000000e+01 -2.9311085e+00 -6.9891632e-01]\n", + " [-3.3333333e+00 -2.8037822e+00 -4.2476448e-01]\n", + " [ 3.3333333e+00 -2.8540342e+00 1.3607703e-03]\n", + " [ 1.0000000e+01 -2.9646037e+00 -4.8020655e-01]]\n", + "\n", + " [[-1.0000000e+01 -9.1975659e-02 9.5076495e-01]\n", + " [-3.3333333e+00 1.8097907e-03 9.1328120e-01]\n", + " [ 3.3333333e+00 -1.8413689e-02 4.3257526e-01]\n", + " [ 1.0000000e+01 5.3893059e-01 -4.5872125e-01]]\n", + "\n", + " [[-1.0000000e+01 2.6714010e+00 -8.1659496e-01]\n", + " [-3.3333333e+00 2.8340647e+00 -5.5561322e-01]\n", + " [ 3.3333333e+00 2.3235922e+00 -9.1233981e-01]\n", + " [ 1.0000000e+01 2.8565753e+00 -7.9444516e-01]]]\n", + "Iteration 14, Loss: 17981.49\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-08 12:47:56][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:47:56][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:47:56][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:47:57][DEBUG] jax_fem: Done pre-computations, took 1.3071558475494385 [s]\n", + "[11-08 12:47:57][INFO] jax_fem: Solving a problem with 4272 cells, 5405x3 = 16215 dofs.\n", + "[11-08 12:47:57][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:47:59][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:47:59][DEBUG] jax_fem: Start timing\n", + "[11-08 12:47:59][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:48:00][DEBUG] jax_fem: Function split_and_compute_cell took 0.5076 seconds\n", + "[11-08 12:48:00][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:48:00][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:48:00][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:48:00][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:48:05][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 2.586386712326864e-09\n", + "[11-08 12:48:05][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:48:05][DEBUG] jax_fem: Function split_and_compute_cell took 0.0461 seconds\n", + "[11-08 12:48:05][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:48:05][DEBUG] jax_fem: l_2 res = 2.630870016449921e-09, relative l_2 res = 1.51358481343932e-11\n", + "[11-08 12:48:05][INFO] jax_fem: Solve took 6.674448251724243 [s]\n", + "[11-08 12:48:06][INFO] jax_fem: max of dofs = 5.644937126324052\n", + "[11-08 12:48:06][INFO] jax_fem: min of dofs = -19.498392050690903\n", + "[11-08 12:48:06][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:48:06][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:48:06][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:48:07][DEBUG] jax_fem: Done pre-computations, took 1.4674644470214844 [s]\n", + "[11-08 12:48:07][INFO] jax_fem: Solving a problem with 4272 cells, 5405x3 = 16215 dofs.\n", + "[11-08 12:48:07][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:48:09][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:48:09][DEBUG] jax_fem: Start timing\n", + "[11-08 12:48:09][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:48:10][DEBUG] jax_fem: Function split_and_compute_cell took 0.5108 seconds\n", + "[11-08 12:48:10][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:48:10][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:48:10][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:48:10][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:48:15][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 2.586386712326864e-09\n", + "[11-08 12:48:15][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:48:15][DEBUG] jax_fem: Function split_and_compute_cell took 0.0416 seconds\n", + "[11-08 12:48:15][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:48:15][DEBUG] jax_fem: l_2 res = 2.630870016449921e-09, relative l_2 res = 1.51358481343932e-11\n", + "[11-08 12:48:15][INFO] jax_fem: Solve took 6.402344226837158 [s]\n", + "[11-08 12:48:15][INFO] jax_fem: max of dofs = 5.644937126324052\n", + "[11-08 12:48:15][INFO] jax_fem: min of dofs = -19.498392050690903\n", + "[11-08 12:48:15][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-08 12:48:16][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:48:16][DEBUG] jax_fem: Function split_and_compute_cell took 0.0407 seconds\n", + "[11-08 12:48:16][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:48:16][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:48:20][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 7.070602718964511e-08\n", + "[11-08 12:48:20][DEBUG] jax_fem: Computing cell residual...\n", + "[11-08 12:48:21][DEBUG] jax_fem: Function split_and_compute_cell took 0.4838 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[[ 8.0575934e-03 2.1437232e-03 1.6946478e-01]\n", + " [-1.0771931e-02 -3.7646871e-02 1.8183859e-01]\n", + " [ 3.9544390e-03 -3.7811521e-02 5.1970363e-02]\n", + " [-6.7789555e-03 -5.2876445e-03 8.5924082e-02]]\n", + "\n", + " [[ 1.0015512e-01 1.6093228e-03 -3.1720418e-01]\n", + " [-6.7855194e-03 -2.2556330e-03 -3.7119350e-01]\n", + " [-1.2908995e-02 -8.3985282e-03 -9.5999166e-02]\n", + " [ 1.1913047e-02 1.5562553e-02 4.6817932e-02]]\n", + "\n", + " [[ 2.0309009e-02 3.8388898e-03 1.8632390e-01]\n", + " [ 4.6609105e-03 4.8098344e-02 2.1986032e-01]\n", + " [ 3.4372933e-04 1.9438198e-02 5.9523951e-02]\n", + " [ 1.8054437e-02 6.9063425e-04 9.6930973e-02]]]\n", + "[[[-10. -2.913428 -0.76823926]\n", + " [ -3.3333333 -2.8148677 -0.4060595 ]\n", + " [ 3.3333333 -2.8518326 0.028106 ]\n", + " [ 10. -2.949442 -0.4510536 ]]\n", + "\n", + " [[-10. -0.12285629 0.9930655 ]\n", + " [ -3.3333333 0.03839129 0.95684403]\n", + " [ 3.3333333 0.01645765 0.47859073]\n", + " [ 10. 0.5788996 -0.42884353]]\n", + "\n", + " [[-10. 2.6618786 -0.8351096 ]\n", + " [ -3.3333333 2.8126597 -0.58091986]\n", + " [ 3.3333333 2.2827587 -0.9541042 ]\n", + " [ 10. 2.8184445 -0.76200753]]]\n", + "Iteration 15, Loss: 17537.26\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-08 12:48:45][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:48:45][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:48:45][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:48:46][DEBUG] jax_fem: Done pre-computations, took 1.2771363258361816 [s]\n", + "[11-08 12:48:46][INFO] jax_fem: Solving a problem with 4300 cells, 5436x3 = 16308 dofs.\n", + "[11-08 12:48:46][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:48:48][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:48:48][DEBUG] jax_fem: Start timing\n", + "[11-08 12:48:48][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:48:48][DEBUG] jax_fem: Function split_and_compute_cell took 0.3048 seconds\n", + "[11-08 12:48:49][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:48:49][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:48:49][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:48:49][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:48:53][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 2.390613792832145e-09\n", + "[11-08 12:48:53][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:48:54][DEBUG] jax_fem: Function split_and_compute_cell took 0.0462 seconds\n", + "[11-08 12:48:54][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:48:54][DEBUG] jax_fem: l_2 res = 2.366129923631448e-09, relative l_2 res = 1.3612752802837186e-11\n", + "[11-08 12:48:54][INFO] jax_fem: Solve took 6.053060054779053 [s]\n", + "[11-08 12:48:54][INFO] jax_fem: max of dofs = 5.491487621965221\n", + "[11-08 12:48:54][INFO] jax_fem: min of dofs = -19.084269067947783\n", + "[11-08 12:48:54][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:48:54][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:48:54][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:48:55][DEBUG] jax_fem: Done pre-computations, took 1.4861369132995605 [s]\n", + "[11-08 12:48:55][INFO] jax_fem: Solving a problem with 4300 cells, 5436x3 = 16308 dofs.\n", + "[11-08 12:48:55][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:48:57][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:48:57][DEBUG] jax_fem: Start timing\n", + "[11-08 12:48:57][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:48:58][DEBUG] jax_fem: Function split_and_compute_cell took 0.2868 seconds\n", + "[11-08 12:48:58][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:48:58][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:48:58][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:48:58][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:49:03][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 2.390613792832145e-09\n", + "[11-08 12:49:03][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:49:03][DEBUG] jax_fem: Function split_and_compute_cell took 0.0435 seconds\n", + "[11-08 12:49:03][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:49:03][DEBUG] jax_fem: l_2 res = 2.366129923631448e-09, relative l_2 res = 1.3612752802837186e-11\n", + "[11-08 12:49:03][INFO] jax_fem: Solve took 6.2988121509552 [s]\n", + "[11-08 12:49:03][INFO] jax_fem: max of dofs = 5.491487621965221\n", + "[11-08 12:49:03][INFO] jax_fem: min of dofs = -19.084269067947783\n", + "[11-08 12:49:04][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-08 12:49:04][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:49:04][DEBUG] jax_fem: Function split_and_compute_cell took 0.0427 seconds\n", + "[11-08 12:49:04][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:49:04][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:49:09][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 8.490832067904948e-08\n", + "[11-08 12:49:09][DEBUG] jax_fem: Computing cell residual...\n", + "[11-08 12:49:09][DEBUG] jax_fem: Function split_and_compute_cell took 0.3159 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[[ 0.00509608 -0.00162461 0.16199337]\n", + " [-0.01158143 -0.04072959 0.17576316]\n", + " [ 0.00408951 -0.03980559 0.04604419]\n", + " [-0.00294321 -0.00676131 0.08406128]]\n", + "\n", + " [[ 0.09823324 -0.01303589 -0.31235656]\n", + " [-0.00725247 -0.0062876 -0.36413255]\n", + " [-0.01217121 -0.0058512 -0.09223013]\n", + " [ 0.01423167 0.01423109 0.04452753]]\n", + "\n", + " [[ 0.01585048 0.0069444 0.18231374]\n", + " [ 0.00464947 0.0434809 0.22120734]\n", + " [-0.00094522 0.01767903 0.06108823]\n", + " [ 0.01534827 -0.00041572 0.09400102]]]\n", + "[[[-10. -2.897763 -0.83835286]\n", + " [ -3.3333333 -2.8242736 -0.389851 ]\n", + " [ 3.3333333 -2.8483543 0.04957009]\n", + " [ 10. -2.9357266 -0.42686468]]\n", + "\n", + " [[-10. -0.150747 1.0315363 ]\n", + " [ -3.3333333 0.07141803 0.99654526]\n", + " [ 3.3333333 0.04794812 0.52087086]\n", + " [ 10. 0.61457586 -0.40245655]]\n", + "\n", + " [[-10. 2.6532788 -0.8520825 ]\n", + " [ -3.3333333 2.7931638 -0.6039734 ]\n", + " [ 3.3333333 2.245628 -0.9920106 ]\n", + " [ 10. 2.7840188 -0.73294395]]]\n", + "Iteration 16, Loss: 17141.59\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-08 12:49:33][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:49:33][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:49:33][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:49:34][DEBUG] jax_fem: Done pre-computations, took 1.3091957569122314 [s]\n", + "[11-08 12:49:34][INFO] jax_fem: Solving a problem with 4321 cells, 5463x3 = 16389 dofs.\n", + "[11-08 12:49:34][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:49:36][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:49:36][DEBUG] jax_fem: Start timing\n", + "[11-08 12:49:36][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:49:37][DEBUG] jax_fem: Function split_and_compute_cell took 0.5190 seconds\n", + "[11-08 12:49:37][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:49:37][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:49:37][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:49:38][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:49:42][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 2.3359113760808067e-09\n", + "[11-08 12:49:42][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:49:42][DEBUG] jax_fem: Function split_and_compute_cell took 0.0457 seconds\n", + "[11-08 12:49:42][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:49:42][DEBUG] jax_fem: l_2 res = 2.3781907444992773e-09, relative l_2 res = 1.3682140781676948e-11\n", + "[11-08 12:49:42][INFO] jax_fem: Solve took 6.217949867248535 [s]\n", + "[11-08 12:49:42][INFO] jax_fem: max of dofs = 5.35155747894039\n", + "[11-08 12:49:42][INFO] jax_fem: min of dofs = -18.71118914758827\n", + "[11-08 12:49:42][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:49:42][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:49:42][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:49:44][DEBUG] jax_fem: Done pre-computations, took 1.486464500427246 [s]\n", + "[11-08 12:49:44][INFO] jax_fem: Solving a problem with 4321 cells, 5463x3 = 16389 dofs.\n", + "[11-08 12:49:44][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:49:45][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:49:45][DEBUG] jax_fem: Start timing\n", + "[11-08 12:49:46][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:49:46][DEBUG] jax_fem: Function split_and_compute_cell took 0.5321 seconds\n", + "[11-08 12:49:47][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:49:47][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:49:47][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:49:47][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:49:51][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 2.3359113760808067e-09\n", + "[11-08 12:49:51][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:49:51][DEBUG] jax_fem: Function split_and_compute_cell took 0.0399 seconds\n", + "[11-08 12:49:51][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:49:51][DEBUG] jax_fem: l_2 res = 2.3781907444992773e-09, relative l_2 res = 1.3682140781676948e-11\n", + "[11-08 12:49:52][INFO] jax_fem: Solve took 6.054427862167358 [s]\n", + "[11-08 12:49:52][INFO] jax_fem: max of dofs = 5.35155747894039\n", + "[11-08 12:49:52][INFO] jax_fem: min of dofs = -18.71118914758827\n", + "[11-08 12:49:52][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-08 12:49:52][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:49:52][DEBUG] jax_fem: Function split_and_compute_cell took 0.0403 seconds\n", + "[11-08 12:49:52][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:49:52][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:49:56][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 1.0533710407144898e-07\n", + "[11-08 12:49:57][DEBUG] jax_fem: Computing cell residual...\n", + "[11-08 12:49:57][DEBUG] jax_fem: Function split_and_compute_cell took 0.4853 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[[-0.01946134 -0.00981538 0.15000497]\n", + " [-0.02213456 -0.05166192 0.15888385]\n", + " [-0.00212982 -0.05022839 0.03194929]\n", + " [-0.01591925 -0.01127151 0.07582805]]\n", + "\n", + " [[ 0.08383305 -0.01714095 -0.30877063]\n", + " [-0.01312121 -0.01282636 -0.35606125]\n", + " [-0.01852102 -0.015098 -0.0959075 ]\n", + " [ 0.02017607 0.01256268 0.04173528]]\n", + "\n", + " [[ 0.01049902 0.0031559 0.1746722 ]\n", + " [-0.00247941 0.0246546 0.20693055]\n", + " [-0.00911118 0.0154341 0.05138211]\n", + " [ 0.00804252 -0.00745272 0.08714029]]]\n", + "[[[-10. -2.8833811 -0.90890926]\n", + " [ -3.3333333 -2.8321235 -0.37585512]\n", + " [ 3.3333333 -2.8436356 0.06660257]\n", + " [ 10. -2.9232905 -0.4070815 ]]\n", + "\n", + " [[-10. -0.1758105 1.0665963 ]\n", + " [ -3.3333333 0.10129333 1.0328059 ]\n", + " [ 3.3333333 0.07642234 0.55980754]\n", + " [ 10. 0.6464556 -0.37916037]]\n", + "\n", + " [[-10. 2.6454973 -0.8676809 ]\n", + " [ -3.3333333 2.7753825 -0.62502474]\n", + " [ 3.3333333 2.2118163 -1.0264895 ]\n", + " [ 10. 2.7529078 -0.7068832 ]]]\n", + "Iteration 17, Loss: 16782.16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-08 12:50:22][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:50:22][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:50:22][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:50:23][DEBUG] jax_fem: Done pre-computations, took 1.5731871128082275 [s]\n", + "[11-08 12:50:23][INFO] jax_fem: Solving a problem with 4349 cells, 5501x3 = 16503 dofs.\n", + "[11-08 12:50:23][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:50:25][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:50:25][DEBUG] jax_fem: Start timing\n", + "[11-08 12:50:25][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:50:26][DEBUG] jax_fem: Function split_and_compute_cell took 0.5640 seconds\n", + "[11-08 12:50:27][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:50:27][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:50:27][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:50:27][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:50:32][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 2.2775198636343975e-09\n", + "[11-08 12:50:32][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:50:32][DEBUG] jax_fem: Function split_and_compute_cell took 0.0444 seconds\n", + "[11-08 12:50:32][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:50:33][DEBUG] jax_fem: l_2 res = 2.2554776998242843e-09, relative l_2 res = 1.2976151509422432e-11\n", + "[11-08 12:50:33][INFO] jax_fem: Solve took 7.745609998703003 [s]\n", + "[11-08 12:50:33][INFO] jax_fem: max of dofs = 5.215205804361041\n", + "[11-08 12:50:33][INFO] jax_fem: min of dofs = -18.369566618149705\n", + "[11-08 12:50:33][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:50:33][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:50:33][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:50:35][DEBUG] jax_fem: Done pre-computations, took 1.6716737747192383 [s]\n", + "[11-08 12:50:35][INFO] jax_fem: Solving a problem with 4349 cells, 5501x3 = 16503 dofs.\n", + "[11-08 12:50:35][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:50:36][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:50:36][DEBUG] jax_fem: Start timing\n", + "[11-08 12:50:36][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:50:37][DEBUG] jax_fem: Function split_and_compute_cell took 0.5543 seconds\n", + "[11-08 12:50:38][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:50:38][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:50:38][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:50:38][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:50:44][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 2.2775198636343975e-09\n", + "[11-08 12:50:44][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:50:44][DEBUG] jax_fem: Function split_and_compute_cell took 0.0407 seconds\n", + "[11-08 12:50:44][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:50:44][DEBUG] jax_fem: l_2 res = 2.2554776998242843e-09, relative l_2 res = 1.2976151509422432e-11\n", + "[11-08 12:50:44][INFO] jax_fem: Solve took 7.687034368515015 [s]\n", + "[11-08 12:50:44][INFO] jax_fem: max of dofs = 5.215205804361041\n", + "[11-08 12:50:44][INFO] jax_fem: min of dofs = -18.369566618149705\n", + "[11-08 12:50:44][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-08 12:50:44][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:50:44][DEBUG] jax_fem: Function split_and_compute_cell took 0.0417 seconds\n", + "[11-08 12:50:44][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:50:44][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:50:50][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 8.659976802830883e-08\n", + "[11-08 12:50:50][DEBUG] jax_fem: Computing cell residual...\n", + "[11-08 12:50:51][DEBUG] jax_fem: Function split_and_compute_cell took 0.4537 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[[-0.01913965 -0.00495254 0.14051446]\n", + " [-0.01442383 -0.04631163 0.16035034]\n", + " [ 0.00401149 -0.04566568 0.04064847]\n", + " [-0.01269086 -0.00439809 0.07995077]]\n", + "\n", + " [[ 0.08071414 -0.01627608 -0.30038655]\n", + " [-0.00458883 0.00265121 -0.3434814 ]\n", + " [-0.01156829 0.00320956 -0.08621974]\n", + " [ 0.02214782 0.0194936 0.03850166]]\n", + "\n", + " [[ 0.01722336 0.00861178 0.17219217]\n", + " [ 0.00615137 0.03367195 0.20843688]\n", + " [-0.00120181 0.02050811 0.05748609]\n", + " [ 0.01644441 0.00143261 0.09959424]]]\n", + "[[[-10. -2.8690183 -0.9794336 ]\n", + " [ -3.3333333 -2.838396 -0.36378464]\n", + " [ 3.3333333 -2.8373706 0.08037174]\n", + " [ 10. -2.9119713 -0.39105994]]\n", + "\n", + " [[-10. -0.19829759 1.0986079 ]\n", + " [ -3.3333333 0.12837584 1.0659883 ]\n", + " [ 3.3333333 0.10221738 0.5957956 ]\n", + " [ 10. 0.6749784 -0.35860142]]\n", + "\n", + " [[-10. 2.6384518 -0.8820438 ]\n", + " [ -3.3333333 2.759201 -0.64427567]\n", + " [ 3.3333333 2.1809995 -1.0578729 ]\n", + " [ 10. 2.724852 -0.6834953 ]]]\n", + "Iteration 18, Loss: 16455.13\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-08 12:51:14][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:51:14][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:51:14][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:51:16][DEBUG] jax_fem: Done pre-computations, took 1.5831830501556396 [s]\n", + "[11-08 12:51:16][INFO] jax_fem: Solving a problem with 4370 cells, 5538x3 = 16614 dofs.\n", + "[11-08 12:51:16][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:51:17][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:51:17][DEBUG] jax_fem: Start timing\n", + "[11-08 12:51:17][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:51:18][DEBUG] jax_fem: Function split_and_compute_cell took 0.5083 seconds\n", + "[11-08 12:51:19][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:51:19][DEBUG] jax_fem: Before, l_2 res = 173.81715204130467, relative l_2 res = 1.0\n", + "[11-08 12:51:19][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:51:19][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:51:25][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 1.865210661783317e-09\n", + "[11-08 12:51:25][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:51:25][DEBUG] jax_fem: Function split_and_compute_cell took 0.0450 seconds\n", + "[11-08 12:51:25][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:51:25][DEBUG] jax_fem: l_2 res = 1.887499509105425e-09, relative l_2 res = 1.0859109627206946e-11\n", + "[11-08 12:51:25][INFO] jax_fem: Solve took 7.629403591156006 [s]\n", + "[11-08 12:51:25][INFO] jax_fem: max of dofs = 5.0944133293697345\n", + "[11-08 12:51:25][INFO] jax_fem: min of dofs = -18.055914227242347\n", + "[11-08 12:51:25][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:51:25][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:51:25][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:51:27][DEBUG] jax_fem: Done pre-computations, took 1.6805346012115479 [s]\n", + "[11-08 12:51:27][INFO] jax_fem: Solving a problem with 4370 cells, 5538x3 = 16614 dofs.\n", + "[11-08 12:51:27][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:51:29][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:51:29][DEBUG] jax_fem: Start timing\n", + "[11-08 12:51:29][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:51:29][DEBUG] jax_fem: Function split_and_compute_cell took 0.5377 seconds\n", + "[11-08 12:51:31][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:51:31][DEBUG] jax_fem: Before, l_2 res = 173.81715204130467, relative l_2 res = 1.0\n", + "[11-08 12:51:31][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:51:31][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:51:36][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 1.865210661783317e-09\n", + "[11-08 12:51:36][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:51:36][DEBUG] jax_fem: Function split_and_compute_cell took 0.0409 seconds\n", + "[11-08 12:51:36][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:51:36][DEBUG] jax_fem: l_2 res = 1.887499509105425e-09, relative l_2 res = 1.0859109627206946e-11\n", + "[11-08 12:51:36][INFO] jax_fem: Solve took 7.722974538803101 [s]\n", + "[11-08 12:51:36][INFO] jax_fem: max of dofs = 5.0944133293697345\n", + "[11-08 12:51:36][INFO] jax_fem: min of dofs = -18.055914227242347\n", + "[11-08 12:51:37][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-08 12:51:37][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:51:37][DEBUG] jax_fem: Function split_and_compute_cell took 0.0415 seconds\n", + "[11-08 12:51:37][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:51:37][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:51:43][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 1.1705854300876114e-07\n", + "[11-08 12:51:44][DEBUG] jax_fem: Computing cell residual...\n", + "[11-08 12:51:44][DEBUG] jax_fem: Function split_and_compute_cell took 0.4502 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[[-1.87985450e-02 -3.04630594e-05 1.33371159e-01]\n", + " [-1.63266491e-02 -5.16522974e-02 1.58157021e-01]\n", + " [ 3.15626571e-03 -4.22243625e-02 3.80983837e-02]\n", + " [-1.18919555e-02 -4.52555390e-03 7.63310418e-02]]\n", + "\n", + " [[ 8.11176747e-02 -1.72371119e-02 -3.02263558e-01]\n", + " [-6.57443190e-03 9.51443240e-03 -3.34891498e-01]\n", + " [-1.24866925e-02 -4.09592502e-03 -8.52887556e-02]\n", + " [ 1.79207772e-02 2.14519165e-02 3.44750658e-02]]\n", + "\n", + " [[ 1.58026740e-02 7.47234793e-03 1.61650389e-01]\n", + " [ 5.66570507e-03 3.31264324e-02 2.12015450e-01]\n", + " [-1.79066998e-03 1.50849316e-02 4.74191085e-02]\n", + " [ 1.48651879e-02 1.15001539e-03 9.96681228e-02]]]\n", + "[[[-10. -2.8553228 -1.0495974 ]\n", + " [ -3.3333333 -2.8433282 -0.35345536]\n", + " [ 3.3333333 -2.8298728 0.09074048]\n", + " [ 10. -2.901693 -0.3785396 ]]\n", + "\n", + " [[-10. -0.21848097 1.1278825 ]\n", + " [ -3.3333333 0.15289606 1.0964026 ]\n", + " [ 3.3333333 0.12557536 0.6290748 ]\n", + " [ 10. 0.70030457 -0.34046432]]\n", + "\n", + " [[-10. 2.6320596 -0.89529884]\n", + " [ -3.3333333 2.7444196 -0.6619165 ]\n", + " [ 3.3333333 2.1527927 -1.0865049 ]\n", + " [ 10. 2.6994216 -0.66253537]]]\n", + "Iteration 19, Loss: 16156.92\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-08 12:52:09][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:52:09][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:52:09][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:52:11][DEBUG] jax_fem: Done pre-computations, took 1.5565919876098633 [s]\n", + "[11-08 12:52:11][INFO] jax_fem: Solving a problem with 4419 cells, 5592x3 = 16776 dofs.\n", + "[11-08 12:52:11][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:52:12][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:52:12][DEBUG] jax_fem: Start timing\n", + "[11-08 12:52:12][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:52:13][DEBUG] jax_fem: Function split_and_compute_cell took 0.5578 seconds\n", + "[11-08 12:52:14][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:52:14][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:52:14][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:52:14][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:52:19][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 2.2334069412596605e-09\n", + "[11-08 12:52:19][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:52:20][DEBUG] jax_fem: Function split_and_compute_cell took 0.0447 seconds\n", + "[11-08 12:52:20][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:52:20][DEBUG] jax_fem: l_2 res = 2.2200513398071037e-09, relative l_2 res = 1.2772337561252565e-11\n", + "[11-08 12:52:20][INFO] jax_fem: Solve took 7.4992406368255615 [s]\n", + "[11-08 12:52:20][INFO] jax_fem: max of dofs = 4.97883732752758\n", + "[11-08 12:52:20][INFO] jax_fem: min of dofs = -17.759860842892174\n", + "[11-08 12:52:20][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:52:20][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:52:20][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:52:22][DEBUG] jax_fem: Done pre-computations, took 1.774066686630249 [s]\n", + "[11-08 12:52:22][INFO] jax_fem: Solving a problem with 4419 cells, 5592x3 = 16776 dofs.\n", + "[11-08 12:52:22][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:52:23][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:52:23][DEBUG] jax_fem: Start timing\n", + "[11-08 12:52:23][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:52:24][DEBUG] jax_fem: Function split_and_compute_cell took 0.5707 seconds\n", + "[11-08 12:52:25][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:52:25][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:52:25][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:52:26][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:52:31][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 2.2334069412596605e-09\n", + "[11-08 12:52:31][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:52:31][DEBUG] jax_fem: Function split_and_compute_cell took 0.0427 seconds\n", + "[11-08 12:52:31][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:52:31][DEBUG] jax_fem: l_2 res = 2.2200513398071037e-09, relative l_2 res = 1.2772337561252565e-11\n", + "[11-08 12:52:31][INFO] jax_fem: Solve took 7.538548946380615 [s]\n", + "[11-08 12:52:31][INFO] jax_fem: max of dofs = 4.97883732752758\n", + "[11-08 12:52:31][INFO] jax_fem: min of dofs = -17.759860842892174\n", + "[11-08 12:52:31][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-08 12:52:31][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:52:31][DEBUG] jax_fem: Function split_and_compute_cell took 0.0419 seconds\n", + "[11-08 12:52:31][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:52:31][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:52:37][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 6.573871574507232e-08\n", + "[11-08 12:52:38][DEBUG] jax_fem: Computing cell residual...\n", + "[11-08 12:52:38][DEBUG] jax_fem: Function split_and_compute_cell took 0.4809 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[[-1.98499523e-02 -1.34920032e-04 1.29276499e-01]\n", + " [-1.54141225e-02 -4.56472710e-02 1.55373648e-01]\n", + " [ 4.65319399e-03 -4.17367779e-02 3.75083387e-02]\n", + " [-1.06861265e-02 -4.64492524e-03 7.81986713e-02]]\n", + "\n", + " [[ 6.01915009e-02 -2.02508848e-02 -2.93056786e-01]\n", + " [-5.88127039e-03 7.77557166e-03 -3.20749879e-01]\n", + " [-1.07697602e-02 6.29624724e-03 -8.16774145e-02]\n", + " [ 1.88852288e-02 2.21792553e-02 3.38849574e-02]]\n", + "\n", + " [[ 1.83418933e-02 7.93265086e-03 1.62532195e-01]\n", + " [ 6.88723242e-03 3.41274627e-02 1.99931160e-01]\n", + " [-1.22778933e-03 1.86534245e-02 5.41538373e-02]\n", + " [ 2.05782019e-02 4.50712489e-03 1.03829458e-01]]]\n", + "[[[-10. -2.8429043 -1.1191951 ]\n", + " [ -3.3333333 -2.8469574 -0.34469184]\n", + " [ 3.3333333 -2.8213801 0.09815931]\n", + " [ 10. -2.8923497 -0.36910066]]\n", + "\n", + " [[-10. -0.2365795 1.1547021 ]\n", + " [ -3.3333333 0.1750863 1.1243246 ]\n", + " [ 3.3333333 0.14675611 0.6599213 ]\n", + " [ 10. 0.722698 -0.3244605 ]]\n", + "\n", + " [[-10. 2.626256 -0.90754634]\n", + " [ -3.3333333 2.730897 -0.6781162 ]\n", + " [ 3.3333333 2.1270063 -1.1126299 ]\n", + " [ 10. 2.6763551 -0.6437619 ]]]\n", + "Iteration 20, Loss: 15878.12\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-08 12:53:03][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:53:03][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:53:03][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:53:05][DEBUG] jax_fem: Done pre-computations, took 1.2959883213043213 [s]\n", + "[11-08 12:53:05][INFO] jax_fem: Solving a problem with 4405 cells, 5579x3 = 16737 dofs.\n", + "[11-08 12:53:05][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:53:06][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:53:06][DEBUG] jax_fem: Start timing\n", + "[11-08 12:53:06][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:53:07][DEBUG] jax_fem: Function split_and_compute_cell took 0.5215 seconds\n", + "[11-08 12:53:07][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:53:08][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:53:08][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:53:08][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:53:13][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 2.0966364688224547e-09\n", + "[11-08 12:53:13][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:53:13][DEBUG] jax_fem: Function split_and_compute_cell took 0.0463 seconds\n", + "[11-08 12:53:13][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:53:13][DEBUG] jax_fem: l_2 res = 2.0890945830373803e-09, relative l_2 res = 1.2018920794082177e-11\n", + "[11-08 12:53:13][INFO] jax_fem: Solve took 7.232414484024048 [s]\n", + "[11-08 12:53:13][INFO] jax_fem: max of dofs = 4.8712369797858415\n", + "[11-08 12:53:13][INFO] jax_fem: min of dofs = -17.48262297226628\n", + "[11-08 12:53:14][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:53:14][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:53:14][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:53:15][DEBUG] jax_fem: Done pre-computations, took 1.492473840713501 [s]\n", + "[11-08 12:53:15][INFO] jax_fem: Solving a problem with 4405 cells, 5579x3 = 16737 dofs.\n", + "[11-08 12:53:15][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:53:17][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:53:17][DEBUG] jax_fem: Start timing\n", + "[11-08 12:53:17][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:53:17][DEBUG] jax_fem: Function split_and_compute_cell took 0.5105 seconds\n", + "[11-08 12:53:18][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:53:18][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:53:18][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:53:18][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:53:24][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 2.0966364688224547e-09\n", + "[11-08 12:53:24][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:53:24][DEBUG] jax_fem: Function split_and_compute_cell took 0.0399 seconds\n", + "[11-08 12:53:24][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:53:24][DEBUG] jax_fem: l_2 res = 2.0890945830373803e-09, relative l_2 res = 1.2018920794082177e-11\n", + "[11-08 12:53:24][INFO] jax_fem: Solve took 7.11728310585022 [s]\n", + "[11-08 12:53:24][INFO] jax_fem: max of dofs = 4.8712369797858415\n", + "[11-08 12:53:24][INFO] jax_fem: min of dofs = -17.48262297226628\n", + "[11-08 12:53:24][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-08 12:53:24][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:53:24][DEBUG] jax_fem: Function split_and_compute_cell took 0.0418 seconds\n", + "[11-08 12:53:24][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:53:24][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:53:30][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 9.12162687384475e-08\n", + "[11-08 12:53:30][DEBUG] jax_fem: Computing cell residual...\n", + "[11-08 12:53:33][DEBUG] jax_fem: Function split_and_compute_cell took 2.5368 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[[-0.02186747 0.00388255 0.12422065]\n", + " [-0.01534358 -0.04874663 0.1519082 ]\n", + " [ 0.00602662 -0.0386022 0.03640281]\n", + " [-0.00683737 -0.00791427 0.07814982]]\n", + "\n", + " [[ 0.06844922 -0.01638587 -0.28049615]\n", + " [-0.00552136 0.0084381 -0.31276798]\n", + " [-0.00918283 0.00489379 -0.06851669]\n", + " [ 0.01788568 0.02096906 0.03286552]]\n", + "\n", + " [[ 0.01942851 0.00915167 0.1589159 ]\n", + " [ 0.00734015 0.02773844 0.20462674]\n", + " [-0.00283142 0.01636824 0.0431789 ]\n", + " [ 0.02146957 0.00149932 0.10290939]]]\n", + "[[[-10. -2.8316216 -1.1881596 ]\n", + " [ -3.3333333 -2.8495002 -0.33733654]\n", + " [ 3.3333333 -2.8119886 0.10292784]\n", + " [ 10. -2.8838475 -0.36250776]]\n", + "\n", + " [[-10. -0.25276214 1.179305 ]\n", + " [ -3.3333333 0.19518341 1.1499907 ]\n", + " [ 3.3333333 0.16595528 0.6885566 ]\n", + " [ 10. 0.74242204 -0.31037715]]\n", + "\n", + " [[-10. 2.6209822 -0.9188906 ]\n", + " [ -3.3333333 2.7185032 -0.69300836]\n", + " [ 3.3333333 2.1033456 -1.1365229 ]\n", + " [ 10. 2.6553736 -0.6269709 ]]]\n", + "Iteration 21, Loss: 15620.92\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-08 12:53:57][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:53:57][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:53:57][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:53:58][DEBUG] jax_fem: Done pre-computations, took 1.5878610610961914 [s]\n", + "[11-08 12:53:58][INFO] jax_fem: Solving a problem with 4454 cells, 5640x3 = 16920 dofs.\n", + "[11-08 12:53:58][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:54:00][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:54:00][DEBUG] jax_fem: Start timing\n", + "[11-08 12:54:00][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:54:01][DEBUG] jax_fem: Function split_and_compute_cell took 0.5316 seconds\n", + "[11-08 12:54:02][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:54:02][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:54:02][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:54:02][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:54:06][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 2.3629945355356627e-09\n", + "[11-08 12:54:06][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:54:07][DEBUG] jax_fem: Function split_and_compute_cell took 0.0495 seconds\n", + "[11-08 12:54:07][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:54:07][DEBUG] jax_fem: l_2 res = 2.4020339644452902e-09, relative l_2 res = 1.3819314930867627e-11\n", + "[11-08 12:54:07][INFO] jax_fem: Solve took 6.849005222320557 [s]\n", + "[11-08 12:54:07][INFO] jax_fem: max of dofs = 4.782490563166226\n", + "[11-08 12:54:07][INFO] jax_fem: min of dofs = -17.249277634706026\n", + "[11-08 12:54:07][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:54:07][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:54:07][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:54:09][DEBUG] jax_fem: Done pre-computations, took 1.7770612239837646 [s]\n", + "[11-08 12:54:09][INFO] jax_fem: Solving a problem with 4454 cells, 5640x3 = 16920 dofs.\n", + "[11-08 12:54:09][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:54:10][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:54:10][DEBUG] jax_fem: Start timing\n", + "[11-08 12:54:10][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:54:11][DEBUG] jax_fem: Function split_and_compute_cell took 0.5612 seconds\n", + "[11-08 12:54:12][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:54:12][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:54:12][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:54:13][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:54:17][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 2.3629945355356627e-09\n", + "[11-08 12:54:17][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:54:17][DEBUG] jax_fem: Function split_and_compute_cell took 0.0419 seconds\n", + "[11-08 12:54:17][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:54:17][DEBUG] jax_fem: l_2 res = 2.4020339644452902e-09, relative l_2 res = 1.3819314930867627e-11\n", + "[11-08 12:54:17][INFO] jax_fem: Solve took 6.851773500442505 [s]\n", + "[11-08 12:54:17][INFO] jax_fem: max of dofs = 4.782490563166226\n", + "[11-08 12:54:17][INFO] jax_fem: min of dofs = -17.249277634706026\n", + "[11-08 12:54:18][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-08 12:54:18][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:54:18][DEBUG] jax_fem: Function split_and_compute_cell took 0.0421 seconds\n", + "[11-08 12:54:18][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:54:18][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:54:21][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 1.0021841828298648e-07\n", + "[11-08 12:54:22][DEBUG] jax_fem: Computing cell residual...\n", + "[11-08 12:54:22][DEBUG] jax_fem: Function split_and_compute_cell took 0.5303 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[[-0.02265018 0.0025494 0.11841706]\n", + " [-0.01593976 -0.05515634 0.14501004]\n", + " [ 0.00475607 -0.0386712 0.03501187]\n", + " [-0.00753694 -0.0067795 0.07740001]]\n", + "\n", + " [[ 0.0777158 -0.01216696 -0.28371602]\n", + " [-0.00455337 0.01785823 -0.31317082]\n", + " [-0.00877582 0.01342454 -0.07116799]\n", + " [ 0.01294155 0.02063247 0.0338147 ]]\n", + "\n", + " [[ 0.02000179 0.01518987 0.15701899]\n", + " [ 0.00789535 0.03737549 0.20666742]\n", + " [-0.00367855 0.0293255 0.05581359]\n", + " [ 0.02068099 0.00396124 0.10572752]]]\n", + "[[[-10. -2.8219352 -1.2563872 ]\n", + " [ -3.3333333 -2.8510013 -0.3312466 ]\n", + " [ 3.3333333 -2.8018923 0.10534021]\n", + " [ 10. -2.8760846 -0.35850453]]\n", + "\n", + " [[-10. -0.2672574 1.2018989 ]\n", + " [ -3.3333333 0.21338834 1.1736168 ]\n", + " [ 3.3333333 0.18336844 0.7150985 ]\n", + " [ 10. 0.7597617 -0.29801968]]\n", + "\n", + " [[-10. 2.6161847 -0.9294174 ]\n", + " [ -3.3333333 2.7071507 -0.7067277 ]\n", + " [ 3.3333333 2.0816338 -1.1583637 ]\n", + " [ 10. 2.6363132 -0.6119703 ]]]\n", + "Iteration 22, Loss: 15405.93\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-08 12:54:47][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:54:47][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:54:47][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:54:48][DEBUG] jax_fem: Done pre-computations, took 1.545468807220459 [s]\n", + "[11-08 12:54:48][INFO] jax_fem: Solving a problem with 4440 cells, 5626x3 = 16878 dofs.\n", + "[11-08 12:54:48][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:54:50][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:54:50][DEBUG] jax_fem: Start timing\n", + "[11-08 12:54:50][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:54:50][DEBUG] jax_fem: Function split_and_compute_cell took 0.2502 seconds\n", + "[11-08 12:54:51][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:54:52][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:54:52][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:54:52][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:55:01][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 6.815611629641128e-08\n", + "[11-08 12:55:01][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:55:01][DEBUG] jax_fem: Function split_and_compute_cell took 0.0452 seconds\n", + "[11-08 12:55:01][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:55:01][DEBUG] jax_fem: l_2 res = 6.822808886254315e-08, relative l_2 res = 3.9252794135258817e-10\n", + "[11-08 12:55:01][INFO] jax_fem: Solve took 11.275623083114624 [s]\n", + "[11-08 12:55:01][INFO] jax_fem: max of dofs = 184.6195534809326\n", + "[11-08 12:55:01][INFO] jax_fem: min of dofs = -178.3280532027349\n", + "[11-08 12:55:01][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:55:01][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:55:01][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:55:03][DEBUG] jax_fem: Done pre-computations, took 1.7127711772918701 [s]\n", + "[11-08 12:55:03][INFO] jax_fem: Solving a problem with 4440 cells, 5626x3 = 16878 dofs.\n", + "[11-08 12:55:03][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:55:05][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:55:05][DEBUG] jax_fem: Start timing\n", + "[11-08 12:55:05][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:55:05][DEBUG] jax_fem: Function split_and_compute_cell took 0.2604 seconds\n", + "[11-08 12:55:06][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:55:06][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:55:06][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:55:07][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:55:16][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 6.815611629641128e-08\n", + "[11-08 12:55:16][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:55:16][DEBUG] jax_fem: Function split_and_compute_cell took 0.0406 seconds\n", + "[11-08 12:55:16][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:55:16][DEBUG] jax_fem: l_2 res = 6.822808886254315e-08, relative l_2 res = 3.9252794135258817e-10\n", + "[11-08 12:55:16][INFO] jax_fem: Solve took 11.156622171401978 [s]\n", + "[11-08 12:55:16][INFO] jax_fem: max of dofs = 184.6195534809326\n", + "[11-08 12:55:16][INFO] jax_fem: min of dofs = -178.3280532027349\n", + "[11-08 12:55:16][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-08 12:55:16][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:55:16][DEBUG] jax_fem: Function split_and_compute_cell took 0.0414 seconds\n", + "[11-08 12:55:16][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:55:16][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:55:26][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 1.5809723647252634e-06\n", + "[11-08 12:55:26][DEBUG] jax_fem: Computing cell residual...\n", + "[11-08 12:55:27][DEBUG] jax_fem: Function split_and_compute_cell took 0.2602 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[[-1.5903565e+00 -1.8832835e+00 -4.8466331e-01]\n", + " [ 2.8668995e+00 2.6249611e+01 -1.7427498e+01]\n", + " [-4.7652300e-02 -3.2319984e-01 -9.8123956e-01]\n", + " [-6.4719522e-01 -2.8909740e-01 1.3542323e-01]]\n", + "\n", + " [[ 5.9280162e+00 5.1396360e+00 3.4174190e+00]\n", + " [ 1.6198188e-01 -5.9985471e-01 2.0362951e+01]\n", + " [ 2.7346489e+00 2.0915724e+01 1.6419977e+01]\n", + " [ 1.5608034e+01 -1.3998454e+00 -3.0588150e-01]]\n", + "\n", + " [[ 5.3210449e+00 -2.0384362e+00 5.7428160e+00]\n", + " [-4.3845735e-02 -2.9623864e+00 1.3927297e+01]\n", + " [-9.0832776e-01 1.5070125e+02 2.5953030e+01]\n", + " [ 5.5140686e+00 3.1812771e+01 -4.6047039e+00]]]\n", + "[[[-10. -2.8135068 -1.3237491 ]\n", + " [ -3.3333333 -2.8514438 -0.32628092]\n", + " [ 3.3333333 -2.7911377 0.10567544]\n", + " [ 10. -2.8689961 -0.3568444 ]]\n", + "\n", + " [[-10. -0.28027433 1.2226834 ]\n", + " [ -3.3333333 0.22984573 1.1954036 ]\n", + " [ 3.3333333 0.19915038 0.73977685]\n", + " [ 10. 0.77494824 -0.28723982]]\n", + "\n", + " [[-10. 2.61181 -0.93920535]\n", + " [ -3.3333333 2.6967013 -0.7193915 ]\n", + " [ 3.3333333 2.0614886 -1.1783984 ]\n", + " [ 10. 2.618956 -0.5985976 ]]]\n", + "Iteration 23, Loss: 28560.32\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-08 12:55:47][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:55:47][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:55:47][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:55:49][DEBUG] jax_fem: Done pre-computations, took 1.3260083198547363 [s]\n", + "[11-08 12:55:49][INFO] jax_fem: Solving a problem with 4454 cells, 5643x3 = 16929 dofs.\n", + "[11-08 12:55:49][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:55:49][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:55:49][DEBUG] jax_fem: Start timing\n", + "[11-08 12:55:49][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:55:49][DEBUG] jax_fem: Function split_and_compute_cell took 0.3957 seconds\n", + "[11-08 12:55:49][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:55:50][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:55:50][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:55:50][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:55:55][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 2.360855374672291e-09\n", + "[11-08 12:55:55][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:55:55][DEBUG] jax_fem: Function split_and_compute_cell took 0.0459 seconds\n", + "[11-08 12:55:55][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:55:55][DEBUG] jax_fem: l_2 res = 2.354954055088299e-09, relative l_2 res = 1.3548456107074428e-11\n", + "[11-08 12:55:55][INFO] jax_fem: Solve took 6.276998281478882 [s]\n", + "[11-08 12:55:55][INFO] jax_fem: max of dofs = 4.728221130058506\n", + "[11-08 12:55:55][INFO] jax_fem: min of dofs = -17.000433900069506\n", + "[11-08 12:55:55][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:55:55][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:55:55][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:55:57][DEBUG] jax_fem: Done pre-computations, took 1.5020506381988525 [s]\n", + "[11-08 12:55:57][INFO] jax_fem: Solving a problem with 4454 cells, 5643x3 = 16929 dofs.\n", + "[11-08 12:55:57][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:55:57][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:55:57][DEBUG] jax_fem: Start timing\n", + "[11-08 12:55:57][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:55:57][DEBUG] jax_fem: Function split_and_compute_cell took 0.3633 seconds\n", + "[11-08 12:55:57][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:55:58][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:55:58][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:55:58][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:56:03][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 2.360855374672291e-09\n", + "[11-08 12:56:03][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:56:03][DEBUG] jax_fem: Function split_and_compute_cell took 0.0418 seconds\n", + "[11-08 12:56:03][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:56:03][DEBUG] jax_fem: l_2 res = 2.354954055088299e-09, relative l_2 res = 1.3548456107074428e-11\n", + "[11-08 12:56:03][INFO] jax_fem: Solve took 6.223349094390869 [s]\n", + "[11-08 12:56:03][INFO] jax_fem: max of dofs = 4.728221130058506\n", + "[11-08 12:56:03][INFO] jax_fem: min of dofs = -17.000433900069506\n", + "[11-08 12:56:03][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-08 12:56:03][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:56:03][DEBUG] jax_fem: Function split_and_compute_cell took 0.0414 seconds\n", + "[11-08 12:56:03][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:56:03][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:56:07][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 5.0947296963556194e-08\n", + "[11-08 12:56:07][DEBUG] jax_fem: Computing cell residual...\n", + "[11-08 12:56:07][DEBUG] jax_fem: Function split_and_compute_cell took 0.3396 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[[-0.02379097 0.0063972 0.11494686]\n", + " [-0.01621479 -0.05727733 0.14510378]\n", + " [ 0.00440974 -0.0380998 0.03570368]\n", + " [-0.00969266 -0.00113207 0.07764787]]\n", + "\n", + " [[ 0.06955243 -0.01559405 -0.2783562 ]\n", + " [-0.00647195 0.01234014 -0.29223418]\n", + " [-0.01108348 0.0177744 -0.08021867]\n", + " [ 0.0235079 0.02530812 0.02526428]]\n", + "\n", + " [[ 0.01586297 0.01566526 0.15055428]\n", + " [ 0.00834993 0.03476628 0.19314928]\n", + " [-0.00393776 0.01950947 0.04736659]\n", + " [ 0.01671265 0.00186443 0.10847297]]]\n", + "[[[-10. -2.7635462 -1.3569067 ]\n", + " [ -3.3333333 -2.9005702 -0.28363147]\n", + " [ 3.3333333 -2.7687445 0.14182642]\n", + " [ 10. -2.8607998 -0.3588119 ]]\n", + "\n", + " [[-10. -0.32603228 1.2382021 ]\n", + " [ -3.3333333 0.2471307 1.1931769 ]\n", + " [ 3.3333333 0.1784279 0.7009987 ]\n", + " [ 10. 0.81596553 -0.27349567]]\n", + "\n", + " [[-10. 2.6104732 -0.9563834 ]\n", + " [ -3.3333333 2.6986237 -0.74410594]\n", + " [ 3.3333333 2.0117128 -1.2306675 ]\n", + " [ 10. 2.5681021 -0.5762076 ]]]\n", + "Iteration 24, Loss: 15198.38\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-08 12:56:27][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:56:27][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:56:27][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:56:28][DEBUG] jax_fem: Done pre-computations, took 1.3285248279571533 [s]\n", + "[11-08 12:56:28][INFO] jax_fem: Solving a problem with 4468 cells, 5654x3 = 16962 dofs.\n", + "[11-08 12:56:28][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:56:30][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:56:30][DEBUG] jax_fem: Start timing\n", + "[11-08 12:56:30][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:56:31][DEBUG] jax_fem: Function split_and_compute_cell took 0.5452 seconds\n", + "[11-08 12:56:31][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:56:32][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:56:32][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:56:32][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:56:35][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 2.53932040769926e-09\n", + "[11-08 12:56:35][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:56:36][DEBUG] jax_fem: Function split_and_compute_cell took 0.0468 seconds\n", + "[11-08 12:56:36][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:56:36][DEBUG] jax_fem: l_2 res = 2.5200003017034607e-09, relative l_2 res = 1.4497995578161501e-11\n", + "[11-08 12:56:36][INFO] jax_fem: Solve took 5.693677663803101 [s]\n", + "[11-08 12:56:36][INFO] jax_fem: max of dofs = 4.751479909258619\n", + "[11-08 12:56:36][INFO] jax_fem: min of dofs = -16.948867908468614\n", + "[11-08 12:56:36][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:56:36][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:56:36][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:56:37][DEBUG] jax_fem: Done pre-computations, took 1.5314834117889404 [s]\n", + "[11-08 12:56:37][INFO] jax_fem: Solving a problem with 4468 cells, 5654x3 = 16962 dofs.\n", + "[11-08 12:56:37][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:56:39][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:56:39][DEBUG] jax_fem: Start timing\n", + "[11-08 12:56:39][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:56:40][DEBUG] jax_fem: Function split_and_compute_cell took 0.5338 seconds\n", + "[11-08 12:56:41][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:56:41][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:56:41][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:56:41][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:56:45][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 2.53932040769926e-09\n", + "[11-08 12:56:45][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:56:45][DEBUG] jax_fem: Function split_and_compute_cell took 0.0417 seconds\n", + "[11-08 12:56:45][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:56:45][DEBUG] jax_fem: l_2 res = 2.5200003017034607e-09, relative l_2 res = 1.4497995578161501e-11\n", + "[11-08 12:56:45][INFO] jax_fem: Solve took 5.676889657974243 [s]\n", + "[11-08 12:56:45][INFO] jax_fem: max of dofs = 4.751479909258619\n", + "[11-08 12:56:45][INFO] jax_fem: min of dofs = -16.948867908468614\n", + "[11-08 12:56:45][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-08 12:56:45][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:56:45][DEBUG] jax_fem: Function split_and_compute_cell took 0.0431 seconds\n", + "[11-08 12:56:45][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:56:45][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:56:49][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 6.144953031681396e-08\n", + "[11-08 12:56:49][DEBUG] jax_fem: Computing cell residual...\n", + "[11-08 12:56:50][DEBUG] jax_fem: Function split_and_compute_cell took 0.4887 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[[-0.0259162 0.00908725 0.11001582]\n", + " [-0.01997831 -0.05504495 0.14477603]\n", + " [ 0.00590756 -0.03827189 0.0358138 ]\n", + " [-0.01442323 -0.00089331 0.07723057]]\n", + "\n", + " [[ 0.0730278 -0.0258598 -0.264029 ]\n", + " [-0.00900441 0.02974069 -0.29815966]\n", + " [-0.0106717 0.01314205 -0.07178175]\n", + " [ 0.01725569 0.02596756 0.0230396 ]]\n", + "\n", + " [[ 0.01496806 0.01582916 0.14811575]\n", + " [ 0.00977657 0.0365847 0.18774755]\n", + " [-0.00291106 0.00669263 0.04536525]\n", + " [ 0.0190422 0.00529206 0.11250916]]]\n", + "[[[-10. -2.718332 -1.3920416 ]\n", + " [ -3.3333333 -2.945085 -0.24522851]\n", + " [ 3.3333333 -2.7468712 0.17333266]\n", + " [ 10. -2.8533478 -0.36260477]]\n", + "\n", + " [[-10. -0.36747846 1.2525704 ]\n", + " [ -3.3333333 0.26278234 1.191448 ]\n", + " [ 3.3333333 0.15957776 0.6660045 ]\n", + " [ 10. 0.8526719 -0.261344 ]]\n", + "\n", + " [[-10. 2.6092386 -0.97220945]\n", + " [ -3.3333333 2.7002375 -0.766746 ]\n", + " [ 3.3333333 1.9664931 -1.2782264 ]\n", + " [ 10. 2.5219066 -0.55612046]]]\n", + "Iteration 25, Loss: 15179.56\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-08 12:57:15][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:57:15][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:57:15][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:57:16][DEBUG] jax_fem: Done pre-computations, took 1.3187880516052246 [s]\n", + "[11-08 12:57:16][INFO] jax_fem: Solving a problem with 4475 cells, 5658x3 = 16974 dofs.\n", + "[11-08 12:57:16][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:57:18][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:57:18][DEBUG] jax_fem: Start timing\n", + "[11-08 12:57:18][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:57:19][DEBUG] jax_fem: Function split_and_compute_cell took 0.5879 seconds\n", + "[11-08 12:57:19][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:57:19][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:57:19][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:57:20][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:57:27][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 4.5197218253147735e-08\n", + "[11-08 12:57:27][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:57:27][DEBUG] jax_fem: Function split_and_compute_cell took 0.0468 seconds\n", + "[11-08 12:57:27][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:57:27][DEBUG] jax_fem: l_2 res = 4.516793573706985e-08, relative l_2 res = 2.598589103930115e-10\n", + "[11-08 12:57:27][INFO] jax_fem: Solve took 9.498594999313354 [s]\n", + "[11-08 12:57:27][INFO] jax_fem: max of dofs = 50.62679404957042\n", + "[11-08 12:57:28][INFO] jax_fem: min of dofs = -137.3461738937681\n", + "[11-08 12:57:28][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:57:28][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:57:28][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:57:29][DEBUG] jax_fem: Done pre-computations, took 1.5233144760131836 [s]\n", + "[11-08 12:57:29][INFO] jax_fem: Solving a problem with 4475 cells, 5658x3 = 16974 dofs.\n", + "[11-08 12:57:29][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:57:31][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:57:31][DEBUG] jax_fem: Start timing\n", + "[11-08 12:57:31][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:57:32][DEBUG] jax_fem: Function split_and_compute_cell took 0.5634 seconds\n", + "[11-08 12:57:32][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:57:32][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:57:32][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:57:33][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:57:40][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 4.5197218253147735e-08\n", + "[11-08 12:57:40][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:57:40][DEBUG] jax_fem: Function split_and_compute_cell took 0.0424 seconds\n", + "[11-08 12:57:40][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:57:40][DEBUG] jax_fem: l_2 res = 4.516793573706985e-08, relative l_2 res = 2.598589103930115e-10\n", + "[11-08 12:57:40][INFO] jax_fem: Solve took 9.582236528396606 [s]\n", + "[11-08 12:57:40][INFO] jax_fem: max of dofs = 50.62679404957042\n", + "[11-08 12:57:41][INFO] jax_fem: min of dofs = -137.3461738937681\n", + "[11-08 12:57:41][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-08 12:57:41][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:57:41][DEBUG] jax_fem: Function split_and_compute_cell took 0.0435 seconds\n", + "[11-08 12:57:41][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:57:41][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:57:49][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 1.3692477333615126e-06\n", + "[11-08 12:57:49][DEBUG] jax_fem: Computing cell residual...\n", + "[11-08 12:57:50][DEBUG] jax_fem: Function split_and_compute_cell took 0.4370 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[[-1.2903625e+00 -7.5606781e-01 3.4670416e-01]\n", + " [-2.4880806e-02 -1.7204423e-01 1.2225298e+00]\n", + " [-5.9847139e-02 1.7278341e+00 -4.6796780e+00]\n", + " [-8.3543434e+00 7.5810142e+00 1.1478690e+00]]\n", + "\n", + " [[ 4.6220522e+00 -3.4450040e+00 2.7215114e-01]\n", + " [-1.3283044e+00 1.3990946e+01 -1.1373494e+01]\n", + " [-3.4077053e+01 4.3312309e+01 -7.1629990e+01]\n", + " [ 7.9140450e+01 8.3926216e+01 -6.8776039e+01]]\n", + "\n", + " [[-3.7692192e+01 -7.4620342e+00 -4.5729718e+00]\n", + " [ 1.0884892e+00 2.7934599e+01 -6.4059696e+00]\n", + " [ 3.9870176e+00 2.4437618e+01 -1.4152588e+01]\n", + " [-1.4505064e+02 -4.4905682e+01 -4.3174019e+01]]]\n", + "[[[-10. -2.6774945 -1.4287844 ]\n", + " [ -3.3333333 -2.985422 -0.21067888]\n", + " [ 3.3333333 -2.725446 0.20061034]\n", + " [ 10. -2.8465722 -0.36806145]]\n", + "\n", + " [[-10. -0.40493566 1.2658846 ]\n", + " [ -3.3333333 0.2768827 1.1901796 ]\n", + " [ 3.3333333 0.14243215 0.6344193 ]\n", + " [ 10. 0.88544905 -0.25061032]]\n", + "\n", + " [[-10. 2.6080961 -0.9868085 ]\n", + " [ -3.3333333 2.7015631 -0.7875019 ]\n", + " [ 3.3333333 1.925409 -1.3215119 ]\n", + " [ 10. 2.47993 -0.53813356]]]\n", + "Iteration 26, Loss: 28670.56\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-08 12:58:14][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:58:14][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:58:14][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:58:15][DEBUG] jax_fem: Done pre-computations, took 1.3200840950012207 [s]\n", + "[11-08 12:58:15][INFO] jax_fem: Solving a problem with 4489 cells, 5678x3 = 17034 dofs.\n", + "[11-08 12:58:15][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:58:17][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:58:17][DEBUG] jax_fem: Start timing\n", + "[11-08 12:58:17][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:58:18][DEBUG] jax_fem: Function split_and_compute_cell took 0.6033 seconds\n", + "[11-08 12:58:18][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:58:19][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:58:19][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:58:19][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:58:23][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 2.2457082175830275e-09\n", + "[11-08 12:58:24][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:58:24][DEBUG] jax_fem: Function split_and_compute_cell took 0.0483 seconds\n", + "[11-08 12:58:24][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:58:24][DEBUG] jax_fem: l_2 res = 2.2106865205089143e-09, relative l_2 res = 1.2718460143585727e-11\n", + "[11-08 12:58:24][INFO] jax_fem: Solve took 6.753411769866943 [s]\n", + "[11-08 12:58:24][INFO] jax_fem: max of dofs = 4.748708468381693\n", + "[11-08 12:58:24][INFO] jax_fem: min of dofs = -16.988586247961017\n", + "[11-08 12:58:24][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:58:24][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:58:24][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:58:26][DEBUG] jax_fem: Done pre-computations, took 1.5430107116699219 [s]\n", + "[11-08 12:58:26][INFO] jax_fem: Solving a problem with 4489 cells, 5678x3 = 17034 dofs.\n", + "[11-08 12:58:26][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:58:27][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:58:27][DEBUG] jax_fem: Start timing\n", + "[11-08 12:58:27][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:58:28][DEBUG] jax_fem: Function split_and_compute_cell took 0.5916 seconds\n", + "[11-08 12:58:29][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:58:29][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:58:29][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:58:29][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:58:34][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 2.2457082175830275e-09\n", + "[11-08 12:58:34][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:58:34][DEBUG] jax_fem: Function split_and_compute_cell took 0.0430 seconds\n", + "[11-08 12:58:34][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:58:34][DEBUG] jax_fem: l_2 res = 2.2106865205089143e-09, relative l_2 res = 1.2718460143585727e-11\n", + "[11-08 12:58:34][INFO] jax_fem: Solve took 6.731608867645264 [s]\n", + "[11-08 12:58:34][INFO] jax_fem: max of dofs = 4.748708468381693\n", + "[11-08 12:58:34][INFO] jax_fem: min of dofs = -16.988586247961017\n", + "[11-08 12:58:34][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-08 12:58:34][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:58:34][DEBUG] jax_fem: Function split_and_compute_cell took 0.0434 seconds\n", + "[11-08 12:58:34][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:58:34][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:58:38][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 6.386774099853727e-08\n", + "[11-08 12:58:39][DEBUG] jax_fem: Computing cell residual...\n", + "[11-08 12:58:39][DEBUG] jax_fem: Function split_and_compute_cell took 0.5000 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[[-0.02584672 0.01046246 0.10379546]\n", + " [-0.02274541 -0.06437728 0.14318007]\n", + " [ 0.00758335 -0.03714467 0.03388705]\n", + " [-0.01026485 -0.0023077 0.08125472]]\n", + "\n", + " [[ 0.06923272 -0.03260825 -0.25588194]\n", + " [-0.00775171 0.01935634 -0.2972005 ]\n", + " [-0.00837923 -0.00034524 -0.07109295]\n", + " [ 0.02277692 0.02830429 0.0206692 ]]\n", + "\n", + " [[ 0.02087939 0.02012961 0.14154156]\n", + " [ 0.01109592 0.0305598 0.19034125]\n", + " [-0.0028779 0.01330682 0.04581501]\n", + " [ 0.02461424 0.00626825 0.11284298]]]\n", + "[[[-10. -2.6243324 -1.475774 ]\n", + " [ -3.3333333 -3.0217407 -0.18221901]\n", + " [ 3.3333333 -2.7554753 0.25620833]\n", + " [ 10. -2.8767736 -0.39827895]]\n", + "\n", + " [[-10. -0.41170815 1.2777106 ]\n", + " [ -3.3333333 0.24768367 1.2004046 ]\n", + " [ 3.3333333 0.0925196 0.6769103 ]\n", + " [ 10. 0.8355614 -0.19943035]]\n", + "\n", + " [[-10. 2.6167977 -0.9931196 ]\n", + " [ -3.3333333 2.6561413 -0.79979783]\n", + " [ 3.3333333 1.8804331 -1.3346742 ]\n", + " [ 10. 2.499128 -0.48545688]]]\n", + "Iteration 27, Loss: 15096.28\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-08 12:59:03][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:59:03][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:59:03][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:59:05][DEBUG] jax_fem: Done pre-computations, took 1.3211302757263184 [s]\n", + "[11-08 12:59:05][INFO] jax_fem: Solving a problem with 4496 cells, 5688x3 = 17064 dofs.\n", + "[11-08 12:59:05][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:59:06][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:59:06][DEBUG] jax_fem: Start timing\n", + "[11-08 12:59:06][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:59:07][DEBUG] jax_fem: Function split_and_compute_cell took 0.5554 seconds\n", + "[11-08 12:59:08][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:59:08][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:59:08][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:59:08][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:59:13][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 2.0747302939341163e-09\n", + "[11-08 12:59:13][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:59:13][DEBUG] jax_fem: Function split_and_compute_cell took 0.0483 seconds\n", + "[11-08 12:59:13][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:59:13][DEBUG] jax_fem: l_2 res = 2.098014011982855e-09, relative l_2 res = 1.2070235804371582e-11\n", + "[11-08 12:59:13][INFO] jax_fem: Solve took 6.58288049697876 [s]\n", + "[11-08 12:59:13][INFO] jax_fem: max of dofs = 4.73990426471812\n", + "[11-08 12:59:13][INFO] jax_fem: min of dofs = -17.01939086394974\n", + "[11-08 12:59:13][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:59:13][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:59:13][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:59:15][DEBUG] jax_fem: Done pre-computations, took 1.542588233947754 [s]\n", + "[11-08 12:59:15][INFO] jax_fem: Solving a problem with 4496 cells, 5688x3 = 17064 dofs.\n", + "[11-08 12:59:15][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:59:16][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:59:16][DEBUG] jax_fem: Start timing\n", + "[11-08 12:59:16][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:59:17][DEBUG] jax_fem: Function split_and_compute_cell took 0.5363 seconds\n", + "[11-08 12:59:18][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:59:18][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:59:18][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:59:18][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:59:23][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 2.0747302939341163e-09\n", + "[11-08 12:59:23][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:59:23][DEBUG] jax_fem: Function split_and_compute_cell took 0.0423 seconds\n", + "[11-08 12:59:23][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:59:23][DEBUG] jax_fem: l_2 res = 2.098014011982855e-09, relative l_2 res = 1.2070235804371582e-11\n", + "[11-08 12:59:23][INFO] jax_fem: Solve took 6.548899412155151 [s]\n", + "[11-08 12:59:23][INFO] jax_fem: max of dofs = 4.73990426471812\n", + "[11-08 12:59:23][INFO] jax_fem: min of dofs = -17.01939086394974\n", + "[11-08 12:59:23][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-08 12:59:23][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:59:23][DEBUG] jax_fem: Function split_and_compute_cell took 0.0427 seconds\n", + "[11-08 12:59:23][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:59:23][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:59:27][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 6.805284311370756e-08\n", + "[11-08 12:59:28][DEBUG] jax_fem: Computing cell residual...\n", + "[11-08 12:59:28][DEBUG] jax_fem: Function split_and_compute_cell took 0.4428 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[[-0.02562347 0.01183107 0.10127895]\n", + " [-0.02258674 -0.06351811 0.14574252]\n", + " [ 0.0091405 -0.03726543 0.03490341]\n", + " [-0.00836967 -0.00514525 0.08561645]]\n", + "\n", + " [[ 0.06828149 -0.02991129 -0.25586915]\n", + " [-0.00576205 0.02179956 -0.29734185]\n", + " [-0.01312789 0.00159253 -0.07730395]\n", + " [ 0.02476523 0.02198047 0.01710089]]\n", + "\n", + " [[ 0.02395088 0.01978802 0.14176938]\n", + " [ 0.01037672 0.03289677 0.18235414]\n", + " [-0.00555686 0.01260471 0.03558563]\n", + " [ 0.02189184 0.00472295 0.10443082]]]\n", + "[[[-10. -2.5762863 -1.5228567 ]\n", + " [ -3.3333333 -3.054618 -0.15669927]\n", + " [ 3.3333333 -2.7818615 0.3063718 ]\n", + " [ 10. -2.9042065 -0.4275731 ]]\n", + "\n", + " [[-10. -0.41763836 1.288714 ]\n", + " [ -3.3333333 0.22109823 1.2099953 ]\n", + " [ 3.3333333 0.04716514 0.71557057]\n", + " [ 10. 0.790212 -0.15293923]]\n", + "\n", + " [[-10. 2.6246781 -0.9990679 ]\n", + " [ -3.3333333 2.6148164 -0.81116325]\n", + " [ 3.3333333 1.8395597 -1.3467072 ]\n", + " [ 10. 2.5165675 -0.43771023]]]\n", + "Iteration 28, Loss: 15044.43\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-08 12:59:48][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:59:48][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:59:48][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:59:49][DEBUG] jax_fem: Done pre-computations, took 1.364821195602417 [s]\n", + "[11-08 12:59:49][INFO] jax_fem: Solving a problem with 4496 cells, 5691x3 = 17073 dofs.\n", + "[11-08 12:59:49][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:59:49][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:59:49][DEBUG] jax_fem: Start timing\n", + "[11-08 12:59:49][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:59:50][DEBUG] jax_fem: Function split_and_compute_cell took 0.4260 seconds\n", + "[11-08 12:59:50][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:59:50][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:59:50][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:59:50][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 12:59:55][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 2.5353090750300913e-09\n", + "[11-08 12:59:55][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:59:55][DEBUG] jax_fem: Function split_and_compute_cell took 0.0472 seconds\n", + "[11-08 12:59:55][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:59:55][DEBUG] jax_fem: l_2 res = 2.5168966031255748e-09, relative l_2 res = 1.448013946591115e-11\n", + "[11-08 12:59:55][INFO] jax_fem: Solve took 5.87504243850708 [s]\n", + "[11-08 12:59:55][INFO] jax_fem: max of dofs = 4.727027994088206\n", + "[11-08 12:59:55][INFO] jax_fem: min of dofs = -16.991965949307463\n", + "[11-08 12:59:55][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 12:59:55][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 12:59:55][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 12:59:57][DEBUG] jax_fem: Done pre-computations, took 1.553823709487915 [s]\n", + "[11-08 12:59:57][INFO] jax_fem: Solving a problem with 4496 cells, 5691x3 = 17073 dofs.\n", + "[11-08 12:59:57][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 12:59:57][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 12:59:57][DEBUG] jax_fem: Start timing\n", + "[11-08 12:59:57][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 12:59:57][DEBUG] jax_fem: Function split_and_compute_cell took 0.3606 seconds\n", + "[11-08 12:59:58][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 12:59:58][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 12:59:58][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 12:59:58][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 13:00:02][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 2.5353090750300913e-09\n", + "[11-08 13:00:03][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:00:03][DEBUG] jax_fem: Function split_and_compute_cell took 0.0431 seconds\n", + "[11-08 13:00:03][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:00:03][DEBUG] jax_fem: l_2 res = 2.5168966031255748e-09, relative l_2 res = 1.448013946591115e-11\n", + "[11-08 13:00:03][INFO] jax_fem: Solve took 5.817667245864868 [s]\n", + "[11-08 13:00:03][INFO] jax_fem: max of dofs = 4.727027994088206\n", + "[11-08 13:00:03][INFO] jax_fem: min of dofs = -16.991965949307463\n", + "[11-08 13:00:03][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-08 13:00:03][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:00:03][DEBUG] jax_fem: Function split_and_compute_cell took 0.0437 seconds\n", + "[11-08 13:00:03][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:00:03][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 13:00:07][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 5.495953854075795e-08\n", + "[11-08 13:00:07][DEBUG] jax_fem: Computing cell residual...\n", + "[11-08 13:00:07][DEBUG] jax_fem: Function split_and_compute_cell took 0.3640 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[[-0.02860403 0.01388119 0.09613815]\n", + " [-0.0279188 -0.06925324 0.14118905]\n", + " [ 0.00884889 -0.04030168 0.03244134]\n", + " [-0.01359993 -0.00665794 0.08948442]]\n", + "\n", + " [[ 0.0680763 -0.02876165 -0.24883299]\n", + " [-0.0072698 0.00752561 -0.2915504 ]\n", + " [-0.01498802 -0.00390267 -0.07247447]\n", + " [ 0.02817333 0.02005964 0.01989364]]\n", + "\n", + " [[ 0.01478288 0.02096042 0.1361869 ]\n", + " [ 0.01111071 0.02574824 0.18554805]\n", + " [-0.00396478 0.00674736 0.03964265]\n", + " [ 0.01885718 0.00513347 0.10565896]]]\n", + "[[[-1.0000000e+01 -2.5329239e+00 -1.5699503e+00]\n", + " [-3.3333333e+00 -3.0843697e+00 -1.3385960e-01]\n", + " [ 3.3333333e+00 -2.8049276e+00 3.5158479e-01]\n", + " [ 1.0000000e+01 -2.9291115e+00 -4.5614508e-01]]\n", + "\n", + " [[-1.0000000e+01 -4.2281997e-01 1.2989732e+00]\n", + " [-3.3333333e+00 1.9687945e-01 1.2190129e+00]\n", + " [ 3.3333333e+00 5.9489571e-03 7.5075626e-01]\n", + " [ 1.0000000e+01 7.4898833e-01 -1.1070450e-01]]\n", + "\n", + " [[-1.0000000e+01 2.6318130e+00 -1.0046892e+00]\n", + " [-3.3333333e+00 2.5772085e+00 -8.2167727e-01]\n", + " [ 3.3333333e+00 1.8024127e+00 -1.3576988e+00]\n", + " [ 1.0000000e+01 2.5324106e+00 -3.9443371e-01]]]\n", + "Iteration 29, Loss: 14981.93\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-08 13:00:28][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 13:00:28][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 13:00:28][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 13:00:29][DEBUG] jax_fem: Done pre-computations, took 0.7551462650299072 [s]\n", + "[11-08 13:00:29][INFO] jax_fem: Solving a problem with 4482 cells, 5678x3 = 17034 dofs.\n", + "[11-08 13:00:29][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 13:00:30][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 13:00:30][DEBUG] jax_fem: Start timing\n", + "[11-08 13:00:30][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:00:31][DEBUG] jax_fem: Function split_and_compute_cell took 0.5394 seconds\n", + "[11-08 13:00:31][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:00:32][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 13:00:32][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 13:00:32][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 13:00:36][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 2.8326805801571874e-09\n", + "[11-08 13:00:36][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:00:36][DEBUG] jax_fem: Function split_and_compute_cell took 0.0501 seconds\n", + "[11-08 13:00:36][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:00:36][DEBUG] jax_fem: l_2 res = 2.8691806907777675e-09, relative l_2 res = 1.6506890471292242e-11\n", + "[11-08 13:00:36][INFO] jax_fem: Solve took 5.905391693115234 [s]\n", + "[11-08 13:00:36][INFO] jax_fem: max of dofs = 4.716938066149579\n", + "[11-08 13:00:36][INFO] jax_fem: min of dofs = -17.008120401300886\n", + "[11-08 13:00:36][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 13:00:36][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 13:00:36][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 13:00:37][DEBUG] jax_fem: Done pre-computations, took 0.7882392406463623 [s]\n", + "[11-08 13:00:37][INFO] jax_fem: Solving a problem with 4482 cells, 5678x3 = 17034 dofs.\n", + "[11-08 13:00:37][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 13:00:39][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 13:00:39][DEBUG] jax_fem: Start timing\n", + "[11-08 13:00:39][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:00:39][DEBUG] jax_fem: Function split_and_compute_cell took 0.5546 seconds\n", + "[11-08 13:00:40][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:00:40][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 13:00:40][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 13:00:40][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 13:00:44][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 2.8326805801571874e-09\n", + "[11-08 13:00:44][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:00:45][DEBUG] jax_fem: Function split_and_compute_cell took 0.0442 seconds\n", + "[11-08 13:00:45][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:00:45][DEBUG] jax_fem: l_2 res = 2.8691806907777675e-09, relative l_2 res = 1.6506890471292242e-11\n", + "[11-08 13:00:45][INFO] jax_fem: Solve took 5.919713973999023 [s]\n", + "[11-08 13:00:45][INFO] jax_fem: max of dofs = 4.716938066149579\n", + "[11-08 13:00:45][INFO] jax_fem: min of dofs = -17.008120401300886\n", + "[11-08 13:00:45][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-08 13:00:45][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:00:45][DEBUG] jax_fem: Function split_and_compute_cell took 0.0435 seconds\n", + "[11-08 13:00:45][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:00:45][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 13:00:49][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 5.555666007222526e-08\n", + "[11-08 13:00:49][DEBUG] jax_fem: Computing cell residual...\n", + "[11-08 13:00:49][DEBUG] jax_fem: Function split_and_compute_cell took 0.4019 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[[-0.0263532 0.01479549 0.09278505]\n", + " [-0.02916125 -0.06907313 0.14648977]\n", + " [ 0.00973595 -0.04307427 0.0341506 ]\n", + " [-0.0107834 -0.0074182 0.09402093]]\n", + "\n", + " [[ 0.06879975 -0.01975272 -0.24043098]\n", + " [-0.00269702 0.00594136 -0.28445733]\n", + " [-0.01099887 0.0050053 -0.065516 ]\n", + " [ 0.03450565 0.02427675 0.01853378]]\n", + "\n", + " [[ 0.01645054 0.02365763 0.14074592]\n", + " [ 0.01352025 0.036117 0.18549794]\n", + " [-0.00328406 0.01266251 0.03698513]\n", + " [ 0.01272748 0.00488436 0.09804412]]]\n", + "[[[-10. -2.4938726 -1.616871 ]\n", + " [ -3.3333333 -3.1112688 -0.11344746]\n", + " [ 3.3333333 -2.824893 0.39232257]\n", + " [ 10. -2.9517121 -0.4841671 ]]\n", + "\n", + " [[-10. -0.4273274 1.3085513 ]\n", + " [ -3.3333333 0.17485017 1.2275066 ]\n", + " [ 3.3333333 -0.03150175 0.78278196]\n", + " [ 10. 0.7115146 -0.07233952]]\n", + "\n", + " [[-10. 2.6382687 -1.0100068 ]\n", + " [ -3.3333333 2.5429895 -0.8314228 ]\n", + " [ 3.3333333 1.7686539 -1.3677512 ]\n", + " [ 10. 2.546803 -0.35522133]]]\n", + "Iteration 30, Loss: 14926.35\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-08 13:01:10][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 13:01:10][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 13:01:10][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 13:01:12][DEBUG] jax_fem: Done pre-computations, took 1.3327975273132324 [s]\n", + "[11-08 13:01:12][INFO] jax_fem: Solving a problem with 4489 cells, 5687x3 = 17061 dofs.\n", + "[11-08 13:01:12][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 13:01:12][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 13:01:12][DEBUG] jax_fem: Start timing\n", + "[11-08 13:01:12][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:01:12][DEBUG] jax_fem: Function split_and_compute_cell took 0.3894 seconds\n", + "[11-08 13:01:12][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:01:13][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 13:01:13][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 13:01:13][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 13:01:17][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 2.3040955304171448e-09\n", + "[11-08 13:01:17][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:01:17][DEBUG] jax_fem: Function split_and_compute_cell took 0.0491 seconds\n", + "[11-08 13:01:17][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:01:17][DEBUG] jax_fem: l_2 res = 2.307043615925419e-09, relative l_2 res = 1.3272819102324202e-11\n", + "[11-08 13:01:18][INFO] jax_fem: Solve took 5.942513465881348 [s]\n", + "[11-08 13:01:18][INFO] jax_fem: max of dofs = 4.692184311608165\n", + "[11-08 13:01:18][INFO] jax_fem: min of dofs = -17.000438681019453\n", + "[11-08 13:01:18][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 13:01:18][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 13:01:18][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 13:01:19][DEBUG] jax_fem: Done pre-computations, took 1.5313012599945068 [s]\n", + "[11-08 13:01:19][INFO] jax_fem: Solving a problem with 4489 cells, 5687x3 = 17061 dofs.\n", + "[11-08 13:01:19][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 13:01:19][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 13:01:19][DEBUG] jax_fem: Start timing\n", + "[11-08 13:01:19][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:01:20][DEBUG] jax_fem: Function split_and_compute_cell took 0.3959 seconds\n", + "[11-08 13:01:20][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:01:20][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 13:01:20][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 13:01:20][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 13:01:25][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 2.3040955304171448e-09\n", + "[11-08 13:01:25][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:01:25][DEBUG] jax_fem: Function split_and_compute_cell took 0.0430 seconds\n", + "[11-08 13:01:25][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:01:25][DEBUG] jax_fem: l_2 res = 2.307043615925419e-09, relative l_2 res = 1.3272819102324202e-11\n", + "[11-08 13:01:25][INFO] jax_fem: Solve took 6.000345230102539 [s]\n", + "[11-08 13:01:25][INFO] jax_fem: max of dofs = 4.692184311608165\n", + "[11-08 13:01:26][INFO] jax_fem: min of dofs = -17.000438681019453\n", + "[11-08 13:01:26][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-08 13:01:26][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:01:26][DEBUG] jax_fem: Function split_and_compute_cell took 0.0435 seconds\n", + "[11-08 13:01:26][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:01:26][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 13:01:30][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 5.2500740364287084e-08\n", + "[11-08 13:01:30][DEBUG] jax_fem: Computing cell residual...\n", + "[11-08 13:01:30][DEBUG] jax_fem: Function split_and_compute_cell took 0.3561 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[[-0.02761334 0.01454902 0.08580631]\n", + " [-0.03130736 -0.06761429 0.14196455]\n", + " [ 0.01190486 -0.04067281 0.03268232]\n", + " [-0.01209042 -0.00707783 0.09685836]]\n", + "\n", + " [[ 0.07095023 -0.02964887 -0.2537609 ]\n", + " [-0.00404611 0.01201419 -0.28133506]\n", + " [-0.01063215 0.00047045 -0.06189089]\n", + " [ 0.03399182 0.02121667 0.01878682]]\n", + "\n", + " [[ 0.01885953 0.02152967 0.14127876]\n", + " [ 0.01201525 0.03427355 0.17671403]\n", + " [-0.00495526 0.00999905 0.03858348]\n", + " [ 0.01471356 0.00175894 0.09374285]]]\n", + "[[[-10. -2.4587665 -1.6635228 ]\n", + " [ -3.3333333 -3.1355743 -0.09525788]\n", + " [ 3.3333333 -2.8419623 0.42897108]\n", + " [ 10. -2.9722142 -0.5118118 ]]\n", + "\n", + " [[-10. -0.43128383 1.3175042 ]\n", + " [ -3.3333333 0.15481515 1.2355199 ]\n", + " [ 3.3333333 -0.06553866 0.811931 ]\n", + " [ 10. 0.6774464 -0.03749086]]\n", + "\n", + " [[-10. 2.644103 -1.0150576 ]\n", + " [ -3.3333333 2.5118325 -0.8404716 ]\n", + " [ 3.3333333 1.7379723 -1.3769463 ]\n", + " [ 10. 2.559877 -0.3196956 ]]]\n", + "Iteration 31, Loss: 14829.46\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-08 13:01:49][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 13:01:49][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 13:01:49][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 13:01:51][DEBUG] jax_fem: Done pre-computations, took 1.3233869075775146 [s]\n", + "[11-08 13:01:51][INFO] jax_fem: Solving a problem with 4475 cells, 5670x3 = 17010 dofs.\n", + "[11-08 13:01:51][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 13:01:51][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 13:01:51][DEBUG] jax_fem: Start timing\n", + "[11-08 13:01:51][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:01:51][DEBUG] jax_fem: Function split_and_compute_cell took 0.3960 seconds\n", + "[11-08 13:01:51][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:01:52][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 13:01:52][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 13:01:52][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 13:02:03][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 5.161482741404447e-08\n", + "[11-08 13:02:03][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:02:03][DEBUG] jax_fem: Function split_and_compute_cell took 0.0460 seconds\n", + "[11-08 13:02:03][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:02:03][DEBUG] jax_fem: l_2 res = 5.175358976639733e-08, relative l_2 res = 2.9774731180786443e-10\n", + "[11-08 13:02:03][INFO] jax_fem: Solve took 12.217623472213745 [s]\n", + "[11-08 13:02:03][INFO] jax_fem: max of dofs = 210.38524851681873\n", + "[11-08 13:02:03][INFO] jax_fem: min of dofs = -148.47706991099747\n", + "[11-08 13:02:03][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 13:02:03][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 13:02:03][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 13:02:05][DEBUG] jax_fem: Done pre-computations, took 1.5327610969543457 [s]\n", + "[11-08 13:02:05][INFO] jax_fem: Solving a problem with 4475 cells, 5670x3 = 17010 dofs.\n", + "[11-08 13:02:05][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 13:02:05][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 13:02:05][DEBUG] jax_fem: Start timing\n", + "[11-08 13:02:05][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:02:05][DEBUG] jax_fem: Function split_and_compute_cell took 0.3818 seconds\n", + "[11-08 13:02:06][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:02:06][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 13:02:06][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 13:02:06][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 13:02:17][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 5.161482741404447e-08\n", + "[11-08 13:02:17][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:02:17][DEBUG] jax_fem: Function split_and_compute_cell took 0.0400 seconds\n", + "[11-08 13:02:17][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:02:17][DEBUG] jax_fem: l_2 res = 5.175358976639733e-08, relative l_2 res = 2.9774731180786443e-10\n", + "[11-08 13:02:17][INFO] jax_fem: Solve took 12.227949380874634 [s]\n", + "[11-08 13:02:17][INFO] jax_fem: max of dofs = 210.38524851681873\n", + "[11-08 13:02:17][INFO] jax_fem: min of dofs = -148.47706991099747\n", + "[11-08 13:02:17][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-08 13:02:17][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:02:17][DEBUG] jax_fem: Function split_and_compute_cell took 0.0428 seconds\n", + "[11-08 13:02:17][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:02:17][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 13:02:25][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 1.5178293003730533e-06\n", + "[11-08 13:02:25][DEBUG] jax_fem: Computing cell residual...\n", + "[11-08 13:02:25][DEBUG] jax_fem: Function split_and_compute_cell took 0.3627 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[[-1.05019943e+02 4.84275579e+00 -2.25096054e+01]\n", + " [-2.63879514e+00 3.80564423e+01 3.83542900e+01]\n", + " [ 1.70393448e+02 7.48344360e+02 1.19292603e+03]\n", + " [-1.72426651e+02 3.24418335e+01 3.16404991e+01]]\n", + "\n", + " [[ 9.73066788e+01 7.42854834e+00 1.78279674e+00]\n", + " [-5.10565853e+00 8.54928665e+01 -3.99073181e+01]\n", + " [-7.85857010e+01 3.91763428e+02 -2.91941345e+02]\n", + " [ 1.97209351e+02 2.01877823e+01 -1.36175241e+01]]\n", + "\n", + " [[ 1.99487972e+00 -1.18062677e+01 -2.00394869e-01]\n", + " [-1.20566264e-01 -3.31096911e+00 4.04919100e+00]\n", + " [-1.70985425e+00 1.70910645e+01 8.42650509e+00]\n", + " [-2.93100142e+00 7.14058447e+00 -9.56660843e+00]]]\n", + "[[[-1.0000000e+01 -2.4272437e+00 -1.7096637e+00]\n", + " [-3.3333333e+00 -3.1575239e+00 -7.9080872e-02]\n", + " [ 3.3333333e+00 -2.8564503e+00 4.6191484e-01]\n", + " [ 1.0000000e+01 -2.9908102e+00 -5.3919780e-01]]\n", + "\n", + " [[-1.0000000e+01 -4.3466744e-01 1.3259048e+00]\n", + " [-3.3333333e+00 1.3657577e-01 1.2430958e+00]\n", + " [ 3.3333333e+00 -9.6467689e-02 8.3846277e-01]\n", + " [ 1.0000000e+01 6.4647597e-01 -5.8391914e-03]]\n", + "\n", + " [[-1.0000000e+01 2.6493752e+00 -1.0198685e+00]\n", + " [-3.3333333e+00 2.4834616e+00 -8.4887964e-01]\n", + " [ 3.3333333e+00 1.7100891e+00 -1.3853651e+00]\n", + " [ 1.0000000e+01 2.5717552e+00 -2.8751761e-01]]]\n", + "Iteration 32, Loss: 27998.79\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-08 13:02:41][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 13:02:41][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 13:02:41][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 13:02:43][DEBUG] jax_fem: Done pre-computations, took 1.3585824966430664 [s]\n", + "[11-08 13:02:43][INFO] jax_fem: Solving a problem with 4496 cells, 5694x3 = 17082 dofs.\n", + "[11-08 13:02:43][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 13:02:43][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 13:02:43][DEBUG] jax_fem: Start timing\n", + "[11-08 13:02:43][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:02:43][DEBUG] jax_fem: Function split_and_compute_cell took 0.3785 seconds\n", + "[11-08 13:02:44][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:02:44][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 13:02:44][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 13:02:44][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 13:02:49][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 2.2805959313755166e-09\n", + "[11-08 13:02:49][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:02:49][DEBUG] jax_fem: Function split_and_compute_cell took 0.0488 seconds\n", + "[11-08 13:02:49][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:02:49][DEBUG] jax_fem: l_2 res = 2.2840100294884365e-09, relative l_2 res = 1.3140302914097225e-11\n", + "[11-08 13:02:49][INFO] jax_fem: Solve took 6.175374507904053 [s]\n", + "[11-08 13:02:49][INFO] jax_fem: max of dofs = 4.604803887484437\n", + "[11-08 13:02:49][INFO] jax_fem: min of dofs = -16.96789457514972\n", + "[11-08 13:02:49][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 13:02:49][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 13:02:49][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 13:02:51][DEBUG] jax_fem: Done pre-computations, took 1.553746223449707 [s]\n", + "[11-08 13:02:51][INFO] jax_fem: Solving a problem with 4496 cells, 5694x3 = 17082 dofs.\n", + "[11-08 13:02:51][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 13:02:51][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 13:02:51][DEBUG] jax_fem: Start timing\n", + "[11-08 13:02:51][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:02:51][DEBUG] jax_fem: Function split_and_compute_cell took 0.3629 seconds\n", + "[11-08 13:02:51][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:02:52][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 13:02:52][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 13:02:52][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 13:02:57][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 2.2805959313755166e-09\n", + "[11-08 13:02:57][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:02:57][DEBUG] jax_fem: Function split_and_compute_cell took 0.0433 seconds\n", + "[11-08 13:02:57][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:02:57][DEBUG] jax_fem: l_2 res = 2.2840100294884365e-09, relative l_2 res = 1.3140302914097225e-11\n", + "[11-08 13:02:57][INFO] jax_fem: Solve took 6.127994537353516 [s]\n", + "[11-08 13:02:57][INFO] jax_fem: max of dofs = 4.604803887484437\n", + "[11-08 13:02:57][INFO] jax_fem: min of dofs = -16.96789457514972\n", + "[11-08 13:02:57][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-08 13:02:57][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:02:57][DEBUG] jax_fem: Function split_and_compute_cell took 0.0435 seconds\n", + "[11-08 13:02:57][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:02:57][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 13:03:01][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 5.303200991726958e-08\n", + "[11-08 13:03:02][DEBUG] jax_fem: Computing cell residual...\n", + "[11-08 13:03:02][DEBUG] jax_fem: Function split_and_compute_cell took 0.3736 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[[-0.0265262 0.01998615 0.09229437]\n", + " [-0.03036441 -0.069767 0.14199121]\n", + " [ 0.01379605 -0.0436583 0.03152889]\n", + " [-0.01423317 -0.01168345 0.10405596]]\n", + "\n", + " [[ 0.07932572 -0.03532257 -0.24023484]\n", + " [-0.00655853 -0.00248515 -0.2681855 ]\n", + " [-0.00831549 0.00137457 -0.05110223]\n", + " [ 0.03401344 0.02176728 0.01902497]]\n", + "\n", + " [[ 0.02506478 0.02659124 0.14077404]\n", + " [ 0.01365135 0.03350383 0.17067334]\n", + " [-0.00290325 0.01283496 0.03765972]\n", + " [ 0.0152394 0.00673237 0.08777517]]]\n", + "[[[-10. -2.4654167 -1.6583592 ]\n", + " [ -3.3333333 -3.2129345 -0.11865719]\n", + " [ 3.3333333 -2.9100583 0.40846622]\n", + " [ 10. -3.046968 -0.5943956 ]]\n", + "\n", + " [[-10. -0.474695 1.3316511 ]\n", + " [ -3.3333333 0.0806988 1.2816442 ]\n", + " [ 3.3333333 -0.15337437 0.8962983 ]\n", + " [ 10. 0.6065601 0.03279078]]\n", + "\n", + " [[-10. 2.6695457 -1.0239226 ]\n", + " [ -3.3333333 2.4635656 -0.8607745 ]\n", + " [ 3.3333333 1.6789277 -1.4063134 ]\n", + " [ 10. 2.5755558 -0.2483955 ]]]\n", + "Iteration 33, Loss: 14644.23\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-08 13:03:18][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 13:03:18][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 13:03:18][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 13:03:19][DEBUG] jax_fem: Done pre-computations, took 0.7551887035369873 [s]\n", + "[11-08 13:03:19][INFO] jax_fem: Solving a problem with 4496 cells, 5694x3 = 17082 dofs.\n", + "[11-08 13:03:19][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 13:03:19][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 13:03:19][DEBUG] jax_fem: Start timing\n", + "[11-08 13:03:19][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:03:19][DEBUG] jax_fem: Function split_and_compute_cell took 0.3650 seconds\n", + "[11-08 13:03:19][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:03:19][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 13:03:19][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 13:03:19][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 13:03:24][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 2.4343567316809435e-09\n", + "[11-08 13:03:24][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:03:24][DEBUG] jax_fem: Function split_and_compute_cell took 0.0492 seconds\n", + "[11-08 13:03:24][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:03:25][DEBUG] jax_fem: l_2 res = 2.457277242170139e-09, relative l_2 res = 1.4137139018284046e-11\n", + "[11-08 13:03:25][INFO] jax_fem: Solve took 5.658714771270752 [s]\n", + "[11-08 13:03:25][INFO] jax_fem: max of dofs = 4.522006266141953\n", + "[11-08 13:03:25][INFO] jax_fem: min of dofs = -16.378213085326735\n", + "[11-08 13:03:25][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 13:03:25][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 13:03:25][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 13:03:25][DEBUG] jax_fem: Done pre-computations, took 0.7631194591522217 [s]\n", + "[11-08 13:03:25][INFO] jax_fem: Solving a problem with 4496 cells, 5694x3 = 17082 dofs.\n", + "[11-08 13:03:25][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 13:03:25][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 13:03:25][DEBUG] jax_fem: Start timing\n", + "[11-08 13:03:25][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:03:26][DEBUG] jax_fem: Function split_and_compute_cell took 0.3682 seconds\n", + "[11-08 13:03:26][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:03:26][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 13:03:26][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 13:03:26][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 13:03:31][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 2.4343567316809435e-09\n", + "[11-08 13:03:31][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:03:31][DEBUG] jax_fem: Function split_and_compute_cell took 0.0440 seconds\n", + "[11-08 13:03:31][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:03:31][DEBUG] jax_fem: l_2 res = 2.457277242170139e-09, relative l_2 res = 1.4137139018284046e-11\n", + "[11-08 13:03:31][INFO] jax_fem: Solve took 5.653102397918701 [s]\n", + "[11-08 13:03:31][INFO] jax_fem: max of dofs = 4.522006266141953\n", + "[11-08 13:03:31][INFO] jax_fem: min of dofs = -16.378213085326735\n", + "[11-08 13:03:31][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-08 13:03:31][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:03:31][DEBUG] jax_fem: Function split_and_compute_cell took 0.0413 seconds\n", + "[11-08 13:03:31][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:03:31][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 13:03:36][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 5.474684809564457e-08\n", + "[11-08 13:03:36][DEBUG] jax_fem: Computing cell residual...\n", + "[11-08 13:03:36][DEBUG] jax_fem: Function split_and_compute_cell took 0.3717 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[[-0.02938404 0.02369689 0.0927937 ]\n", + " [-0.02275722 -0.06373892 0.14321345]\n", + " [ 0.01447043 -0.04092593 0.03418223]\n", + " [-0.01299725 -0.01398125 0.10696628]]\n", + "\n", + " [[ 0.06838862 -0.03067511 -0.24137707]\n", + " [-0.00229913 0.01453763 -0.2493632 ]\n", + " [-0.00552889 0.01111166 -0.04509393]\n", + " [ 0.03472789 0.02602771 0.02090693]]\n", + "\n", + " [[ 0.02309371 0.02784855 0.13817911]\n", + " [ 0.0137971 0.03371148 0.16548444]\n", + " [-0.00352314 0.01085566 0.02645943]\n", + " [ 0.0179375 0.00353721 0.08034112]]]\n", + "[[[-10. -2.500304 -1.6119683 ]\n", + " [ -3.3333333 -3.263196 -0.15478873]\n", + " [ 3.3333333 -2.9587605 0.3599041 ]\n", + " [ 10. -3.0979717 -0.6447226 ]]\n", + "\n", + " [[-10. -0.5108801 1.3371278 ]\n", + " [ -3.3333333 0.02993339 1.3168919 ]\n", + " [ 3.3333333 -0.20507707 0.94885385]\n", + " [ 10. 0.5702809 0.06787328]]\n", + "\n", + " [[-10. 2.6878362 -1.0278307 ]\n", + " [ -3.3333333 2.4454305 -0.87176365]\n", + " [ 3.3333333 1.6506114 -1.4254072 ]\n", + " [ 10. 2.5790021 -0.21294796]]]\n", + "Iteration 34, Loss: 14411.75\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-08 13:03:56][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 13:03:56][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 13:03:56][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 13:03:57][DEBUG] jax_fem: Done pre-computations, took 0.7597544193267822 [s]\n", + "[11-08 13:03:57][INFO] jax_fem: Solving a problem with 4503 cells, 5694x3 = 17082 dofs.\n", + "[11-08 13:03:57][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 13:03:58][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 13:03:58][DEBUG] jax_fem: Start timing\n", + "[11-08 13:03:58][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:03:59][DEBUG] jax_fem: Function split_and_compute_cell took 0.5006 seconds\n", + "[11-08 13:04:00][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:04:00][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 13:04:00][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 13:04:00][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 13:04:05][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 1.9805642252618024e-09\n", + "[11-08 13:04:05][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:04:05][DEBUG] jax_fem: Function split_and_compute_cell took 0.0482 seconds\n", + "[11-08 13:04:05][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:04:05][DEBUG] jax_fem: l_2 res = 1.9573815494133348e-09, relative l_2 res = 1.1261153035968488e-11\n", + "[11-08 13:04:05][INFO] jax_fem: Solve took 6.497474431991577 [s]\n", + "[11-08 13:04:05][INFO] jax_fem: max of dofs = 4.441696024753757\n", + "[11-08 13:04:05][INFO] jax_fem: min of dofs = -16.31085726154219\n", + "[11-08 13:04:05][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 13:04:05][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 13:04:05][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 13:04:06][DEBUG] jax_fem: Done pre-computations, took 0.7663793563842773 [s]\n", + "[11-08 13:04:06][INFO] jax_fem: Solving a problem with 4503 cells, 5694x3 = 17082 dofs.\n", + "[11-08 13:04:06][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 13:04:07][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 13:04:07][DEBUG] jax_fem: Start timing\n", + "[11-08 13:04:07][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:04:08][DEBUG] jax_fem: Function split_and_compute_cell took 0.5012 seconds\n", + "[11-08 13:04:09][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:04:09][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 13:04:09][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 13:04:09][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 13:04:14][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 1.9805642252618024e-09\n", + "[11-08 13:04:14][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:04:14][DEBUG] jax_fem: Function split_and_compute_cell took 0.0439 seconds\n", + "[11-08 13:04:14][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:04:14][DEBUG] jax_fem: l_2 res = 1.9573815494133348e-09, relative l_2 res = 1.1261153035968488e-11\n", + "[11-08 13:04:14][INFO] jax_fem: Solve took 6.585190296173096 [s]\n", + "[11-08 13:04:14][INFO] jax_fem: max of dofs = 4.441696024753757\n", + "[11-08 13:04:14][INFO] jax_fem: min of dofs = -16.31085726154219\n", + "[11-08 13:04:14][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-08 13:04:14][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:04:14][DEBUG] jax_fem: Function split_and_compute_cell took 0.0443 seconds\n", + "[11-08 13:04:14][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:04:14][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 13:04:19][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 5.7164873275996896e-08\n", + "[11-08 13:04:19][DEBUG] jax_fem: Computing cell residual...\n", + "[11-08 13:04:20][DEBUG] jax_fem: Function split_and_compute_cell took 0.4548 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[[-0.03023494 0.0143412 0.08685553]\n", + " [-0.02574222 -0.06382567 0.13348682]\n", + " [ 0.0107946 -0.04159833 0.02947597]\n", + " [-0.01349086 -0.01590881 0.10404362]]\n", + "\n", + " [[ 0.06870487 -0.04052793 -0.23571727]\n", + " [-0.00222302 0.02034936 -0.2434932 ]\n", + " [-0.0034252 0.01263646 -0.03505218]\n", + " [ 0.02561549 0.01796562 0.01750663]]\n", + "\n", + " [[ 0.02704922 0.02715184 0.13453026]\n", + " [ 0.01351036 0.02674899 0.15510292]\n", + " [-0.00440191 0.01064528 0.01546581]\n", + " [ 0.01534854 0.00154896 0.07433105]]]\n", + "[[[-10. -2.5322435 -1.5700489 ]\n", + " [ -3.3333333 -3.3087816 -0.18779065]\n", + " [ 3.3333333 -3.0030017 0.31578562]\n", + " [ 10. -3.1442845 -0.6906267 ]]\n", + "\n", + " [[-10. -0.5435935 1.3423628 ]\n", + " [ -3.3333333 -0.01619421 1.349124 ]\n", + " [ 3.3333333 -0.2520486 0.9966069 ]\n", + " [ 10. 0.5373061 0.09972817]]\n", + "\n", + " [[-10. 2.7044148 -1.031604 ]\n", + " [ -3.3333333 2.428896 -0.88192505]\n", + " [ 3.3333333 1.6248832 -1.4427965 ]\n", + " [ 10. 2.5821295 -0.1808346 ]]]\n", + "Iteration 35, Loss: 14269.13\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-08 13:04:44][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 13:04:44][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 13:04:44][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 13:04:45][DEBUG] jax_fem: Done pre-computations, took 0.797835111618042 [s]\n", + "[11-08 13:04:45][INFO] jax_fem: Solving a problem with 4461 cells, 5658x3 = 16974 dofs.\n", + "[11-08 13:04:45][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 13:04:47][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 13:04:47][DEBUG] jax_fem: Start timing\n", + "[11-08 13:04:47][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:04:47][DEBUG] jax_fem: Function split_and_compute_cell took 0.5521 seconds\n", + "[11-08 13:04:48][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:04:48][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 13:04:48][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 13:04:48][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 13:04:53][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 2.020520185490453e-09\n", + "[11-08 13:04:53][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:04:53][DEBUG] jax_fem: Function split_and_compute_cell took 0.0482 seconds\n", + "[11-08 13:04:53][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:04:53][DEBUG] jax_fem: l_2 res = 1.9909401893079587e-09, relative l_2 res = 1.1454221668727179e-11\n", + "[11-08 13:04:53][INFO] jax_fem: Solve took 6.362879276275635 [s]\n", + "[11-08 13:04:53][INFO] jax_fem: max of dofs = 4.370060639688745\n", + "[11-08 13:04:53][INFO] jax_fem: min of dofs = -16.23235232037151\n", + "[11-08 13:04:53][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 13:04:53][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 13:04:53][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 13:04:54][DEBUG] jax_fem: Done pre-computations, took 0.8483011722564697 [s]\n", + "[11-08 13:04:54][INFO] jax_fem: Solving a problem with 4461 cells, 5658x3 = 16974 dofs.\n", + "[11-08 13:04:54][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 13:04:56][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 13:04:56][DEBUG] jax_fem: Start timing\n", + "[11-08 13:04:56][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:04:56][DEBUG] jax_fem: Function split_and_compute_cell took 0.5828 seconds\n", + "[11-08 13:04:57][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:04:57][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 13:04:57][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 13:04:57][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 13:05:02][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 2.020520185490453e-09\n", + "[11-08 13:05:02][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:05:02][DEBUG] jax_fem: Function split_and_compute_cell took 0.0439 seconds\n", + "[11-08 13:05:02][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:05:02][DEBUG] jax_fem: l_2 res = 1.9909401893079587e-09, relative l_2 res = 1.1454221668727179e-11\n", + "[11-08 13:05:02][INFO] jax_fem: Solve took 6.390815258026123 [s]\n", + "[11-08 13:05:02][INFO] jax_fem: max of dofs = 4.370060639688745\n", + "[11-08 13:05:02][INFO] jax_fem: min of dofs = -16.23235232037151\n", + "[11-08 13:05:02][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-08 13:05:02][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:05:02][DEBUG] jax_fem: Function split_and_compute_cell took 0.0424 seconds\n", + "[11-08 13:05:02][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:05:02][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 13:05:07][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 1.0973407516235757e-07\n", + "[11-08 13:05:07][DEBUG] jax_fem: Computing cell residual...\n", + "[11-08 13:05:08][DEBUG] jax_fem: Function split_and_compute_cell took 0.4100 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[[-0.02557635 0.01981702 0.09574752]\n", + " [-0.02442927 -0.06330683 0.12653981]\n", + " [ 0.01240619 -0.03843487 0.03211948]\n", + " [-0.01269489 -0.01770701 0.09586954]]\n", + "\n", + " [[ 0.07868844 -0.03510033 -0.2470499 ]\n", + " [-0.00155873 0.02337856 -0.23701578]\n", + " [-0.00451045 0.0163912 -0.03802042]\n", + " [ 0.02450855 0.02008872 0.0337509 ]]\n", + "\n", + " [[ 0.02801018 0.0286474 0.13455002]\n", + " [ 0.01567305 0.02967523 0.15222356]\n", + " [-0.00293999 0.01394895 0.00877904]\n", + " [ 0.02153104 0.00371186 0.06639323]]]\n", + "[[[-10. -2.5614064 -1.5321833 ]\n", + " [ -3.3333333 -3.350114 -0.21793573]\n", + " [ 3.3333333 -3.043186 0.27570844]\n", + " [ 10. -3.186328 -0.73250496]]\n", + "\n", + " [[-10. -0.57309675 1.3473738 ]\n", + " [ -3.3333333 -0.05810785 1.3786103 ]\n", + " [ 3.3333333 -0.29471782 1.0399907 ]\n", + " [ 10. 0.5073413 0.12865034]]\n", + "\n", + " [[-10. 2.7194376 -1.0352505 ]\n", + " [ -3.3333333 2.4138288 -0.89132386]\n", + " [ 3.3333333 1.6015087 -1.4586179 ]\n", + " [ 10. 2.5849688 -0.15174738]]]\n", + "Iteration 36, Loss: 14026.02\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-08 13:05:28][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 13:05:28][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 13:05:28][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 13:05:29][DEBUG] jax_fem: Done pre-computations, took 1.3541271686553955 [s]\n", + "[11-08 13:05:29][INFO] jax_fem: Solving a problem with 4489 cells, 5683x3 = 17049 dofs.\n", + "[11-08 13:05:29][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 13:05:29][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 13:05:29][DEBUG] jax_fem: Start timing\n", + "[11-08 13:05:29][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:05:30][DEBUG] jax_fem: Function split_and_compute_cell took 0.4268 seconds\n", + "[11-08 13:05:30][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:05:30][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 13:05:30][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 13:05:30][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 13:05:35][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 1.8833617116478513e-09\n", + "[11-08 13:05:35][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:05:35][DEBUG] jax_fem: Function split_and_compute_cell took 0.0488 seconds\n", + "[11-08 13:05:35][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:05:36][DEBUG] jax_fem: l_2 res = 1.884429341149819e-09, relative l_2 res = 1.0841446422399191e-11\n", + "[11-08 13:05:36][INFO] jax_fem: Solve took 6.424050807952881 [s]\n", + "[11-08 13:05:36][INFO] jax_fem: max of dofs = 4.304659979811347\n", + "[11-08 13:05:36][INFO] jax_fem: min of dofs = -16.170492148942625\n", + "[11-08 13:05:36][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 13:05:36][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 13:05:36][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 13:05:37][DEBUG] jax_fem: Done pre-computations, took 1.5852015018463135 [s]\n", + "[11-08 13:05:37][INFO] jax_fem: Solving a problem with 4489 cells, 5683x3 = 17049 dofs.\n", + "[11-08 13:05:37][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 13:05:38][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 13:05:38][DEBUG] jax_fem: Start timing\n", + "[11-08 13:05:38][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:05:38][DEBUG] jax_fem: Function split_and_compute_cell took 0.3902 seconds\n", + "[11-08 13:05:38][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:05:38][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 13:05:38][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 13:05:39][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 13:05:44][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 1.8833617116478513e-09\n", + "[11-08 13:05:44][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:05:44][DEBUG] jax_fem: Function split_and_compute_cell took 0.0429 seconds\n", + "[11-08 13:05:44][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:05:44][DEBUG] jax_fem: l_2 res = 1.884429341149819e-09, relative l_2 res = 1.0841446422399191e-11\n", + "[11-08 13:05:44][INFO] jax_fem: Solve took 6.3370361328125 [s]\n", + "[11-08 13:05:44][INFO] jax_fem: max of dofs = 4.304659979811347\n", + "[11-08 13:05:44][INFO] jax_fem: min of dofs = -16.170492148942625\n", + "[11-08 13:05:44][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-08 13:05:44][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:05:44][DEBUG] jax_fem: Function split_and_compute_cell took 0.0438 seconds\n", + "[11-08 13:05:44][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:05:44][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 13:05:49][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 7.12000454852062e-08\n", + "[11-08 13:05:49][DEBUG] jax_fem: Computing cell residual...\n", + "[11-08 13:05:49][DEBUG] jax_fem: Function split_and_compute_cell took 0.3560 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[[-2.0435898e-02 2.0831792e-02 9.5856257e-02]\n", + " [-2.3995720e-02 -6.6491835e-02 1.2676315e-01]\n", + " [ 1.1042981e-02 -4.0153991e-02 2.7049437e-02]\n", + " [-9.0670446e-03 -1.6780954e-02 9.5807858e-02]]\n", + "\n", + " [[ 6.2452450e-02 -3.7031066e-02 -2.3321112e-01]\n", + " [-2.0099530e-04 4.5880917e-03 -2.4557288e-01]\n", + " [-9.8773162e-04 1.7880684e-02 -2.2199532e-02]\n", + " [ 2.3591053e-02 2.0935345e-02 3.3438377e-02]]\n", + "\n", + " [[ 2.5268544e-02 2.7209444e-02 1.3379888e-01]\n", + " [ 1.4064988e-02 3.1898111e-02 1.4199767e-01]\n", + " [-3.4325735e-03 1.3243265e-02 2.5072219e-03]\n", + " [ 1.8072637e-02 6.2430133e-03 6.1777290e-02]]]\n", + "[[[-10. -2.5881033 -1.4980278 ]\n", + " [ -3.3333333 -3.3875787 -0.24547535]\n", + " [ 3.3333333 -3.079681 0.23930635]\n", + " [ 10. -3.2244856 -0.77070934]]\n", + "\n", + " [[-10. -0.59970766 1.3521959 ]\n", + " [ -3.3333333 -0.0961913 1.4055957 ]\n", + " [ 3.3333333 -0.33347496 1.0794015 ]\n", + " [ 10. 0.48011246 0.15489246]]\n", + "\n", + " [[-10. 2.733043 -1.0387836 ]\n", + " [ -3.3333333 2.4000907 -0.9000274 ]\n", + " [ 3.3333333 1.5802735 -1.4730026 ]\n", + " [ 10. 2.587544 -0.12540379]]]\n", + "Iteration 37, Loss: 13920.67\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-08 13:06:09][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 13:06:09][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 13:06:09][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 13:06:11][DEBUG] jax_fem: Done pre-computations, took 1.3401293754577637 [s]\n", + "[11-08 13:06:11][INFO] jax_fem: Solving a problem with 4517 cells, 5714x3 = 17142 dofs.\n", + "[11-08 13:06:11][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 13:06:12][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 13:06:12][DEBUG] jax_fem: Start timing\n", + "[11-08 13:06:13][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:06:13][DEBUG] jax_fem: Function split_and_compute_cell took 0.5481 seconds\n", + "[11-08 13:06:14][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:06:14][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 13:06:14][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 13:06:14][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 13:06:25][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 4.9245633240278956e-08\n", + "[11-08 13:06:25][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:06:25][DEBUG] jax_fem: Function split_and_compute_cell took 0.0467 seconds\n", + "[11-08 13:06:25][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:06:25][DEBUG] jax_fem: l_2 res = 4.8989126671207664e-08, relative l_2 res = 2.81842879692139e-10\n", + "[11-08 13:06:25][INFO] jax_fem: Solve took 12.824892282485962 [s]\n", + "[11-08 13:06:25][INFO] jax_fem: max of dofs = 98.00059892914108\n", + "[11-08 13:06:25][INFO] jax_fem: min of dofs = -294.2249678856815\n", + "[11-08 13:06:25][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 13:06:25][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 13:06:25][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 13:06:27][DEBUG] jax_fem: Done pre-computations, took 1.531693458557129 [s]\n", + "[11-08 13:06:27][INFO] jax_fem: Solving a problem with 4517 cells, 5714x3 = 17142 dofs.\n", + "[11-08 13:06:27][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 13:06:29][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 13:06:29][DEBUG] jax_fem: Start timing\n", + "[11-08 13:06:29][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:06:30][DEBUG] jax_fem: Function split_and_compute_cell took 0.5580 seconds\n", + "[11-08 13:06:30][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:06:30][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 13:06:30][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 13:06:30][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 13:06:41][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 4.9245633240278956e-08\n", + "[11-08 13:06:41][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:06:41][DEBUG] jax_fem: Function split_and_compute_cell took 0.0426 seconds\n", + "[11-08 13:06:41][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:06:41][DEBUG] jax_fem: l_2 res = 4.8989126671207664e-08, relative l_2 res = 2.81842879692139e-10\n", + "[11-08 13:06:42][INFO] jax_fem: Solve took 12.839642763137817 [s]\n", + "[11-08 13:06:42][INFO] jax_fem: max of dofs = 98.00059892914108\n", + "[11-08 13:06:42][INFO] jax_fem: min of dofs = -294.2249678856815\n", + "[11-08 13:06:42][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-08 13:06:42][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:06:42][DEBUG] jax_fem: Function split_and_compute_cell took 0.0434 seconds\n", + "[11-08 13:06:42][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:06:42][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 13:06:51][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 4.004865756921023e-07\n", + "[11-08 13:06:52][DEBUG] jax_fem: Computing cell residual...\n", + "[11-08 13:06:52][DEBUG] jax_fem: Function split_and_compute_cell took 0.4460 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[[ -19.565641 -37.241756 -33.626987 ]\n", + " [ -39.735012 8.954512 68.71517 ]\n", + " [ -8.400767 -47.95371 -41.488373 ]\n", + " [ -30.311235 37.593685 31.607153 ]]\n", + "\n", + " [[ 53.6301 20.031187 2.6758363 ]\n", + " [ -0.24167043 -39.534336 63.982334 ]\n", + " [ -0.57205003 103.24981 71.697136 ]\n", + " [ 86.95251 31.583872 98.18956 ]]\n", + "\n", + " [[ -59.50984 -61.764336 -13.553885 ]\n", + " [ 8.468154 6.302691 -41.065796 ]\n", + " [ 16.039331 -53.276875 -142.11946 ]\n", + " [ -77.23694 -6.1161757 -78.56554 ]]]\n", + "[[[-10. -2.6125703 -1.4672483 ]\n", + " [ -3.3333333 -3.4215214 -0.2706472 ]\n", + " [ 3.3333333 -3.1128209 0.20624651]\n", + " [ 10. -3.2591112 -0.80557394]]\n", + "\n", + " [[-10. -0.6236766 1.3568327 ]\n", + " [ -3.3333333 -0.13077973 1.4303159 ]\n", + " [ 3.3333333 -0.3686748 1.1151966 ]\n", + " [ 10. 0.45537093 0.17869745]]\n", + "\n", + " [[-10. 2.745361 -1.0422138 ]\n", + " [ -3.3333333 2.3875566 -0.9080887 ]\n", + " [ 3.3333333 1.5609839 -1.4860702 ]\n", + " [ 10. 2.5898762 -0.10155052]]]\n", + "Iteration 38, Loss: 22733.34\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-08 13:07:13][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 13:07:13][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 13:07:13][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 13:07:14][DEBUG] jax_fem: Done pre-computations, took 1.342005968093872 [s]\n", + "[11-08 13:07:14][INFO] jax_fem: Solving a problem with 4503 cells, 5700x3 = 17100 dofs.\n", + "[11-08 13:07:14][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 13:07:14][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 13:07:14][DEBUG] jax_fem: Start timing\n", + "[11-08 13:07:14][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:07:15][DEBUG] jax_fem: Function split_and_compute_cell took 0.3439 seconds\n", + "[11-08 13:07:15][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:07:15][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 13:07:15][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 13:07:15][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 13:07:20][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 2.5402176976555516e-09\n", + "[11-08 13:07:20][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:07:20][DEBUG] jax_fem: Function split_and_compute_cell took 0.0471 seconds\n", + "[11-08 13:07:20][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:07:20][DEBUG] jax_fem: l_2 res = 2.5312291303343106e-09, relative l_2 res = 1.4562596962426396e-11\n", + "[11-08 13:07:20][INFO] jax_fem: Solve took 5.626572847366333 [s]\n", + "[11-08 13:07:20][INFO] jax_fem: max of dofs = 4.29074544478391\n", + "[11-08 13:07:20][INFO] jax_fem: min of dofs = -16.33578351625422\n", + "[11-08 13:07:20][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 13:07:20][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 13:07:20][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 13:07:22][DEBUG] jax_fem: Done pre-computations, took 1.54764723777771 [s]\n", + "[11-08 13:07:22][INFO] jax_fem: Solving a problem with 4503 cells, 5700x3 = 17100 dofs.\n", + "[11-08 13:07:22][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 13:07:22][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 13:07:22][DEBUG] jax_fem: Start timing\n", + "[11-08 13:07:22][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:07:22][DEBUG] jax_fem: Function split_and_compute_cell took 0.3325 seconds\n", + "[11-08 13:07:23][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:07:23][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 13:07:23][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 13:07:23][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 13:07:27][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 2.5402176976555516e-09\n", + "[11-08 13:07:27][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:07:27][DEBUG] jax_fem: Function split_and_compute_cell took 0.0430 seconds\n", + "[11-08 13:07:27][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:07:27][DEBUG] jax_fem: l_2 res = 2.5312291303343106e-09, relative l_2 res = 1.4562596962426396e-11\n", + "[11-08 13:07:27][INFO] jax_fem: Solve took 5.296109914779663 [s]\n", + "[11-08 13:07:27][INFO] jax_fem: max of dofs = 4.29074544478391\n", + "[11-08 13:07:27][INFO] jax_fem: min of dofs = -16.33578351625422\n", + "[11-08 13:07:27][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-08 13:07:27][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:07:27][DEBUG] jax_fem: Function split_and_compute_cell took 0.0438 seconds\n", + "[11-08 13:07:27][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:07:27][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 13:07:32][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 3.711090062468508e-08\n", + "[11-08 13:07:32][DEBUG] jax_fem: Computing cell residual...\n", + "[11-08 13:07:32][DEBUG] jax_fem: Function split_and_compute_cell took 0.3581 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[[-0.01212933 0.02680061 0.09945226]\n", + " [-0.02137651 -0.06508728 0.11806057]\n", + " [ 0.01040295 -0.04127475 0.02555476]\n", + " [-0.00474714 -0.02015385 0.09402783]]\n", + "\n", + " [[ 0.04742298 -0.03918566 -0.23129596]\n", + " [ 0.0009557 0.02661997 -0.22783181]\n", + " [-0.00350613 0.0135354 -0.01749949]\n", + " [ 0.01366735 0.01751137 0.03565072]]\n", + "\n", + " [[ 0.02081618 0.02638875 0.13365254]\n", + " [ 0.0139488 0.03130394 0.13251302]\n", + " [-0.00311377 0.0166392 -0.00048581]\n", + " [ 0.01294792 0.00523333 0.04745966]]]\n", + "[[[-10. -2.5597823 -1.4047967 ]\n", + " [ -3.3333333 -3.4625342 -0.33052135]\n", + " [ 3.3333333 -3.1392312 0.17821285]\n", + " [ 10. -3.3220215 -0.8678609 ]]\n", + "\n", + " [[-10. -0.6837713 1.3580568 ]\n", + " [ -3.3333333 -0.13609765 1.4064281 ]\n", + " [ 3.3333333 -0.41389155 1.1336981 ]\n", + " [ 10. 0.41480026 0.1452235 ]]\n", + "\n", + " [[-10. 2.7987006 -1.02407 ]\n", + " [ -3.3333333 2.3651052 -0.8781783 ]\n", + " [ 3.3333333 1.5630586 -1.4338162 ]\n", + " [ 10. 2.59819 -0.04219338]]]\n", + "Iteration 39, Loss: 13978.09\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-08 13:07:48][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 13:07:48][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 13:07:48][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 13:07:49][DEBUG] jax_fem: Done pre-computations, took 0.8128254413604736 [s]\n", + "[11-08 13:07:49][INFO] jax_fem: Solving a problem with 4496 cells, 5687x3 = 17061 dofs.\n", + "[11-08 13:07:49][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 13:07:49][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 13:07:49][DEBUG] jax_fem: Start timing\n", + "[11-08 13:07:49][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:07:49][DEBUG] jax_fem: Function split_and_compute_cell took 0.3626 seconds\n", + "[11-08 13:07:50][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:07:50][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 13:07:50][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 13:07:50][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 13:07:54][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 2.1285217107550765e-09\n", + "[11-08 13:07:54][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:07:54][DEBUG] jax_fem: Function split_and_compute_cell took 0.0491 seconds\n", + "[11-08 13:07:54][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:07:54][DEBUG] jax_fem: l_2 res = 2.096840944617826e-09, relative l_2 res = 1.206348694586566e-11\n", + "[11-08 13:07:54][INFO] jax_fem: Solve took 4.8171000480651855 [s]\n", + "[11-08 13:07:54][INFO] jax_fem: max of dofs = 4.324117925425383\n", + "[11-08 13:07:54][INFO] jax_fem: min of dofs = -16.506583026282243\n", + "[11-08 13:07:54][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-08 13:07:54][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-08 13:07:54][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n", + "[11-08 13:07:55][DEBUG] jax_fem: Done pre-computations, took 0.8151583671569824 [s]\n", + "[11-08 13:07:55][INFO] jax_fem: Solving a problem with 4496 cells, 5687x3 = 17061 dofs.\n", + "[11-08 13:07:55][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-08 13:07:55][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-08 13:07:55][DEBUG] jax_fem: Start timing\n", + "[11-08 13:07:55][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:07:55][DEBUG] jax_fem: Function split_and_compute_cell took 0.3680 seconds\n", + "[11-08 13:07:55][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:07:56][DEBUG] jax_fem: Before, l_2 res = 173.8171520413047, relative l_2 res = 1.0\n", + "[11-08 13:07:56][DEBUG] jax_fem: Solving linear system...\n", + "[11-08 13:07:56][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 13:07:59][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 2.1285217107550765e-09\n", + "[11-08 13:07:59][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:08:00][DEBUG] jax_fem: Function split_and_compute_cell took 0.0435 seconds\n", + "[11-08 13:08:00][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:08:00][DEBUG] jax_fem: l_2 res = 2.096840944617826e-09, relative l_2 res = 1.206348694586566e-11\n", + "[11-08 13:08:00][INFO] jax_fem: Solve took 4.80546760559082 [s]\n", + "[11-08 13:08:00][INFO] jax_fem: max of dofs = 4.324117925425383\n", + "[11-08 13:08:00][INFO] jax_fem: min of dofs = -16.506583026282243\n", + "[11-08 13:08:00][INFO] jax_fem: Running backward and solving the adjoint problem...\n", + "[11-08 13:08:00][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-08 13:08:00][DEBUG] jax_fem: Function split_and_compute_cell took 0.0419 seconds\n", + "[11-08 13:08:00][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-08 13:08:00][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-08 13:08:04][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 8.434417960217443e-08\n", + "[11-08 13:08:04][DEBUG] jax_fem: Computing cell residual...\n", + "[11-08 13:08:05][DEBUG] jax_fem: Function split_and_compute_cell took 0.3664 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[[-0.01119207 0.02507099 0.10059829]\n", + " [-0.02235498 -0.07067111 0.11654225]\n", + " [ 0.00783549 -0.04585744 0.02469749]\n", + " [-0.00318578 -0.02519117 0.10204217]]\n", + "\n", + " [[ 0.05040131 -0.04360584 -0.24616869]\n", + " [ 0.0016035 0.0234471 -0.25454405]\n", + " [-0.00060138 0.01110184 -0.0205776 ]\n", + " [ 0.01258176 0.02005282 0.02697048]]\n", + "\n", + " [[ 0.0189574 0.027937 0.13203527]\n", + " [ 0.01394692 0.03298108 0.14123243]\n", + " [-0.00158055 0.01742641 0.00706678]\n", + " [ 0.01355303 0.00130551 0.04950303]]]\n", + "[[[-10. -2.5118961 -1.3482366 ]\n", + " [ -3.3333333 -3.4996912 -0.384964 ]\n", + " [ 3.3333333 -3.1632063 0.15275964]\n", + " [ 10. -3.3791158 -0.92453134]]\n", + "\n", + " [[-10. -0.73823303 1.3594279 ]\n", + " [ -3.3333333 -0.14094165 1.3848833 ]\n", + " [ 3.3333333 -0.4549461 1.1504991 ]\n", + " [ 10. 0.37795493 0.11481537]]\n", + "\n", + " [[-10. 2.8471074 -1.0078065 ]\n", + " [ -3.3333333 2.3446648 -0.8511383 ]\n", + " [ 3.3333333 1.5649364 -1.3863742 ]\n", + " [ 10. 2.6057332 0.01166824]]]\n", + "Iteration 40, Loss: 14205.49\n" + ] + } + ], + "source": [ + "import optax\n", + "\n", + "n_steps = 40\n", + "# strong learning rate decay\n", + "schedule = optax.exponential_decay(\n", + " init_value=0.1, transition_steps=n_steps, decay_rate=0.9, staircase=False\n", + ")\n", + "optmizer = optax.adam(learning_rate=schedule)\n", + "opt_state = optmizer.init(initial_params)\n", + "\n", + "params = initial_params.copy()\n", + "loss_hist = []\n", + "params_hist = []\n", + "\n", + "grad_fn = jax.value_and_grad(loss)\n", + "\n", + "for i in range(n_steps):\n", + " loss_value, grads = grad_fn(params)\n", + "\n", + " print(grads)\n", + " print(params)\n", + "\n", + " updates, opt_state = optmizer.update(\n", + " grads, opt_state, params, value=loss_value, grad=grads, value_fn=loss\n", + " )\n", + " params = optax.apply_updates(params, updates)\n", + "\n", + " params = params.at[..., 0].set(initial_params[..., 0]) # fix x-coordinates\n", + "\n", + " # Ensure parameters are within bounds\n", + " params = params.at[..., 1].set(\n", + " jnp.clip(params[..., 1], -Ly / 2 + bar_radius, Ly / 2 - bar_radius)\n", + " )\n", + "\n", + " # Clip the z-coordinates to be within the bar radius\n", + " params = params.at[..., 2].set(\n", + " jnp.clip(params[..., 2], -Lz / 2 + bar_radius, Lz / 2 - bar_radius)\n", + " )\n", + "\n", + " loss_hist.append(loss_value)\n", + " params_hist.append(params)\n", + "\n", + " print(f\"Iteration {i + 1}, Loss: {loss_value:.2f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 228, + "id": "16cabfa8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Compliance over Optimization')" + ] + }, + "execution_count": 228, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlIAAAHHCAYAAAB0nLYeAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAhn5JREFUeJzt3Xd8VFX6P/DPnUkmPYEAIaGFXkJVimIDKQKriK7ddQV3RUWwIWv5roq4rth+KAqi7q7YhbWLBaUILgjSRI0UIUZADQQCpE3qzPn9Mbl3ZjIlM3futHs/79fLl+TOzcyZkplnnvOc50hCCAEiIiIiCpop2gMgIiIiilcMpIiIiIhUYiBFREREpBIDKSIiIiKVGEgRERERqcRAioiIiEglBlJEREREKjGQIiIiIlKJgRQRERGRSgykiMiNJEl48MEHlZ9ffvllSJKEX375JWpjovD75ZdfIEkSXn75Zc2uc926dZAkCevWrdPsOmP5dsmYGEgRhUFRURFuvPFGdO/eHcnJycjMzMSZZ56JhQsXoqamJtrDozhQVlaGv/3tb+jTpw+Sk5ORnZ2NCRMm4OOPPw7pet988008/fTT2gwyyp577jlNAz8iNSTutUekrU8++QSXXXYZkpKScO2112LAgAGor6/Hhg0b8O6772LatGl48cUXoz1MnyRJwty5c5WslM1mQ0NDA5KSkiBJUnQHZxB79+7F2LFjcfToUVx33XUYNmwYTp48iTfeeAM7d+7EnDlz8MQTT6i67gsuuACFhYUeGUYhBOrq6pCYmAiz2azBvQDsdjvq6+thsVhgMmn/vX3AgAFo27atR+Yp3LdL5Coh2gMg0pPi4mJceeWVyM/Px9q1a5GXl6dcNnPmTOzfvx+ffPJJFEcYPLPZrNkHKzlUV1cjLS3N62UNDQ249NJLceLECXz11Vc47bTTlMvuuOMO/OlPf8KTTz6JYcOG4YorrtBsTJIkITk5WbPrAwCTyaT5dcby7ZJBCSLSzE033SQAiI0bNwZ0fkNDg3jooYdE9+7dhcViEfn5+eLee+8VtbW1bufl5+eL888/X3z55Zdi6NChIjk5WQwYMEB8+eWXQggh3n33XTFgwACRlJQkTj31VLFjxw633586dapIS0sTRUVF4rzzzhOpqakiLy9PzJs3T9jtdrdzAYi5c+cqPy9dulQAEMXFxcqxDz74QPzhD38QeXl5wmKxiO7du4uHHnpINDY2ul3XqFGjRP/+/cWPP/4oRo8eLVJSUkSHDh3EY4895vFY1NTUiLlz54pevXqJpKQkkZubKy6++GKxf/9+5RybzSaeeuopUVBQIJKSkkROTo644YYbxPHjxwN6vNesWSPOOusskZqaKrKyssSFF14odu3apVz+9ttvCwBi3bp1Hr/7/PPPCwDihx9+UI7t3r1bXHLJJaJ169YiKSlJDB06VHz44Yduvyc/fuvWrRMzZswQ7dq1E61atfI5xrfeeksAEA899JDXy0+ePClatWol+vbtqxz78ssvBQCxbNkyce+994r27duL1NRUMXnyZHHw4EHlvFGjRgkAbv/l5+cLIYQoLi4WAMTSpUuV8+XXzYEDB8T5558v0tLSRIcOHcSiRYuEEEJ8//334txzzxWpqamiS5cu4o033nAbqzwu+XUqPxbe/hs1apTyey+99JI499xzRbt27YTFYhH9+vUTzz33nNt15+fn+7yO5rcr++9//ytOPfVUkZycLNq0aSP+9Kc/iV9//dXtHPk+//rrr2LKlCkiLS1NtG3bVtx5550er28iIYRgIEWkoY4dO4ru3bsHfP7UqVMFAHHppZeKxYsXi2uvvVYAEBdddJHbefn5+aJPnz4iLy9PPPjgg+Kpp54SHTt2FOnp6eL1118XXbp0EY8++qh49NFHRVZWlujZs6ew2Wxut5OcnCx69eol/vznP4tFixaJCy64QAAQ999/v9ttBRJIXXTRReLyyy8XTzzxhFiyZIm47LLLBAAxZ84ct+saNWqU6NChg+jcubO47bbbxHPPPSfGjBkjAIhPP/1UOa+xsVGMHTtWABBXXnmlWLRokZg/f74YM2aM+OCDD5Tzrr/+epGQkCCmT58unn/+eXH33XeLtLQ0MXz4cFFfX+/3sV61apVISEgQvXv3Fo8//riYN2+eaNu2rWjdurVy36xWq0hPTxc333yzx++fe+65on///srPhYWFIisrSxQUFIjHHntMLFq0SJxzzjlCkiTx3nvveTx+BQUFYtSoUeLZZ58Vjz76qM9xXn311QKA+OWXX3yeI79u9u3bJ4RwBg4DBw4UgwYNEgsWLBD33HOPSE5OFr179xZWq1UIIcQXX3whhgwZItq2bStee+018dprr4n3339fCOE7kEpOThYFBQXipptuEosXLxZnnHGGcl6HDh3E3/72N/Hss8+K/v37C7PZLH7++Wfl95sHNEVFRcrtyv89/PDDAoC47LLLlN8bPny4mDZtmnjqqafEs88+K8477zwBQAnghBDi/fffF506dRJ9+/ZVruuLL77weruuz8Pw4cPFU089Je655x6RkpIiunbtKk6cOOFxn/v37y/+8pe/iCVLlohLLrlEAPAI5oiEYCBFpJny8nIBQEyZMiWg83fu3CkAiOuvv97t+Jw5cwQAsXbtWuWY/O3766+/Vo59/vnnAoBISUkRBw4cUI6/8MILHh8i8gfvLbfcohyz2+3i/PPPFxaLRRw9elQ5HkggJX8wu7rxxhtFamqqWzZNzoC8+uqryrG6ujqRm5srLrnkEuXYSy+9JACIBQsWeFyvnDH73//+JwB4ZD1Wrlzp9XhzQ4YMETk5OaKsrEw59t133wmTySSuvfZa5dhVV10lcnJy3LIPJSUlwmQyuWWJxo4dKwYOHOh2f+12uzjjjDNEr169lGPy43fWWWcFlNEYMmSIyMrK8nvOggULBADx0UcfCSGcgUPHjh1FRUWFct5///tfAUAsXLhQOXb++ecrWShXvgIpAOKRRx5Rjp04cUKkpKQISZLEsmXLlON79uzxeO34ygzJampqxNChQ0WHDh1ESUmJctzb62vChAkeX1L69+/vlsnydbv19fUiJydHDBgwQNTU1CjnffzxxwKAeOCBBzzuc/OM4CmnnCKGDh3q9X6QsbEKj0gjFRUVAICMjIyAzv/0008BALNnz3Y7fueddwKARy1VQUEBRo4cqfws186MGTMGXbp08Tj+888/e9zmrFmzlH9LkoRZs2ahvr4eq1evDmjMspSUFOXflZWVOHbsGM4++2xYrVbs2bPH7dz09HRcc801ys8WiwUjRoxwG9+7776Ltm3b4pZbbvG4LbnA/e2330ZWVhbGjx+PY8eOKf8NHToU6enp+PLLL32Ot6SkBDt37sS0adOQnZ2tHB80aBDGjx+vPBcAcMUVV6C0tNStgPmdd96B3W5XapKOHz+OtWvX4vLLL1fu/7Fjx1BWVoYJEyZg3759+O2339zGMH369IBqzSorK1t8DcmXy6852bXXXuv2u5deeiny8vLc7p8a119/vfLvVq1aoU+fPkhLS8Pll1+uHO/Tpw9atWrl9XXny80334wffvgB7777LnJzc5Xjrq+v8vJyHDt2DKNGjcLPP/+M8vLyoMe/bds2lJaW4uabb3arnTr//PPRt29fr3WLN910k9vPZ599dlD3jYyDxeZEGsnMzATg+CAMxIEDB2AymdCzZ0+347m5uWjVqhUOHDjgdtw1WAKArKwsAEDnzp29Hj9x4oTbcZPJhO7du7sd6927NwAE3SPqxx9/xH333Ye1a9d6fJg3/6Dr1KmTx2q/1q1b4/vvv1d+LioqQp8+fZCQ4Pstad++fSgvL0dOTo7Xy0tLS33+rvxY9unTx+Oyfv364fPPP1cKwCdOnIisrCwsX74cY8eOBQAsX74cQ4YMUR6v/fv3QwiB+++/H/fff7/P8XTs2FH5uVu3bj7H5yojIwPHjh3ze478GmsecPXq1cvtZ0mS0LNnz5B6gCUnJ6Ndu3Zux7Kysrw+r1lZWR6vO19eeOEFLF26FC+88AJOP/10t8s2btyIuXPnYtOmTbBarW6XlZeXK6/xQPl7/vv27YsNGza4HfN2n1u3bh3wfSNjYSBFpJHMzEx06NABhYWFQf1eoC0FfGUzfB0XYepscvLkSYwaNQqZmZl46KGH0KNHDyQnJ2PHjh24++67YbfbwzI+u92OnJwcvPHGG14vb/7Bp1ZSUhIuuugivP/++3juuedw5MgRbNy4EY888ojbWABgzpw5mDBhgtfraR4gu2ZZ/OnXrx927tyJgwcPegTPMjkILSgoCOg6QxGO192WLVtw22234frrr8cNN9zgdllRURHGjh2Lvn37YsGCBejcuTMsFgs+/fRTPPXUUx6vr3DgKlUKBgMpIg1dcMEFePHFF7Fp0ya3aThv8vPzYbfbsW/fPvTr1085fuTIEZw8eRL5+fmajs1ut+Pnn39WsioA8NNPPwEAunbtGvD1rFu3DmVlZXjvvfdwzjnnKMeLi4tVj61Hjx745ptv0NDQgMTERJ/nrF69GmeeeWbAQYlMfiz37t3rcdmePXvQtm1bt3YEV1xxBV555RWsWbMGu3fvhhDCrdWAnNlLTEzEuHHjghpLSy644AK89dZbePXVV3Hfffd5XF5RUYEPP/wQffv29QjW9u3b5/azEAL79+/HoEGDlGPR7gV29OhRXHrppRgyZAgWL17scfmKFStQV1eHjz76yC2Q9DZ1G+h9cX3+x4wZ43bZ3r17Nf9bI2NhjRSRhu666y6kpaXh+uuvx5EjRzwuLyoqwsKFCwEAf/jDHwDAo8v0ggULADjqN7S2aNEi5d9CCCxatAiJiYnKFFYg5G/rrpmH+vp6PPfcc6rHdckll+DYsWNu43MdJwBcfvnlsNls+Mc//uFxTmNjI06ePOnz+vPy8jBkyBC88sorbucVFhbiiy++UJ4L2bhx45CdnY3ly5dj+fLlGDFihNvUXE5ODkaPHo0XXngBJSUlHrd39OjRlu6yT5deeikKCgrw6KOPYtu2bW6X2e12zJgxAydOnMDcuXM9fvfVV191m1p+5513UFJSgkmTJinH0tLSVNUZacFms+HKK69EfX093n33XVgsFo9zvL2+ysvLsXTpUo9z09LS/D7vsmHDhiEnJwfPP/886urqlOOfffYZdu/eHZa/NTIOZqSINNSjRw+8+eabuOKKK9CvXz+3zuZff/013n77bUybNg0AMHjwYEydOhUvvviiMl22ZcsWvPLKK7joootw7rnnajq25ORkrFy5ElOnTsVpp52Gzz77DJ988gn+7//+L6hpsTPOOAOtW7fG1KlTceutt0KSJLz22mshTSVee+21ePXVVzF79mxs2bIFZ599Nqqrq7F69WrcfPPNmDJlCkaNGoUbb7wR8+fPx86dO3HeeechMTER+/btw9tvv42FCxfi0ksv9XkbTzzxBCZNmoSRI0fir3/9K2pqavDss88iKyvLbW9BwJFp+uMf/4hly5ahuroaTz75pMf1LV68GGeddRYGDhyI6dOno3v37jhy5Ag2bdqEX3/9Fd99952qx8JiseCdd97B2LFjcdZZZ7l1Nn/zzTexY8cO3Hnnnbjyyis9fjc7O1v5nSNHjuDpp59Gz549MX36dOWcoUOHYvny5Zg9ezaGDx+O9PR0TJ48WdVYg/X8889j7dq1uOmmmzwyTO3bt8f48eNx3nnnwWKxYPLkybjxxhtRVVWFf/3rX8jJyfEIWocOHYolS5bg4YcfRs+ePZGTk+ORcQIcz+djjz2G6667DqNGjcJVV12FI0eOYOHChejatSvuuOOOsN5v0rkorRYk0rWffvpJTJ8+XXTt2lVYLBaRkZEhzjzzTPHss8+6LZdvaGgQ8+bNE926dROJiYmic+fOfhtyNgdAzJw50+2YvIz9iSeeUI55a8jZvn17MXfuXLd+U/J1ttT+YOPGjeL0009XGmzeddddSjsG16XuckPO5qZOneqxBN9qtYq///3vymORm5srLr30UlFUVOR23osvviiGDh0qUlJSREZGhhg4cKC46667xO+//+5xO82tXr1anHnmmSIlJUVkZmaKyZMnuzXkdLVq1SoBQEiSJA4dOuT1nKKiInHttdeK3NxckZiYKDp27CguuOAC8c477yjnyI/f1q1bWxyfq9LSUjF79mzRs2dPkZSUJFq1aiXGjRuntDxwJS/3f+utt8S9994rcnJyREpKijj//PPdWmMIIURVVZW4+uqrRatWrQJuyNmcr+e1+eu0eRuCuXPnBtSQ86OPPhKDBg0SycnJomvXruKxxx5TWmS4vg4PHz4szj//fJGRkRFQQ87ly5eLU045RSQlJYns7Gy/DTmbk8dO1Bz32iMygGnTpuGdd95BVVVVtIdCYbBu3Tqce+65ePvtt/1m5YhIe6yRIiIiIlKJgRQRERGRSgykiIiIiFRijRQRERGRSsxIEREREanEQIqIiIhIJTbkDCO73Y7ff/8dGRkZUd+WgYiIiAIjhEBlZSU6dOgAk8l/zomBVBj9/vvv6Ny5c7SHQURERCocOnQInTp18nsOA6kwysjIAOB4IjIzM6M8GiIiIgpERUUFOnfurHyO+8NAKozk6bzMzEwGUkRERHEmkLIcFpsTERERqcRAioiIiEglBlJEREREKjGQIiIiIlKJgRQRERGRSgykiIiIiFRiIEVERESkEgMpIiIiIpUYSBERERGpxM7mRFFkswtsKT6O0spa5GQkY0S3bJhN3OCaiCheMJAiipKVhSWYt2IXSsprlWN5WcmYO7kAEwfkRXFkREQUKE7tEUXBysISzHh9h1sQBQCHy2sx4/UdWFlYEqWRERFRMBhIEUWYzS4wb8UuCC+XycfmrdgFm93bGUREFEsYSBFF2Jbi4x6ZKFcCQEl5LbYUH4/coIiISBUGUkQRVlrpO4hScx4REUUPAymiCMvJSNb0PCIiih4GUkQRNqJbNvKykuGryYEEx+q9Ed2yIzksIiJSgYEUUYSZTRLmTi4AAI9gSv557uQC9pMiIooDDKSIomDigDwsueZU5Ga5T9/lZiVjyTWnso8UEVGcYCBFFCUTB+Rhw91jkJLo+DPslZOGDXePYRBFRBRHGEgRRZEEoLbR7vi3JHE6j4gozjCQIoqi6vpGiKa+m9V1tugOhoiIgsZAiiiKKmsbXf7dEMWREBGRGgykiKLINZCqrrdBCG4LQ0QUTxhIEUWRaxbKZheobbBHcTRERBQsBlJEUeSakQKAqrpGH2cSEVEsYiBFFEUVzeqiGEgREcUXBlJEUdQ8I1XNQIqIKK4wkCKKouaBVPOfiYgotjGQIoqi5i0POLVHRBRfGEgRRRGn9oiI4hsDKaIoap6RqmQgRUQUVxhIEUWRnJGSmrbYY0aKiCi+MJAiiiI5kGqbngQAqGKxORFRXGEgRRRFch+pvKxkACw2JyKKNwykiKJIzkgxkCIiik8MpIiiqFLJSKUAYI0UEVG8YSBFFCVCCCUDxYwUEVF8YiBFFCXV9TbYhePfuU2BFDubExHFFwZSRFEiT+slmCS0a1q1x6k9IqL4wkCKKErk7FNGcgLSkxMAcGqPiCjeMJAiihI5I5WRnIj0JAZSRETxiIEUUZRUuGakmgKp6rpGCCGiOSwiIgoCAymiKPE2tWcXQE2DLZrDIiKiIDCQIooS16m9lEQzTE377XGbGCKi+MFAiihKXDNSkiQhjXVSRERxh4EUUZTIGanM5EQAYME5EVEcYiBFFCWuGSnAJZDi1B4RUdxgIEUUJc0DKU7tERHFHwZSRFHiWmzu+D8DKSKieMNAiihKKnxM7XGbGCKi+MFAKkhWqxX5+fmYM2dOtIdCcc45tefISMlTe5UMpIiI4gYDqSD985//xOmnnx7tYZAOOKf2mJEiIopXDKSCsG/fPuzZsweTJk2K9lBIB+SMVCZX7RERxa2oB1JLlizBoEGDkJmZiczMTIwcORKfffaZprfx1VdfYfLkyejQoQMkScIHH3zg9bzFixeja9euSE5OxmmnnYYtW7a4XT5nzhzMnz9f07GRMQkhlKJyeWovXSk25xYxRETxIuqBVKdOnfDoo49i+/bt2LZtG8aMGYMpU6bgxx9/9Hr+xo0b0dDQ4HF8165dOHLkiNffqa6uxuDBg7F48WKf41i+fDlmz56NuXPnYseOHRg8eDAmTJiA0tJSAMCHH36I3r17o3fv3iruJZE7a70NNrtjc2LP9geer28iIopNUQ+kJk+ejD/84Q/o1asXevfujX/+859IT0/H5s2bPc612+2YOXMmrr76athszm/te/fuxZgxY/DKK694vY1Jkybh4YcfxsUXX+xzHAsWLMD06dNx3XXXoaCgAM8//zxSU1Px0ksvAQA2b96MZcuWoWvXrpgzZw7+9a9/4aGHHgrx3pNRydN6ZpOElEQzACCDfaSIiOJO1AMpVzabDcuWLUN1dTVGjhzpcbnJZMKnn36Kb7/9Ftdeey3sdjuKioowZswYXHTRRbjrrrtU3W59fT22b9+OcePGud3WuHHjsGnTJgDA/PnzcejQIfzyyy948sknMX36dDzwwANer2/x4sUoKCjA8OHDVY2H9M+10FySHLsVOzNSnNojIooXMRFI/fDDD0hPT0dSUhJuuukmvP/++ygoKPB6bocOHbB27Vps2LABV199NcaMGYNx48ZhyZIlqm//2LFjsNlsaN++vdvx9u3b4/Dhw0Ff38yZM7Fr1y5s3bpV9ZhI35r3kAJci805tUdEFC8SWj4l/Pr06YOdO3eivLwc77zzDqZOnYr169f7DKa6dOmC1157DaNGjUL37t3xn//8R/lWHwnTpk2L2G2RPikZqaRE5Ziz/QEzUkRE8SImMlIWiwU9e/bE0KFDMX/+fAwePBgLFy70ef6RI0dwww03YPLkybBarbjjjjtCuv22bdvCbDZ7FKsfOXIEubm5IV03kTfN99kDXFftsUaKiChexEQg1ZzdbkddXZ3Xy44dO4axY8eiX79+eO+997BmzRosX748pE7jFosFQ4cOxZo1a9zGsGbNGq+1WkShat7VHHDJSNU3wt60oo+IiGJb1Kf27r33XkyaNAldunRBZWUl3nzzTaxbtw6ff/65x7l2ux2TJk1Cfn4+li9fjoSEBBQUFGDVqlUYM2YMOnbs6DU7VVVVhf379ys/FxcXY+fOncjOzkaXLl0AALNnz8bUqVMxbNgwjBgxAk8//TSqq6tx3XXXhe/Ok2HJU3uZXmqkhACsDTblZyIiil1Rf6cuLS3Ftddei5KSEmRlZWHQoEH4/PPPMX78eI9zTSYTHnnkEZx99tmwWCzK8cGDB2P16tVo166d19vYtm0bzj33XOXn2bNnAwCmTp2Kl19+GQBwxRVX4OjRo3jggQdw+PBhDBkyBCtXrvQoQCfSgrepveREE8wmCTa7QHVdIwMpIqI4EPV36v/85z9Bne8twAKAU045xefvjB49GkK0PFUya9YszJo1K6jxEKnhbH/gnNqTJAlpFjMqahtRWduI9pnRGh0REQUqJmukiPTOW0bK8bMjsGLBORFRfGAgRRQFFV6KzQEgLcnR5byagRQRUVxgIEUUBa6dzV3JdVFyxoqIiGIbAymiKPA1tZemNOVkIEVEFA8YSBFFQWWdZ7G542c25SQiiidRX7VHZERyRirTx9QeAymKZTa7wJbi4yitrEVORjJGdMuG2RS5bbqIYgkDKaIIE0J47WwOOKf2GEhRc7ESvKwsLMG8FbtQUl6rHMvLSsbcyQWYOCAv4uMhijYGUkQRVtNgg61pCxiP9geskSIvYiV4WVlYghmv70DzrnyHy2sx4/UdWHLNqQymyHBYI0UUYXI2ymySkGoxu12mZKS4ao+ayMGLaxAFOIOXlYUlERmHzS4wb8UujyAKgHJs3opdypcEIqNgIEUUYXLrg/SkBEiS+9RMOovNyUUsBS9bio97BHPNx1NSXostxcfDPhaiWMJAiijCKny0PgBYbE7uYil4Ka30PQ415xHpBQMpogjzVWgOMJAid7EUvORkJGt6HpFeMJAiijBfXc0Brtojd7EUvIzolo28rGT4WicowVEAP6JbdtjHQhRLGEgRRZivHlKAS0aKxeaE2ApezCYJcycX+BwHAMydXMB+UmQ4DKSIIsyZkfKc2pOzVGx/QIB78NI8PIlG8DJxQB6WXHOqx5eA3Kxkw7c+sNkFNhWV4cOdv2FTURlXLxoI+0gRRZivffYAl7326m2w2wVM/HZveHLw8sCHP6K0sk45nhulJpgTB+Th52PVeHzlXgDAY5cMxKVDOxs6ExUrfb4oOpiRIoowf4GUPLUHANX1zEqRw8QBeVh2w+nKz5cP64QNd4+J2od0bb1N+XePdumGD6Jioc8XRQ8DKaIIq/AztZeUYEJC04cSC87JVW2DXfl3m/SkqAYvVXXOQKraJagymljq80XRw0CKKML8ZaQkSVKacrJOily5Ziij/dqwuozFauDXaSz1+aLoYSBFFGH+is0BIM2S0HSecT+gyJNr8FRdF90skGsWysgZqVjq80XRw0CKKML8ZaRcj3Nqj1y5Bk/WKNfPuWahoj2WaIqlPl8UPQykiCLMXx8pwGXlHgMpcuH6eoh2kF0VQ9mxaIqlPl8UPQykiCKspak9eeUep/bIlWuNlDXK02mut2/kjFSs9fmi6GAgRRRBQogWp/ZYbE7euNdIRfe14V74btyMFODs85WTmeR2nE1KjYMNOeOQzS6wpfg4SitrkZPhSBvzG098qG2wo7FpKbTPjJSFNVLkyb3AO9o1UsxIuZo4IA+DO7fCyPlrAQDnD8zFM1edyvdlg2AgFWfYQTe+ydN6JglIs5i9npOuFJsb+5s+uXPNQlmjvmovduq1YkWdS5+vrFQLgygD4dReHFHTQZf7P8WWiqZpvfSkBEiS9zdaudi8qq4hYuOi2FddFxsZKSGEe1Bn4PYHrqrZW8uwmJGKEy110JXg6KA7viBX+SbE7FXsaanQHAAylFV7/IAiJ9fgpbbBDptdRCXrUddoh+v3sWjXa8UKK3trGRYzUnEi0A66SzcW46S1XvX+T8xghVdLheaAMyPFVXvkqnkWKlpZqeaBEzNSDlXsrWVYzEjFiUA74z78yW48/MlumCQElb0CmMGKBGcPKd8ZKWeNFKf2yMkjgKmz+X0dhUvzwCnahe+xwrVujdlkY2FGKk4E3kHXsQTXXyJJzl49/Mku/G/fURw6bsWn33MH80hwTu35/g6TnuQoQuebMblq/nqIWkaq3jOgo+Z9vhhcGgkzUnFC7qB7uLzWa6ZJgqNvyYa7x+Cd7Ydw97s/tHidSzf+gqUbf/F7jr8MFgUvkKm99CRHloGrociVx9RelF4f8u1KEiAEM1IyK7u9GxYzUnEimA66XbLTArrOofmt0TMnHQktBEfcwVw7gRSbpzVlpBhIkSvXAMbxc3Q+rOXbbZNmAeCY6hOCtZTV7PZuWAyk4ojcQTc3y32ar3kH3UD3f/rvjSOxevYoPHHZ4IBunzuYh64igIxUhpyRYrE5uXAGMI7p+2h9WMu32zbdMQ6bXaCu0e7vVwzBrfM8C/ANhVN7cWbigDyML8j129lczl7NeH0HJLgXnXvb/yk3kzuYR4pzaq/lYvOaBlvUlrhTbKlvtKPe5ghWcjKScKyqLmoZSzmga5eRhD2HK5uONSI50XuDWaNwLcKvb7SjwWZHopm5CiPgsxyHzCYJI3u0wZQhHTGyRxuvH7SBZq+AljNYgGM6wWbnt85QBVJsLk/tAZzeIwfX7FO7DDkjFaWpvXpnVjWlKXhiCwS2hTAyZqR0LJDsFeA/gyUTApi6dCvmTi7An0/P99mVm/xT2h+k+M5IJSWYYTGbUG+zo7quEVl+ziVjkKeKLGYTWqU6Xg/RKzZ3jCXVkoC0JDNqGmwsOIdn4GSt59+uUTAjpXOBZK8A3xmsvKxkPHPlEEwZ0gE2u8ADH/6I/3v/B9Q31USwgWdwKutazkgBLDgnd3LQlJZkVhq2RqvYXM6OpVnMSLWwC7+s+d8qHxPjYEaKFP4yWJMHd0BBXiYeXbkHb205hH1HqnDZsM54evVPbOAZBGdDTv9/eunJCThhbWB3cwLgDKRSLQnKZtfRKjZXMlJJCUiN8lhiSfPHgI+JcTCQIjdyBqs5SZJw46ge6J2bgVvf+hbbDpzAtgMnPM6TG3g2r8Mih0CKzQEgTfmmzzdjcgYv6UkJzixQlFftpVnMSOe+kAqPhql8TAyDU3sUlHP75ODdGWf4nCKUJ/bmrdjFab5mhBABFZu7Xs6pPQKcr4O0pOgHL86xJCC1aSzMvjAjZWQMpChoZVX1foMkNvD0rrbBjgab43FrMSOVxECKnJQsUFICUpUthKKVkXIEcGku04zsm+R8DJTFAHxMDIOBFAUt0MacbODpTs5GmSQoH0C+yFkHNuUkwKXY3JKgTPtGrf2BXK+V5Cw2tzLgVx6Xdk2NSvmYGAcDKQpa4Bsos4GnK7mreXpSQovtI+SpPdZIEeDMbjiCFzkLFAMZqShnx2KF3S6UxyUn0xFIMSNlHAykKGiBbkEzolt2JIcV8wLZZ08mZx04tUeAM1BJT0pwqZGK7qbFaW6F78YOGmoanPefGSnjYSBFQfO3gTLgqJH6+/n9Ynprk2j0v6oMYJ89WTqLzcmFtwLvqG1aXC+3YjBHvRVDrJAfE0kCstOYkTIatj8gVeQGnvNW7HLrIyV3Rt9afBwXDOoQtfH5s7KwxGPckeh/5ewh1XJGKp3F5uTCWidPp0U/eFHGEgNBXayornNOd6YnMbg0GgZSpJq3Bp4nqutx85s78MqmA+idm4E/nZYf7WG6WVlYghmv7/DYBicS/a8CbX0AsNic3FW5rNqLZmdzIYSSfYmFoC5WOBummhlcGhADKQqJtwaec471xpNf/IS5H/6I7m3TvTb4jAabXWDeil3e9xKEI5s2b8UujC/IDcu0ZDBTe2x/QK6sXlbt1dvsqG+0w5IQuQqNukY75Fnw1CgHdbFELjRPT4p+53mKPNZIkeZmntsTkwd3QKNdYMYb23GwzBrtIQEAthQfd5vOay7c/a+CKTZnjRS5qnabTnO2zqiJcB2O6+sxNdGsrNozetCg1I25tIRgjZRxMJAizUmShCcuHYRBnbJw0tqA61/dqgQR0RTt/lcVwRSbR3llFsUW1w/qRLNJyUJVRTiAkeujUi1mmEwSg4YmzsfF2RKCq/aMg4EUhUVyohkv/nkYcjKS8NORKty+bCfqG+0RXynnKtr9rwLdZw9gsTm5c21/ADgbukb6w9q5Yk8eBxtyAq4NU5mRMiLWSFHY5GYl48Vrh+GKFzZhzZ5SnPLQF25vLpFYKedK7n91uLzWa52U1DTmcPW/UlVsbvAPKHKoclkVBjgCmRPWhoh/WDu3qnEEcvI0o9Ffp9VuiwE43Wk0zEhRWA3p3Ap/Oq0LAM9vaPJKuZWFJREZi9z/ylcQBQBzJxeErf9VUH2kmgKp2gY7Gm32sIyH4kfzACZaU7/VLlNYANy2qxHCuJuUu3Z7VzJSBi/ANxIGUhRWNrvAZ4WHvV4mv+3OW7ErYtN8Ewfk4fJhnTyO52Ylh7X1AQBU1jkyUoH0kZJXQwF8QzY61+1H5NdFtDYudk4xumekGu0C9QYO+F33H3QGl8xIGQUDKQqraK+U80aehkhsyjxNHNAeG+4eE/YpxmAyUpYEZ0GxHICRMVldth9J85IJiiRlzz95ijHRuYLQauCA33VT6VRlas8Ge4TrQCk6GEhRWEV7pVxzQghs/eUEAGDSQEfg1GgTEdnOJphicwDIYI8egvND2iQByYmOt+y0KNUmNZ9iTDCbkNQU8EdrE+VY4LqptBzkAu578JF+MZCisIr2SrnmDpRZcbSyDhazCZMHO7awOXg8/H2uhBBBFZsDrk05mZEyMtdNgiXJEfBHa/qoeY0U4KzXinR2LJbIz0N6UgKSE01oepoMHVwaCQMpCit5pZyvfI8Ex+q9cK2Ua27LL44pxEGdstArJx2AI5AKd6FsXaMdDTbHbQQaSMkfUJXcJsbQqput2ANca6QiPLXXrA2D+1iM+zp1DTAlSXJpC2Hc4NJIGEhRWMkr5QB4DaYEwrtSrrltTYHU8G7Z6NAqBSbJsTLuaGVdWG+3oikbJUnuH4j+pHNqj+Ccvktz6WgetYyU0kfK21iM+zq1uuw/CDgfH2akjIGBFIXdxAF5WHLNqcjN8py+S04w4ZQurSM2Frk+akTXbFgSTMjLSgEQ/uk9OauUnpQAU4BBo3ObGE7tGZnVpUeRzDntG+E+UnXuqwcBl6DBwBkp+XmQNyxO43SnobAhJ0XExAF5GF+Qiy3Fx1FaWYt26Ul4bOUefPdrOf7x8S4suvrUsI+htLIWxceqIUnAqfmO4K1Ldip+O1mDg8etGNY1fNOLciAVSOsDWXqUPiwptlS5rAiTpUZpY1yvGSk5c2rg7IuzRqpZRsrAwaWRMCNFEWM2SRjZow2mDOmIM3q2xT8vHgiTBHz8fQn+t+9o2G9/W1M2qk/7DGSlOAKa/DapACKRkQqu0BxwyTqwRsrQnD2kvAQvkc5I1Xup17JEp14rlvhrVEr6x0CKomZAxyxMPaMrAOCBD39EbZiXCm9tqo9yLWzvnN0USJVFZmovmEBKPtfI3/TJfdWeLC1Knc2rvI2FDShdaqSi2zCVooOBFEXV7PG9kZORhOJj1Xjxq5/DeltyIDXcZQqvS3akM1KBT+3Jb8pctWds3oOX6EztybeX6pIdi9YKwljh2nlefiyYkTIWBlIUVRnJibj/AseqvkVf7seBsuqw3E5lbQN2/V4BIFqBVPAZKbnYnN9qjc05neYSvMj7uUV602IvrRiMnpHy1nmeq/aMhYEURd0Fg/JwVs+2qG+044EPfwxLT6dvD56EXQCds1PcVg/KNVKllXWoCeOHUoWaQCpK3asptnjLSEVt02IvxebRCupihdVr53n2kTISBlIUdZIk4aEp/WExm7D+p6NY6WOT41B4m9YDgKyURCW4OXQifFkpNVN76UmOc1lsbmxWb6v2orZpsSMwSHer12qaZjRowF/tUoAvd55nRspYGEhRTOjeLh03jeoOAJi3YpfmWRh5U+TmgZQkSc7pvTAWnKuZ2ovWfmoUW6q89G5yrcEJd1d+mRDCmZHytoLQoBkpOZj19pgwI2UMDKQoZtx8bk90yU7F4YpaLFz9k2bXW9dow85DJwF4BlJAZFogqMlIZSgNORlIGVnzjYJd/91oF6hrtEdkHLUNdsgxWyz0tIoV1X76fDEjZQwMpChmJCeaMW9KfwDASxt/wY+/l2NTURk+3PkbNhWVwWZX98278LcK1DXakZ1mQY92aR6Xd45AwbmzIWfwfaRYbG5s3j+onf+O1Mow16AgJdFzixijNo519vnynjEk/WNnc4op5/bJwaQBufis8DAuWrxR2egXcGxuPHdyASYOyAvqOuX6qGH5rZUaBleRWLmnatWevGkxAylD81ZsbjZJSE40obbBjuq6RmSnWcI+DqvSdNLsts1RquFrpLwU4LOPlKEwI0Ux55zebQHALYgCgMPltZjx+g6sLCwJ6vq2Fns24nQVmUBKxdReU7F5faMd9RGavqHY462zOeCyci9C00feAjqA2Rdv+w8a/TExGgZSFFNsdoFn1uz3epkcVs1bsSvgaT67XWDbAcfWMN7qowAgP9sx3XfouBV2ldOHLQml2BzgN1sj8xXAKG0HIjSl5uze7R7Qya9To9YDeW8JYezHxGgYSFFM2VJ8HCXltT4vFwBKymuVVXgt2VdahfKaBqRazOjfIdPrOXmtkmE2SahrtKO0sk7NsFvkDKQCz0glmE1KXxoWnBuTEMLr/nZA5Iu85VV5qR7jMPYKNW81bFy1ZywMpCimlFb6DqLUnLelqT7qlC6tkGD2/nJPNJvQoZWjSWc4pvdqG2yotzmm5oLJSAHO6RsGUsZU12hXsq/Np/YivXGx0s+q+TiaAoh6mzGnoKu9FJszI2UsDKQopuRkJLd8UhDnbfPRiLO5cNZJydkoSQLSLQykKHCuz3vzTFCkV3X6zEi5BFbh3B0gVnkLMJWMVAT7fFH0MJCimDKiWzbyspLhubbOQYJj9Z6vwvHmlELzFgMpR51UeAIpR6F5uiXBbbVTINIYSBmaPDWUkmiGudlrJ9IbF8sBW3qzWq1EswmWBMdHiREzMN4CzJSm58YWwT5fFD0hBVL19fXYu3cvGhuN98dD4WE2SZg72bGJsa+QY+7kAo8PFW9+PWHF7+W1SDBJGNKlld9znd3Ntd80WU2huUzJSHGbGEPyVWgORH6PO29F1bJIB3WxpNpLRirVpc8WV+7pn6pAymq14q9//StSU1PRv39/HDx4EABwyy234NFHH9V0gGQ8EwfkYck1p7ptLgw4AqvHLx0UcB8puX9U/45ZHtMRzUViai+YQnNZtDanpdjgrau5LD3CvYq8LfOXRXoFYSyp9rIYIMFsQpKcpePfru6pCqTuvfdefPfdd1i3bh2Sk50fduPGjcPy5cs1GxwZ18QBedhw9xi8Nf10LLxiCLq1TYMA8EsQGaOtvzjaHozo2rrFc52BVI2q8frj7CGlIiPFbWIMrcrLijBZaoSLzf1mpAzcgNJnEb5LnRTpm6pA6oMPPsCiRYtw1llnuXWK7t+/P4qKijQbHBmb2SRhZI82mHJKR9wzqS8A4JWvD6Dc2hDQ78v1UcNaqI8CgC5N++0dq6rTfHpCk6k9A35AkfNDuHldEhC9GqlYmGaMJb7bQhh3utNoVAVSR48eRU5Ojsfx6upqr1twEIVqfL/26Jubgaq6Riz9urjF809U12NfaRWAllfsAUBWSiKyUhxTb1pP71Wo6GouY42UsckBdKqXqb1IL0RwTmH5zkgZMWjwNf3K7ubGoSqQGjZsGD755BPlZzl4+ve//42RI0dqMzIiFyaThFljegIAXtpQrEyX+SJ3M++Zkx7wPmTOgnNtAyktMlJGXA1F/rNAkf6gtipBHWukXMnPka+2EEac7jQaVZsWP/LII5g0aRJ27dqFxsZGLFy4ELt27cLXX3+N9evXaz1GIgDApAF56NHuJxQdrcarmw5g5rk9fZ67Vekf1XJ9lKxLm1T88Fu55hmpUIrN5Q/QSmakDMnqJwsU6Q9qb0XVMmOv2vM+/cqMlHGoykidddZZ2LlzJxobGzFw4EB88cUXyMnJwaZNmzB06FCtx0gEwFEzJWel/rOh2O+btryFTCDTejI5I3VI80CKxeakjr/2B2kRzlbKf2/+phmNlpGy2QVqGuQaKffHhd3NjUNVRgoAevTogX/9619ajoWoRZMHdcDTq/fhQJkVb2w+iOnndPc4x1rfiMLfygGoC6QOhCkjlRnK1B4DKUOy+miCCbhkPCK1as9H5gVwXaFmrNepHEQBnsEu99szDlUZqU8//RSff/65x/HPP/8cn332WciDIvIlwWzCzNGOrNQLX/2M2gbPN6mdh06i0S6Ql5WMTq1TAr7ucPWSqqwLvdicU3vGVFXnfUWY41hkMx7OWiAv04wGzb7Ij4lJgtI3SmbUx8SIVAVS99xzD2w2zw8wIQTuueeekAdF5M/Fp3ZEx1YpOFZVh+VbD3lcvrXYUWg+rGt2UKtI5UDq1+M1sNu12x8rlGLzSE/fUGyRMzzpMTCdZvVbI2XM7IvrYoDm7zXsI2UcqgKpffv2oaCgwON43759sX///pAHReRPotmEGaN7AACeX1+Eukb3Nyq50DyQRpyu8rKSkWCSUG+z40hlrTaDRWjF5nLwxfYHxlTlY0UY4NIEs74x7BvjCiGcDTm9BHXyMaPV8vkLLpWMlMEeEyNSFUhlZWXh559/9ji+f/9+pKWlhTwoopZcOrQT2mcmoaS8Fu9u/0053mizY8dBR0ZqeIAbG8sSzCZ0bJoKPKBhC4SQis0NWsRLDoG0PxACqG0I78a4NQ02yLGa33otg2Vfqv31+TLoY2JEqgKpKVOm4Pbbb3frYr5//37ceeeduPDCCzUbHJEvyYlm3HiOIyv13Lr9aLA5Pkh2lVTAWm9DZnICeudkBH294aiTqtBgaq/eZvfIvJH+KRkPLx/UKS4b44Z76lcO5CUJSE5gjZTMb0aKfaQMQ1Ug9fjjjyMtLQ19+/ZFt27d0K1bN/Tr1w9t2rTBk08+qfUYiby6akQXtE234NcTNfjgW0dWaovLtjAmU/Bd9rVugVDXaEN9oyPIC6XYHGBWyoj8tT8wmSSlf1O4P6yV1geJZq9/V0ZdoVblpwCfGSnjUNX+ICsrC19//TVWrVqF7777DikpKRg0aBDOOeccrcdH5FOKxYzpZ3fH/M/24Ll1RfjjqZ2wrWmj4mDaHrjSOiPlutrO25RIS8wmCSmJZtQ02FBV2xhwl3bSB3977QGOLuPV9bawB9ny9Xvrag4YOSPluz2FUR+T5mx2gS3Fx1FaWYucjGSM6JYNs4ovubFMdR8pSZJw3nnn4bzzztNyPERBueb0fDy/vgjFx6qxYNVebNh/FABwapdWqq5P6SWlUY2UHEilJyWofvNIT05ATYNNaaNAxuEv4wE4OoofRfj7Nyn7yfkah0FXqPkLMI2apXO1srAE81bsQkm5c/FOXlYy5k4uwMQBeVEcmbZUB1Jr1qzBmjVrUFpaCrvdvdDxpZdeCnlgRIFIS0rA2b3a4qPvSrD4S2fN3m3LvsWDF/YP+o+1s8ZTe6EUmsvSkxJwtLKOU3sG02CzK9PCvjJSkdq42N8Uo+txo9UD+QswjZ6RWllYghmv70Dz9aSHy2sx4/UdWHLNqboJplTVSM2bNw/nnXce1qxZg2PHjuHEiRNu/xFFysrCEqz4rsTj+JGKOsx4fQdWFnpe5k+XNo5Aqqy6XpMPp1B6SMnSlQ9LZqSMxDWT4a39ARC5Ohx/RdWO446goa7RjkZbeFcQxhJ5/0Hv7SmMmaUDHNN581bs8giiACjH5q3YBZuG/fqiSdW7+/PPP4+XX34Zf/7zn7UeD1HAWvpjleD4Yx1fkBvwtFpmciJapybihLUBB8usKOiQGdIYnRmp4AvNZWlKjx7jvSEbWVVTJsNiNsGS4P07b6RWhvlb5g+4BxLWBhsyzaq+o8edamULHz8ZKYNl6QDHoh/X6bzmBICS8lpsKT6OkT3aRG5gYaLq1V5fX48zzjhD67EQBSWYP9ZgaFlwHkrrA1l6kiMIY1NOY7Eq02negxfHZZGZUmspI2VJMCHRLEVkLLHEb41U02NltCwdAJQG2NA40PNinapA6vrrr8ebb76p9ViIghKuP9YubRxNZbWokwqlq7lMDsKM9AFF/ruay5T2B2GePlK6mvsoNndcZrzmsX5rpFwCYKuXPUH1LCcjWdPzYp2qr8m1tbV48cUXsXr1agwaNAiJie4fEgsWLNBkcET+hOuPtUu2o7u5FhkpLYrN5YxEJQMpQ2mp9QHgDF7CvWrPX4d1WZrFjPKahrCPJZb4q5GymE1IMElotAtY62zIDOHLVLwZ0S0beVnJOFxe67X0QgKQm+VohaAHqt7dv//+ewwZMgQAUFhY6HZZMJvEEoUiXH+sSgsETTNSoU/tMSNlLFUt1CUBkdtCSL5+f9OMqQbczqjaz/SrJElItZhRUdtouJV7ZpOEuZMLMOP1HR6XyRHC3MkFuuknperd/csvv9R6HERBc/1jlQC3YCqUP1YtWyDIGalQvo3KhayskTIWZyGzn4xUhIrNlc7mAUwzGiojFUBbiIraRkP2kpo4IA9LrjkVty7bqbTxABxfbvXWR8oYSytIt+Q/1tws9+m73Kxk1X1K8ptqpH49YQ15ea6m7Q8M9AFFrtNGforNI9T+oFopNg+gRspAy/2tfqb2HMeN3Utq4oA8FOQ59jyVALw1/TRsuHuMroIoIISGnNu2bcN///tfHDx4EPX19W6XvffeeyEPjChQEwfkYXxBrmbbEORmJiPRLKHBJnC4ohYdW6WoHpsWgZTSdJEZKUMJpC5J/qAOd0POgGqklE7exnmdKsXmPqY8nb2kjPOYNCe/BwoAAzu10s10nitVGally5bhjDPOwO7du/H++++joaEBP/74I9auXYusrCytx0jUIrNJwsgebTBlSEeM7NEmpD9Ws0lCp9byVjHVIY1LKTZPCn3VXrg/LCm2WAOY2kuP0Ae1VamR8hdIRWYFYSxRasdaykgZcGpPVuHyBbCiRp9NhVUFUo888gieeuoprFixAhaLBQsXLsSePXtw+eWXo0uXLlqPkSjitKqT0jIjxWJzY5EbsPqrS4pUgXcw7Q+MkpGy2QVqGvwHmGkRWlUZy1yDp4paBlKKoqIinH/++QAAi8WC6upqSJKEO+64Ay+++KKmAySKhnyNmnJWaNBHSs46VHJqz1D8dc2WRarAW2nI2UL7A8A4tXyuj7mvANOIKxld1TXaUOdSaF5Ro8/XhqpAqnXr1qisrAQAdOzYUWmBcPLkSVit2mz2ShRNzu7mNSFdj1abFgPGLVg1qupAVsop+zCGu/1BABkppUbKGEGDHFyaTRKSfGzhY8SVjK6af/nT69Seqnf3c845B6tWrcLAgQNx2WWX4bbbbsPatWuxatUqjB07VusxEkWcPLV3MIQaqfpGu/JtLKT2B8nOYnMhBHu1GUQg7Q8iNXUU2FiMtULNNbj09TdpxJWMrpoHTnqd2lMVSC1atAi1tY5tN/7+978jMTERX3/9NS655BLcd999mg6QKBq02G+v0uVNI12DjFSjXaCu0Y7kRN9ZAdKP6gCm0+Q+UtZ6G+x2AVMYVkTZ7ULZ4iSQei2jZKRaKjQHnAX4Rqkba66CGSnfsrOdnaJNJhPuuecezQZEFAu6tHEEUiesDaiobVCVUZLT2mkWc0irCF3fqKvqGhlIGUR1EJ3NAcd+bv4yRmrVNtogmtqp+d1A2WgZqRZaHwDMSHlmpPT52gj4r66iogKZmZnKv/2RzyOKV+lJCWiTZkFZdT0OHbeif4fg23posWExAJhMEtIsZlTX21Bd14i26UkhXR/Fh0D22ktKMMEkAXbhyHqEI5CSMy+SBKT4CeJTI9QcNFY4e0gFkJEySHDZXPOpPMNnpFq3bo2SkhLk5OSgVatWXueE5foNm80Yf0ikb52zU1FWXY+DZWoDqdALzWVpSQmorrdx5Z6BVAVQ4C1JEtIsCaisawxb1kNpxmlJ8Fuflxah7WpiRXVdy53nlYyUQaY7m2u+Ss/wNVJr165VpvS41x4ZQX6bVOw8dFJ1nVSFBj2kZOnJCSitrGNTTgMJpMAbcATZlXWNYQtgAukhJY8DMGBGivsP+uSZkdLn4xDwO/yoUaO8/ptIr0ItOHdmpEKb2gNcWiAwkDIEu120uI+bLNwbFwfSQwowXvPJqgC6vRu9j5T8HpidZsHx6npmpL7//vuAr3TQoEGqBkMUSzqHHEhpmJFS+gUZ40PK6ORVckAAGakw1yYF0kPK9XKjvEatdS0Xmxs+I9WUgerUOoWBFAAMGTIEkiRByMs3fGCNFOlF6BkpbYrNAdfGi8Z8QzYa+UPaJAHJif77Jssf5OF6bSgZqRYyY/JrtLbBDptd6HJzWlfVAWQMDb9qrylw6tQ6Bd//Ws6pveLi4nCOgyjm5De1QPjtRA0abXYkmIPbCEBOa2dqkJHKkAMpFpsbQlWABd7yOUD4sh5VAWReAPeMlbW+UZMvELHMWSPlJyNl9D5SNXIg5XgvrTR6Rio/Pz+c4yCKOe0zkmExm1Bvs6OkvFaZ6guUplN7yayRMpLqAOpvZOGuw7Eq/az8jyUpwQSzSYKtqb5L74GUsmrPX42UHOQ2hK9haiyTF9x0bJWi/KzH3RlU7bUHAHv37sWsWbMwduxYjB07FrNmzcLevXu1HBtRVJlMEjplO94ADqmY3qus067YXP5ArWQgZQjKSrkWskCASyPMsK3ak6f2/I9FkiQlK2WEgF9pCxFAHykhHI1NjcaZkXK8j9pcFlHoiapA6t1338WAAQOwfft2DB48GIMHD8aOHTswYMAAvPvuu1qPkShq5DqpA2oCqTAUmxvhA4oCb30AOD/Iw1WHYw1g82RlLAZqylkdwNRecoIZcvLFiCv35PfAnIxkJJodD4QeC85VvcPfdddduPfee/HQQw+5HZ87dy7uuusuXHLJJZoMjija8kMoOK/QsNicq/aMpTrAAm/HOeFdGeacZmw5OxbuVgyxJJD2FCaThNREx64EjufHWLsSyEFTVkoiMpMTUVZdj4qaRuQF3984pqnKSJWUlODaa6/1OH7NNdegpKQk5EERxYpQWiBo2dlcDqTY2dwYqgMs8AbCXyMVyBSWLN1ATTkDfY6M2kuqwWZXXgeZKQnITHF8odRjRkpVIDV69Gj873//8zi+YcMGnH322SEPiihWyFN7qmqkNJzaS+PUnqEEE7yE+7URaPsDwLlyzwgbF1cHsNceYNxeUq5f+tKTEpTVy3rcb0/VO/yFF16Iu+++G9u3b8fpp58OANi8eTPefvttzJs3Dx999JHbuUTxKr9NGgDgQJn6jFSmBlN7cjDGqT1jcO7jFvjUXriCl0C3iHGMxTgBv7UusADTqL2k5IApzWJGgtmk64yUqkDq5ptvBgA899xzeO6557xeBrA5J8W/zk2r9sprGlBubUBWamBBUYPNjtoGOwCtM1L8ezICOXhJD2RqL8wF3tYYasUQSwLfg9CYvaTkgEkOoOQvlHpsyqlqas9utwf0H4MoineplgS0TXcUiB46EXhWqnlaO1TOGin9fZsjT2rqksKVBaoKZprRINNYNrtQvii19LgYNSMlvwfKAVRmin6n9lT3kSIyii5NWalgpvfkgCe1Ka0dKjmrVV1va3GbJop/1S6dzVuirJQLU/ASSAdvZSwGCRpcA8WAM1I6Dy6bkwMmOYBSMlI6/DKo+qvy1q1b8eWXX6K0tBR2u93tsgULFoQ8MKJYkd8mDTsOngxq5Z6WheaA81uv/E04JYAPNYpfSvuDgLJATVN74Vq1F8Ayf2UsBpnGkqcuE0wSkhL8f1FSgksDTHe6qmhWI6rUSOlwak/Vu/wjjzyC++67D3369EH79u3d2r3rrfU7kZoWCBW12nU1B4DUREdjPyEcUy0MpPQtmPYHYd+0OJhWDAbJSLnWR7W8F6JRM1JNU3tKjVTT1B4zUg4LFy7ESy+9hGnTpmk8HKLYI29vsOPACWwqKsOIbtkt7myvdUbKZJKQZklAVV0jquoa0S7DWI39jCa4hpyOc+oa7ao21/bHbhewNqjISOk8aGABfssqmvXR0/OqPVV/cSaTCWeeeabWYyGKOSsLS/DYZ3sAAHuPVOKqf23GWY+txcpC/41nKzXsai5TupuzKafuVSsbBQfeTRyAEvRopabBBrkkL6DtagwyjRVcSwhjBJfNKTVSyVy159Udd9yBxYsXaz0WopiysrAEM17fgbLqerfjh8trMeP1HX6DKS27msvCPYVDsSOYvfYsZhMSmjKkWq/ckwMGSQKSE1v+uDBKRiqY58co053NyVtkKcXmKZzaczNnzhycf/756NGjBwoKCpCY6P6t+7333tNkcETRYrMLzFuxC97WxwkAEoB5K3ZhfEGu12k+59Jf7QKp9KZvdAyk9C+Y9geSJCEtKQHlNQ2aZ4Jcm04GUv9qlMJqFuC3rHlDYmdGSn+BlKqM1K233oovv/wSvXv3Rps2bZCVleX2H1G821J8HCXltT4vFwBKymuxpfi418srNS42B5zNGY3QNdrIhBBB1Ug5zgtPJiiYKSzAGTTofYsYdQX4+n5MmvMoNldqpBp118JF1dflV155Be+++y7OP/98rcdDFBNKK30HUYGcp9RIadCMU6Y05WQgpWt1jXbY7I4PmkA+qAFnQbPW2Uo5sxRoU1lmpDw5pzv1/Zg059H+oOn/NruAtd4WULY1XqjKSGVnZ6NHjx5aj4UoZuRkJId0ntar9gAgPcnxRsSMlL65Pr+BfFADzilArXtJKRmpAAM6paeVzrMvqjJSBvu7lafw5PfA5EQTEs2O6WG91UmpCqQefPBBzJ07F1Zr8Bu5EsWDEd2ykZeVDH9VIWkWM4bmt/Z6mdZ9pADn1B5X7embnM1JSTS32GZDFq6Ni61BbJ4MOAMua70Ndru+pm9cVSnd3oNomGq4jJT71J4kScr7od5W7qn6uvzMM8+gqKgI7du3R9euXT2KzXfs2KHJ4IiixWySMHdyAWa8vgMS4LXovLrehplv7sDCK4d4fNCEJSOVHJ7pG4otcjAUzNRHuDYurg5iexjHec4x1zToa/rGlRJgBtRHyni1jTa7UN6nXBfcZCYn4Hh1ve4yUqpe5RdddJHGwyCKPRMH5GHJNadi3opdboXneVnJ+MPAPLy2+QBW7TqCK17YjP9MHYacTOc0XziKzdPCVAdDsSWYruaycC1EsCr9rAL7qEhONCkd+KvrG3UbSAUTYLpmpIQQhtj9wzVr7voe6NwmhoEU5s6dq/U44obVakW/fv1w2WWX4cknn4z2cCjMJg7Iw/iCXGwpPo7SylrkZCQrnc3/MDAX01/djh9+K8dFizfipeuGo29uJmx2gbIqR++p4mNVAXVCD0QGG3IaQrAr9oDwdc+Wx5Ie4FgkydmB31pnAzI0HU7MCCYjJW/n1GgXqLfZkZSg/+2d5IxTSqIZFpe9CPW6cXFIXxe2b9+O3bt3AwD69++PU045RZNBxbJ//vOfOP3006M9DIogs0nCyB5tPI4Pzc/G+zefgeuWbsXPx6px6ZJNuO7Mrnhn+6842fSN6//eL8Sza/dj7uQCTByQF9I45G/3RltGbTRqMlJha38QRId1ZSxJZlTVNer6dSrft/SAis1dOs/X2QwRSJXLXc1T3EMMpSmnzmqkVBWbl5aWYsyYMRg+fDhuvfVW3HrrrRg6dCjGjh2Lo0ePaj3GmLFv3z7s2bMHkyZNivZQKEbkt0nDezefgRHdslFV14hn1+736D8VSCf0QCjtD5iR0rVgmnHKwjXta1WRHTNCcbUSYAbwuCSaTUpWRs/BpavmrQ9kem3KqSqQuuWWW1BZWYkff/wRx48fx/Hjx1FYWIiKigrceuutQV3X/PnzMXz4cGRkZCAnJwcXXXQR9u7dq2ZYPn311VeYPHkyOnToAEmS8MEHH3g9b/HixejatSuSk5Nx2mmnYcuWLW6Xz5kzB/Pnz9d0bBT/WqVa8PJ1w5HiYwsNuVB93opdSn8gNdKV6RtjvBkblRJIxUDwoiYjlWqArYyCDTCdGUP9Bpeu5IxT88U2et24WFUgtXLlSjz33HPo16+fcqygoACLFy/GZ599FtR1rV+/HjNnzsTmzZuxatUqNDQ04LzzzkN1dbXX8zdu3IiGBs8nYdeuXThy5IjX36mursbgwYP97g+4fPlyzJ49G3PnzsWOHTswePBgTJgwAaWlpQCADz/8EL1790bv3r2Dun9kDN8dKkdNg93n5S11Qg8EV+0Zg1IjpSJ4Cddee0HVa8lBnY6bcgbbX8tovaSUjFRK84yUPqf2VNVI2e12j5YHAJCYmAi73feHiTcrV650+/nll19GTk4Otm/fjnPOOcfjdmfOnIlevXph2bJlMJsdL+K9e/dizJgxmD17Nu666y6P25g0aVKL03ELFizA9OnTcd111wEAnn/+eXzyySd46aWXcM8992Dz5s1YtmwZ3n77bVRVVaGhoQGZmZl44IEHgrq/pE+hdkIPBFftGYOaqb30MNXPycXrQU0zhqmnVSxx3YMwEEbrbu7ca7RZIMWMlNOYMWNw22234ffff1eO/fbbb7jjjjswduzYkAZUXl4OwNE9vTmTyYRPP/0U3377La699lrY7XYUFRVhzJgxuOiii7wGUYGor6/H9u3bMW7cOLfbGjduHDZt2gTAMQV56NAh/PLLL3jyyScxffp0n0HU4sWLUVBQgOHDh6saD8WfUDuhByLDZWpPb3tVkZOaqb1wbc1iDbKPFOBcyabnTXqrglwQYLiMlK9ic52u2lMVSC1atAgVFRXo2rUrevTogR49eqBbt26oqKjAs88+q3owdrsdt99+O84880wMGDDA6zkdOnTA2rVrsWHDBlx99dUYM2YMxo0bhyVLlqi+3WPHjsFms6F9+/Zux9u3b4/Dhw8HfX0zZ87Erl27sHXrVtVjovjSUid0CY7+UyO6eX5BCJQ8tWcXjmaHpE/Oqb3gs0Dar9oLfJl/87FU6zT70mizo67RMfPCjJR3PovNdbpqT9XUXufOnbFjxw6sXr0ae/bsAQD069fPLaOjxsyZM1FYWIgNGzb4Pa9Lly547bXXMGrUKHTv3h3/+c9/ItrkbNq0aRG7LYoP/jqhy6/MuZMLQuonlZJohklyBFJVtY0Bb9tB8UVN+4Nw9ZFSlZHS+X57VpcvMUHXSOn0MWlODpQ8a6SYkcLatWtRUFCAiooKSJKE8ePH45ZbbsEtt9yC4cOHo3///vjf//6naiCzZs3Cxx9/jC+//BKdOnXye+6RI0dwww03YPLkybBarbjjjjtU3aasbdu2MJvNHsXqR44cQW5ubkjXTcYhd0LPzXKfvsvNSsaSa04NuY+UJEmskzKAKhVTe0pnc40/qKvU1Egphe/6zL7I9VEJJgkWc2AfoUrGUKePSXPOvUZ9rNrTWfuDoL7SPv3005g+fToyMzM9LsvKysKNN96IBQsW4Oyzzw74OoUQuOWWW/D+++9j3bp16Natm9/zjx07hrFjx6Jfv354++238dNPP2H06NFISkpS3WncYrFg6NChWLNmjbL9jd1ux5o1azBr1ixV10nG5K8TuhbSkxJQWdvIQErHrCqm9sK1Us6qYtWePG69ZqRc90IMdCZEqRszytReTQt9pGobdbVdTlCB1HfffYfHHnvM5+XnnXde0MHMzJkz8eabb+LDDz9ERkaGUpOUlZWFlJQUt3PtdjsmTZqE/Px8LF++HAkJCSgoKMCqVaswZswYdOzY0Wt2qqqqCvv371d+Li4uxs6dO5GdnY0uXboAAGbPno2pU6di2LBhGDFiBJ5++mlUV1crq/iIAuWrE7oW0rlNjO6p62zueF3U2+yob7S7bcuhlt0ulA/+oDqbK9NY+gwanIsBot95PlZV1PqY2muqkbLZBWoabLopTwjqXhw5csRr2wPlyhISgu5sLheJjx492u340qVLPWqRTCYTHnnkEZx99tmwWCzK8cGDB2P16tVo166d19vYtm0bzj33XOXn2bNnAwCmTp2Kl19+GQBwxRVX4OjRo3jggQdw+PBhDBkyBCtXrvQoQCeKJk7t6Z9rxiNQroGOtb4RlgSLn7MD47qgIbgVhOHpaRUr1BTgG61GqlIpNnd/jFISzUgwSWi0C1TU6KfOM6h70bFjRxQWFqJnz55eL//++++RlxdcHUiwy7jHjx/v9bi/ff5Gjx4d0O3MmjWLU3kU0zLYlFP3qoPsUQQ4tyGpb7Sjut6GVqkajKPpQ98kAck+uvZ7o0zt6bQeSE0BvrJqT6ePSXPO9gfuiRdJkpCZkojj1fWoqG3wqCeNV0Hlf//whz/g/vvvR22tZ1PBmpoazJ07FxdccIFmgyMid2kG60djRGqm9gDXgmZtXhuuAV0wtSypOm/IKU9ZBpNNMVJGym4XqKzz3pDTcUxugaCfgvOgMlL33Xcf3nvvPfTu3RuzZs1Cnz59AAB79uzB4sWLYbPZ8Pe//z0sAyUiZy+pSgZSuqSmR5EsLSkBJ6wNmmUr1eyzJ48D0G9htbpNpY3TR6qqvhHyBFDzVXuAPrubB/WX2r59e3z99deYMWMG7r33XmW6TJIkTJgwAYsXL2ZNEVEYceNifXNtGRDMBzWg/cbFwW7MK9N/jZSKPl8GyiTLmSZLggnJiZ6PkbJyT0dNOYOu9MrPz8enn36KEydOYP/+/RBCoFevXmjdunU4xkdELrhqT9/kqR9LU81TMLTeuDjYjXllWgd0scaqYmpP74+JK6UZp5dpPcClu7lRM1KuWrduzb3kiCIsXSk21/8bshGpnU4DtN+4WM2ef4BLQFevr15BsmpV+w/qu27MlbJiL8X768aZkdJPIBV6sxEiihhn+wP9vAmRU7XK6TTAdUpNo6k9FV3NAWdAJwRQ22DXZCyxRM3jkhamhqmxSOkh5TMjleh2nh4wkCKKIxnsI6VralfsAa7TRxpP7QWReQGA5AQz5CSUHjMw6mqkjJOR8tX6QKbHVXsMpIjiSEpT8eah4zXYVFQGmz24PmwU26pUrAiTObOV0S02N5kkpCbqt+DcGWAGv21ObYNd93+zvvbZk+lx1R4DKaI4sbKwBPe+/wMA4OBxK67612ac9dharCwsifLISCtyNildRSCVmqR1Hyn19VqpyupS/U1lOfdCDD4j5fh9/QWXrlosNtfhqj0GUkRxYGVhCWa8vgPHq+vdjh8ur8WM13cwmNIJOZsU7HQaoP0ed3IgpSao0/PeckqAGURGKinBpGxcrveVexUtFZvrcNUeAymiGGezC8xbsQveJgTkY/NW7NL9lIERWEOY2tO6f5OaDt7Oseh342I5yxZMgClJku77a8mc++y1lJFiIEVEEbKl+DhKyj23ZZIJACXltdhSfDxyg6KwUNtyAHB+sGuVBVL2lFNT+K7xNGMsUVuEb5ReUsrUnq9ic67aI6JIK630HUSpOY9il9L+QFWNlLZ1SdV1zEh5Y1X5HGndMDVWKVN7vorNXTJS8u4o8Y6BFFGMy8kIbIf0QM+j2OWsS1JTI6XtEntndiyEjJSua6SYkfKmoqWpvaYaqUa7QE2DPh4LBlJEMW5Et2zkZSXDX3/odhlJGNEtO2JjovCoUlHILEvTeB/GkLJjFn2u2nPdVDrYInyj9JJyTu15f3xSEs1K4b1eVu4xkCKKcWaThLmTCwDAZzBVXdeInYdORG5QFBZytkLdSjmtNy1WXyOldb1WrHCdqgw22JUDUr13N28pIyVJkrMpp05W7jGQIooDEwfkYck1pyI3y336rn1mErq2SYW13oar//UNPv/xcJRGSFqoCql3k8ar9kKqkXKMRW8d+OXAMNEsBb+ptAEyUkIIVNb6LzZ3vUwvK/dUb1pMRJE1cUAexhfkYkvxcZRW1iInIxkjumWjvtGOW97agdW7SzHj9e2Yd2F//Hlk12gPl1RwZoHUr9qrrrdpslmwMpYQphn1ln0JJbg0Qo2Utd6mtGHxlZFyvUwvGSkGUkRxxGySMLJHG7djKRYznr9mKO7/sBBvbTmE+z/8ESXltfjbhD6wC3gEXnJ9AsUe+YM6lE2LbXaBukY7khODz2rJ7HahqoN387HoLfviDC6jnzGMRXJglGiWkJzoO2OnNOXUSY0UAykiHUgwm/DIxQORl5WCBat+wnPrirD9wAkcKLPicIWzLUJeVjLmTi7AxAF5URwt+RLKpsWuWRJrvS2kQMrqsppK1b5/Os2+KIEuHxOvXLeH8ZcR1VtGijVSRDohSRJuHdsLj18yCCYJ+Kb4uFsQBXBLmVgXyrYsZpOkbGodatZDbqRpkhzbmwRLr9kX5/6D6vdC1Ntj4qqlDYtleutuzkCKSGcuGdoJWT4KPbmlTOyy20VI27IAzkxWqFNqSusDS4KqWiu9Zl+qQ5ja0+tj4koOjPwVmjsul1ft6SOoZCBFpDNbio/jhNX3Nz1uKRObXJsTqslIAdr1b6oOYfWgYxx6rZEKfSWj3h4TVy21PpAxI0VEMY1bysSnapfpNH+Fuv5otTFudQibJ7v+nv5W7YXQeV6nj4krZ+uDFqb2UlgjRUQxjFvKxKdQp9MA7RphWuvVrx4EXLqs6yz7orQ/UNXt3QAZqZoAM1I6W7XHQIpIZwLZUibVYsYpXVpFakgUgFCzQIB2GxfLH/bB7icnS3PJjOllY1ogtPYHSkZKzzVSATTjBLhqj4hiXCBbyljrbZj+6jaU66RGQQ9C6Wou02rjYmsIy/wBZ0BnF1D2ptMDZ4AZQkZKz6v2mt5PMlp43eitszkDKSId8rWlTF5WMmaM6oFUixn/23cMlyz5GgfLrAAcjRw3FZXhw52/YVNRGVf1RZic7VBbaA64blwcWtajKsTsWIpLDys9BQ7OAJOr9rxRis0Dzkjp47XBhpxEOuVrSxmzScL5g/Jw/SvbsL+0Chc9txF/ObMr3vjmIErK2bwzWqqU7UdCz0iFXiOlfgoLcPa0qmmwwVpvQ5uWfyUuVIewhU+qS2sKLbbwiUVKQ84Wi83lGqkGXTwWzEgR6Zi8pcyUIR0xskcbZXuYAR2z8OGsMzGwYxaOV9fjyS9+cguiADbvjDRrCM04ZfKUWqibBYfazwrQrqdVLAllCx/5d4QAahv0M93pqjLI9geNduHW9iNeMZAiMqj2mcl4c/ppPjtXs3lnZCk1UiEEL+kaLbG3hrBVjUyrnlaxJJQifLfpTh0Fl64CLTZPtZiVL3V6WLnHQIrIwAp/q/BbDMzmnZHj3CQ4hIyURsXmWmSkUjWaZowloRThm0yS8zHRUXDpKtD2B5IkIbNpG5lKHazcYyBFZGBs3hk7Qmn2KNOqoFmTsWhU+B5LQqmRAlyydDoKLmVCiID32gP01ZSTgRSRgbF5Z+zQYmovLaZqpLRpDhpLlF5favtrJekvSyerbbCjweYoAWhpag9w3SYm/h8LBlJEBhZI885WKYkY0S07YmMyKjmLFFqxuUar9jSokXL2tNJTRkp9Z3NAn3VjMjmzZJICCzSdGxczI0VEcSyQ5p0naxrwxOd7WXAeZto05NSm2FybGik5aIj/jAMANNjsqG+qJ1SdkdJh3ZhMqY9KSQyonYGeNi5mIEVkcP6ad04c0B4A8Pz6Itzw6jZdFIbGKm0acjo+qEOe2tMiIyVnx3QSSLnWnakNMLXawicWKSv2Wig0l+mpKScbchKR3+adH+78DXe98z3W7CnFH5/7Gv+ZOhxd2qTCZhdezyd1qkLoUSTTqtjcGmJRNeBaWK2PoEF+TCxmEyw+Woa0RNcZKaWreWCvGdemnPGOgRQRAXA272xuypCO6NomDTe8tg37Sqtw4eINmHZGVyzfeoid0DVUrcHUnlbds0NpPCnTW9CgyfOjs+DSlXOfvWAzUvEfSHFqj4haNLhzK3w06ywM7pSFk9YGPL16Hzuha0yLzuau3bPVdoy2uXSbDmW7Gr1NY2kSXOpsutOVsxlnoBkprtojIoNxdEI/HcmJ7IQeDlq0P0hJNENOQqkNYFwDsFCm9nSXkQqhq7nMCBmpgGukuGqPiIzo+1/L/e4Txk7o6gghNGl/YDJJSE0MLYCRp7DMJsnn9kGB0FtGKpSu5jK9BZeunDVSQU7t6aBGioEUEQWMndDDo67RjsamLF4oNTiO3w+tKadSC2Qxq66xAvQXNDi7mnO605vKYFftpehn1R4DKSIKGDuhh4frKrtQanAAl42LVU4fKXv+hTgOZYsYnUxjycFPSN3edRZcunL2kQqwRooZKSIyokA6oVvMEvLbpEZsTHogZ4FSEs0ht5BQNi4ONSMVYmYsTWcNOZWWECzA90rOLGWoqJESIr5rKhlIEVHAAumEXm8TmPzsBvxv39HIDSzOVWnQAFOWFuI2JFplpJRWDDoJpJSMFGukvHIWmwf2+MgBV4NN+K27jAcMpIgoKP46oc+7sD/65WWirLoe1760BQu+cGwtY7MLbCoqw4c7f8OmojKu6mtGiwaYsjSXXlJqaBXUuTYHjfeMA6BN53ldr9oLstg8zWKGnHyN95V7bMhJREHz1wn9iuGd8dDHu/DmNwfxzNr9WPnjYZy0NqC0sk75fTbvdFelQf2NTM6YqO1V5JzC0iYj1WgXqLfZkZQQerYtmqrqQm9/oOs+UjXBFZtLkoTMlESctDagoqYB7TPjt66SGSkiUkXuhD5lSEeM7NFGqe1JTjTjkYsHYuGVQ5CUYMJPR6rcgiiAzTubczbj1GJqT85Iqct6aDGFBUBpwwCEvolyLNBiylPPGanKILeIAfTT3ZyBFBGFxQWDOvisl2DzTnfO6TQtpvZCK/LWoqgaABLMJqUPldppxliiRRG+kpHSwePhqrbBhrpGR51ToFN7jnPl/fbi+/FgIEVEYbGl+DiOVtX7vJzNO53kD+lQp9Ncr0Nt+4MqDRpPKmMJsRVDLNGiYaqckWqwCdQ3xneBtSu5h5QkAelBvIaZkSIi8oPNOwMnT/VosWov1NVyWmWkgNBbMcQS5xYxoQRSLtOdOspKyYFQelICTEG079BLLykGUkQUFoE25UwOYRsSvajWYJ89WbrSCFNtHyltaqRcx6KHjJQza6g+wEw0m2Axy9Od8f+YyILdZ0/m7CUV30El38GIKCwCad4JAP/3fiHW7jkSkTHFKi2mjWSpIfeR0j4jpXa7mliiWRG+DlfuyYFQMPVRADNSRER++WveKf/cISsZZdX1+MvL2/D3939QPsSN1ndK02LzEJs+ypkSLbJjzhqp+A8atAow03S4ci/YZpwy53578R1IsY8UEYWN3Lxz3opdKCl31kLlNvWRGt0nB09+vhf/3lCMN745iK+LynDZ0E54bfMBt/P13nfKqsGGuDLnpsVq2x9oF9Q5a6TiP2hw1rGFmJGy6C8jVak6I6WPVXsMpIgorPw17wSA+y4owJi+Objz7e9QfKwaj3++1+M65L5TS645VZfBlLJSTpMaqRAzUmHYribeM1INNruyyi70RqU6zEjVqq2R0kdGilN7RBR2vpp3ys7o2Raf3HI2khO9vyXpve+UlsFL6DVSWnZZ10dGyrWhaErIU3v66yUlT+1lBDu1xxopIiLt7D1S6XfzUj33ndJyOs25aXGI7Q+YkVLIKyAtZhMsIa4yDTXQjUXB7rMnc2ak4vv1wUCKiGKCkftOadGjSCYHQDUNNlXZuyoNm4PqZUsUTYNLHXY3d+6zF2yxuVwjxYwUEVHIAu071To1uG+98UCeOtKi/YFrVqumIbgAxmYXSlZQm87m+iisrtZyU2lmpBSunc2FiN8pewZSRBQTAu07NW/FLmw/4Jze00OrhCoNa6SSEkyQS9CCnd5zzZKkatJHSh8ZKW0L8PWXkVJW7aksNm+wCb/T+rGOq/aIKCbIfadmvL4DEpwF5gCUnzOSE1B0tBqXPr8JU0d2xZDOrfDYyj1x3Sqh0WZXNnzVYjpNkiSkJSWgsrZRRSDlCHjMJknZcDgUaSFuVxMrtOytlRpi5/lYpPSRSgnu8UmzmGGSALtwZKVCLeSPFmakiChmyH2ncrPcp/lys5Lx/DWn4n93nYtLh3aCEMDLX/+C25fvdAuiAGerhJWFJZEcumqu2RotptMA9RsXO7eqMUOSAt8zraVxxHtGStsCfHm6M74fE1dq2x9IkuQsOI/jOilmpIgoprTUd+rJywbjgoF5+MsrW+FtFk/AkcGat2IXxhfkerRaiDVy8JJolkJeESZTu3FxtYa1Wq7j0EuNlCYF+LrMSKmb2pN/56S1Ia57STGQIqKYI/ed8iUp0ew1iJK5tkrwdz2xwJnt0O7tWO3Gxc7Vg9pMsajNjMUabdtTyDVS8f2YyOob7cqihmCn9lx/J55bIHBqj4jijp5aJWjZ1VymdmsWrYM6pUYqzrMvWgaYqToJLmWVLpkkNZlMPTTlZCBFRHEn0FYJGSqmGiLNquGKMJnaRpjOZf7ajEUJGuK8Hsiq0T57juvQRwG+TF6xl56UgARz8CGFswVC/D4eDKSIKO4E2irh3ne/x8ff/+7WoybW2iVUaThtJFO7cbGSkdIoOyZfT73LXnXxqDoMTUr1kpFyFpqre2z00JSTNVJEFHcCaZXQNt2CI5V1mPXmt1jW8xAevLA/9pdWYt6KXTHVLqFa4+AFcNm4OMishzLNqFFQ57qcvabeplkxfaQ5M1LsbN6cXGiuNvvr2pQzXsXnq5qIDK+lVgkb7h6D28f1giXBhA37j2HC0+tx0+s7Yq5dgrIiTMOpPbWNMLWeZrQkmGBpmu6J5zqpKqUthJZ7IeosI6Wi0Nzxe3KNVPy+PpiRIqK41VKrhNvH9cYfT+mEuR8V4su9R71eR7TbJWg5bSRLs6hsf6Bh40llLElm1FvtcV0TpGUfKbn+TN4LMdbbc7REacapOiMlr9pjRoqIKCrkVglThnTEyB5tPD6YurRJxQ3n9PB7Ha7tEiKtWsNCZlmayvYHzhqp6GfHYomWe+2FshdiLFK7z55MDw05GUgRke7FcrsELXsUyeRi82BXy4Wj8F0PGxdrmZFy3Qsxnh8TmbMZp8qpPa7aIyKKfYG2S2iTZgnzSDyFIwukTO0Fm5GSMy9aBnU6ykhptheiDh4TWaVGGalKZqSIiGJXoO0S5n70I9btLVV+jkSrBK1XyrleV/A1UmEI6nSwSq1aw4wUoH4Ln1gkZ5IyQm1/EMc1Uiw2JyLdC6RdQnpSAoqOVmPa0q04t087jOrTDi+s/znsrRKqw9qQM9g+UtoXm6fqYJWaVcMaKUB+fup00Usq1GLzjGTnqj0hhCabZUcaM1JEZAgttUvYeM8YXH9WNySYJHy59yge/GhXRFolhKdGyhGUVQW9aXE4grr4zkjVN9pRb3M0E9XqOUrVydY5gAbF5snOpq11cdq0lRkpIjKMltol3HdBAa4Y3hkXPLvB65t6OFolVIdx0+JgMx7hGEtqUnxnpGpcHkNunePJWWyuLpBKsyTAJAF24chuJSdqF8RHCgMpIjIUuV2CL8eq6v1+M3ZtleDvegJlDeumxeqKzcPR0ypeM1JVTeO2JJiQqGIvOW/ULgaIRaE25DSZJGQkJ6K8pgEVtQ3IyQxsYUgs4dQeEZGLSLdKqApjjVRdox2NtsCnS+QPdq0yL4AzuxXsNGOsULq9a9lbS2lPEZ+PiSt502K1GSnAGYSVx2l3cwZSREQuAm2V8PLGX7DncIXbMTWr/MLS2dxlai7QJfY2u0Btg7a1QID6wvdYEZZu70pGKj4fE1mjza4EyGpX7QHxv98ep/aIiFzIrRIOl9fCXxj07aGTmLTwf/jjKZ1wx/heKPytPOgNke12AWuD9u0PHNNQEhpsAtb6RmQFUAjsOs2kZUYq3pf6y1mj9DD01orX6U6Za5ZR7abFgEsgFae9pJiRIiJyIbdKAODRd0pq+u/BCwvwh4G5EAJ4d8evGP3EOlUbItc02CCaojUtp/aA4NsOyPVRCSYJSQnafTToJiOl5dSrElzG52MikwvNUxLNsITwmnH2korPwJKBFBFRM/5aJSy55lRMO6MbnvvTUHww80yc1q01Gn1M4clH563Y5XWaT84CmSTHh5GWgt242LU+SstePqlxXlgdjqlXvWSkQi00l8V7RopTe0REXrTUKgEAhnRuhdvH9cZV//rG5/X4W+XnuvWI1o0Ig9242BqGDuuu1xevS/3DUoCvkxqpUJtxypSNi1kjRUSkLy21SgCA0sq6gK7L2yo/+YNIMgGbiso8ArVQBLtxcTgCBtfri9eMlPz4aVojpZNVe/JUnNpmnLJMl+7m8YhTe0REIQh0ld/yrYdQ+Fu58vPKwhJc9/JWAI4PkKv+tRlnPbZWs67pwfYqqg5DUTXgkpGK0+yLEmCGoT1F3GekmjJIoazYA+J/vz1mpIiIQhDoKr+vi8pwwbMbcGbPNji1S2ssWrvf43y5OH3JNaeGvJ9fWpAdxcOxzN9xffG9ai8sNVI62MgZ0HBqL85rpJiRIiIKQSCr/P5vUl9MGdIBZpOEjfvL8KyXIApouTg9GMF2FLeGoTGoYxzqmoPGivD0kYrvujGZc2ov1IyUXCMVn4ElAykiohC1tMrvhlE9sPDKU7D+b6MxaUCu3+tyLU4PRWqQHcXDlZFS0xw0loQjwIz3ujGZdhkpx2ukMk4zUpzaIyLSQCCr/Dq1TsXEAbn4rPBwi9cX6hY08of197+WB1TIHq6MlJrmoLFEDv407fYe5ysZZc72B1y1R0REGghklV+gxemBnufNysISLNtyCACwdk8p1u4p9dtl3WYX+Km0EgBQbm2AzS40Wz0IOLJc5TUNcdmA0hrW9geNEEJo3voiUuRVdpq1P6iJz8eDU3tERBEkF6f7+qiQ4NhaZkS3bFXXv7KwBDNe3+Expeery/rKwhKc9dharPjOcfzTwsOarh4Egq/XiiVVLr2+tCJPu9qFo3YsXlVq1pDT8fv1NntcPh4MpIiIIqil4nQAmDu5QFVGyGYXmLdiV8CF7HLQFezWNsGOSb5jW4uPh1xEH2nylKeW7Q9cu9jH62pGwFkcHso+e4AjSJVf7vG4co+BFBFRhLVUnK629cGW4uMeQZEruZD9qVV78dkPJfi/9wvDunpQznb9ftIxpn98srvFbJfNLrCpqAwf7vwNm4rKoh54yf2vtOyvZTZJSjAVr/21ANdi89AeG5NJUoKxeKyTYo0UEVEUBFKcHqxAC9QXfVnU4jn+trYJhJztCqZX1srCEsxbscstGPRX2xUJzo7vWq9mNKOmwRbXK/e0KjZ3XIejjq48DrubMyNFRBQlcnH6lCEdMbJHm5ALvAMtUB/QIRP5bVIDOlfN6sFgpxgB9dOM4c5gVYdpNaMcmMVjAT4A2O1CqcMLtdjc9TqYkSIioqhpqcu6BMf04YezzsKW4uO46l+bW7xONasHA51inPthIU7v0QY5Gcl44MMffQZeEhyB1/iCXLdgM9gMls0ugsoA1jfa0WBzjCpcHd/jsQAfACrrGiGanrBQt4gB4ru7OQMpIiKdkAvZZ7y+AxLgFpg0L2QPNOhSs3ow0CzW698cxOvfHGzxPOc0YxlG9mgLIPipQzXThq5BTprGmzkHu4VPrJFX7CUlmJCcGPpjI6/8q4zD7uac2iMi0pFAC9nDuXow0CzWyB5tMCy/NVqnBjY1NPWlLZj49FeY/spW3Pnf78K+OlFuxpmUYEKCWduPy3jPSMk9pEJdsSfj1B4REcWMQAvZ5aCreaYmN8QC70CzXa//9TSYTRI2FZUFNM1YbxPYc7gSew5X+j1PzmDN/3Q3zurZFvd/4Ht1oq9pQ8C5ZUmCWQqoO3ww5L5U8bhtDuBaaK5NGOHalDPeMJAiItKhQLqsA+FZPRjMFCMQeOD16l9G4NeTNfjkuxK8s+PXFsfx7w3F+PeGYr/n+FqduLKwBH9/vxCAY/rtqn9t1nQFodyXyhqnfaS02mdPFs8ZKU7tEREZnNarB4HgemUFOs3Yq30Gzu2Tg0uGdgpoDKd0boW8zMCmGZes248Pvv0Nvxyrxmc/OKYCy6rr3c7RslFp/GekmlbsabR3opzZYrE5ERFRk2CyXcFMMwaawXpnxhkBr078at8xfLXvmOP3JaiaCgyGfjJSGk3tKRmp+Hs8GEgREVHYBDrFCAQeeGm5OhEAWqUm4sLBHfD9r+Uo/K0cjX56UYXaqFQW7xmpSs0zUvHb/oBTe0REFDMCnWbUanWiBODRPw7EQ1MG4IOZZ+KxSwYGNE41jUpdJSc6Pn5/OlIRE1vhBEuuZdKihxTgzGzFY40UM1JERBSXwrE6sUOrwDq+q2lUKltZWILFTdv0bD9wUvNC9kjQuthc2WuPq/aIiIgiR+vVieFsVAqo24MwFmm5z57jeuI3I8WpPSIiMoRApg3D2ahUzR6EsUrOHGlWbN4UkNU32lHbEF91YwykiIiIXATTuiEYge5BuKX4uKrrjyStM1LplgRIkvt1xwtO7RERETUTjkalgRaoh1rIHglKIKVRjZTJJCEjKQEVtY2oqGlEToYmVxsRDKSIiIi8CKZ1QyACLVBfWXgYZ/VsizbpSQAcU4JaBnRaUNofaDS1BziyWxW1jcxIERERkadAeloBwGeFh/HVT0fx17O7o1ubVDz++V63KcFor/ATQjhX7Wk0tQfI2a2auOslxRopIiKiCAikp9UtY3piYMcsVNfb8Myafbjjv9951FVpuVWNGtX1Nsj18FpN7QGuK/fiqwUCAykiIqIIaamQ/c7z+uCjWWdi0VWn+Jy+i/YKPzljlGiWlMaiWlC2iYmzjBSn9oiIiCKopUJ2SZLQJj3Jb5Dkb6uacNdUuRaaS5J216tsE8MaKSIiIvKnpUL2QFfuPfzJLlx3ZjeM79ceWamJWFlY4tHBXeuaKqWHlIb1UYBrRiqwqb1YKcJnIEVERBRjAl3h9+PvFZjz9ndIMEno3T4Du0oqPM7Rumt6pcb77MmC6W4eiYAxUKyRIiIiijHyCj9f+RUJQLv0JNw2thf65mag0S68BlGA9jVVWveQkgVaIyVvsxMrRfgMpIiIiGJMIFvV/OOi/rhjfG+svP0cLLh8sN/r07JrunNqT+uMlFwj5XtqLxa32WEgRUREFIOC2aom0NogLbqmKz2kNM9IJbhdvzexuM0Oa6SIiIhiVKBb1QRaU7V61xGc2zdHCYLUFGxrvc+eLJBVe7G4zQ4DKSIiohgWyFY1gXZNX/F9Cb4uKsMd43ujdWoiHv5kd9AF28rUnsbF5mkWx/UdrajDpqIyj6Duh1/L8e///RzQdQUaWGqBU3tERERxLpCu6TPP7YHu7dJQVl2P+z4oxMw3v1VVsF1ZJ6/a0y4jtbKwBH95ZWvT9Tfiqn9txlmPrcXKwhIUHa3CzDd2YPKiDfjhN+8F9TIJjmBwRLdszcbWEgZSREREOtBSTdXfJvTF57efgwcu6AdffTRbKti22QUOllkBOKbPtCjqllfhHa2sczteUl6Lm17fgfEL1uOTH0ogScAfT+mIhy8aoASHruSf504uiGg/KU7tERER6URLNVWJZhP65WVB+Il/fHVNb967afGXRXhvx28h9W7ytwpPZhfA2L7t8LeJfdE3NxMA0Dbd4tFHKjdKfaQYSBEREemIVl3T73nve0wakIfTu2fjhLUBs5fv9Ah4Qm322dIqPNn1Z/dQgigg8CL8SGAgRUREZCCBFmIfKLPi+fVFeH59kc9zBBxTavNW7ML4gtygA5lQVuEFUoQfCayRIiIiMpBAuqbnZCThiUsH4bKhndAuw+L3+kLp3RRoUBfJVXjBYiBFRERkIIF0TX9oSn9cNqwznrhsMO47vyCg61XTuymQoC7Sq/CCxUCKiIjIYILpmh7OrFEgQV2kV+EFizVSREREBhRowXZLzT4lOAIwtVkjOaiLlVV4wZKE8LcIkkJRUVGBrKwslJeXIzMzs+VfICIiikFyrycAbsGUHHKpXbXnSs12NeESzOc3A6kwYiBFRER60byPFBDYljLxKJjPb07tERERUYtiqXdTLGEgRURERAGJld5NsYSr9oiIiIhUYiBFREREpBIDKSIiIiKVGEgRERERqcRAioiIiEglBlJEREREKjGQIiIiIlKJgRQRERGRSgykiIiIiFRiZ/MwkrcxrKioiPJIiIiIKFDy53Yg2xEzkAqjyspKAEDnzp2jPBIiIiIKVmVlJbKysvyeI4lAwi1SxW634/fff0dGRgYkSdtNHSsqKtC5c2ccOnSoxZ2p45kR7qcR7iPA+6k3vJ/6YYT7CAR3P4UQqKysRIcOHWAy+a+CYkYqjEwmEzp16hTW28jMzNT1C19mhPtphPsI8H7qDe+nfhjhPgKB38+WMlEyFpsTERERqcRAioiIiEglBlJxKikpCXPnzkVSUlK0hxJWRrifRriPAO+n3vB+6ocR7iMQvvvJYnMiIiIilZiRIiIiIlKJgRQRERGRSgykiIiIiFRiIEVERESkEgOpOLR48WJ07doVycnJOO2007Bly5ZoD0lTDz74ICRJcvuvb9++0R5WyL766itMnjwZHTp0gCRJ+OCDD9wuF0LggQceQF5eHlJSUjBu3Djs27cvOoMNQUv3c9q0aR7P78SJE6MzWJXmz5+P4cOHIyMjAzk5Objooouwd+9et3Nqa2sxc+ZMtGnTBunp6bjkkktw5MiRKI1YnUDu5+jRoz2ez5tuuilKI1ZnyZIlGDRokNKoceTIkfjss8+Uy/XwXAIt3089PJfNPfroo5AkCbfffrtyTOvnk4FUnFm+fDlmz56NuXPnYseOHRg8eDAmTJiA0tLSaA9NU/3790dJSYny34YNG6I9pJBVV1dj8ODBWLx4sdfLH3/8cTzzzDN4/vnn8c033yAtLQ0TJkxAbW1thEcampbuJwBMnDjR7fl96623IjjC0K1fvx4zZ87E5s2bsWrVKjQ0NOC8885DdXW1cs4dd9yBFStW4O2338b69evx+++/449//GMURx28QO4nAEyfPt3t+Xz88cejNGJ1OnXqhEcffRTbt2/Htm3bMGbMGEyZMgU//vgjAH08l0DL9xOI/+fS1datW/HCCy9g0KBBbsc1fz4FxZURI0aImTNnKj/bbDbRoUMHMX/+/CiOSltz584VgwcPjvYwwgqAeP/995Wf7Xa7yM3NFU888YRy7OTJkyIpKUm89dZbURihNprfTyGEmDp1qpgyZUpUxhMupaWlAoBYv369EMLx3CUmJoq3335bOWf37t0CgNi0aVO0hhmy5vdTCCFGjRolbrvttugNKkxat24t/v3vf+v2uZTJ91MIfT2XlZWVolevXmLVqlVu9ysczyczUnGkvr4e27dvx7hx45RjJpMJ48aNw6ZNm6I4Mu3t27cPHTp0QPfu3fGnP/0JBw8ejPaQwqq4uBiHDx92e26zsrJw2mmn6e65BYB169YhJycHffr0wYwZM1BWVhbtIYWkvLwcAJCdnQ0A2L59OxoaGtyez759+6JLly5x/Xw2v5+yN954A23btsWAAQNw7733wmq1RmN4mrDZbFi2bBmqq6sxcuRI3T6Xze+nTC/P5cyZM3H++ee7PW9AeP42uWlxHDl27BhsNhvat2/vdrx9+/bYs2dPlEalvdNOOw0vv/wy+vTpg5KSEsybNw9nn302CgsLkZGREe3hhcXhw4cBwOtzK1+mFxMnTsQf//hHdOvWDUVFRfi///s/TJo0CZs2bYLZbI728IJmt9tx++2348wzz8SAAQMAOJ5Pi8WCVq1auZ0bz8+nt/sJAFdffTXy8/PRoUMHfP/997j77ruxd+9evPfee1EcbfB++OEHjBw5ErW1tUhPT8f777+PgoIC7Ny5U1fPpa/7CejnuVy2bBl27NiBrVu3elwWjr9NBlIUcyZNmqT8e9CgQTjttNOQn5+P//73v/jrX/8axZGRFq688krl3wMHDsSgQYPQo0cPrFu3DmPHjo3iyNSZOXMmCgsLdVHH54+v+3nDDTco/x44cCDy8vIwduxYFBUVoUePHpEepmp9+vTBzp07UV5ejnfeeQdTp07F+vXroz0szfm6nwUFBbp4Lg8dOoTbbrsNq1atQnJyckRuk1N7caRt27Ywm80eqwuOHDmC3NzcKI0q/Fq1aoXevXtj//790R5K2MjPn9GeWwDo3r072rZtG5fP76xZs/Dxxx/jyy+/RKdOnZTjubm5qK+vx8mTJ93Oj9fn09f99Oa0004DgLh7Pi0WC3r27ImhQ4di/vz5GDx4MBYuXKi759LX/fQmHp/L7du3o7S0FKeeeioSEhKQkJCA9evX45lnnkFCQgLat2+v+fPJQCqOWCwWDB06FGvWrFGO2e12rFmzxm2OW2+qqqpQVFSEvLy8aA8lbLp164bc3Fy357aiogLffPONrp9bAPj1119RVlYWV8+vEAKzZs3C+++/j7Vr16Jbt25ulw8dOhSJiYluz+fevXtx8ODBuHo+W7qf3uzcuRMA4ur59MZut6Ourk43z6Uv8v30Jh6fy7Fjx+KHH37Azp07lf+GDRuGP/3pT8q/NX8+Q6+Np0hatmyZSEpKEi+//LLYtWuXuOGGG0SrVq3E4cOHoz00zdx5551i3bp1ori4WGzcuFGMGzdOtG3bVpSWlkZ7aCGprKwU3377rfj2228FALFgwQLx7bffigMHDgghhHj00UdFq1atxIcffii+//57MWXKFNGtWzdRU1MT5ZEHx9/9rKysFHPmzBGbNm0SxcXFYvXq1eLUU08VvXr1ErW1tdEeesBmzJghsrKyxLp160RJSYnyn9VqVc656aabRJcuXcTatWvFtm3bxMiRI8XIkSOjOOrgtXQ/9+/fLx566CGxbds2UVxcLD788EPRvXt3cc4550R55MG55557xPr160VxcbH4/vvvxT333CMkSRJffPGFEEIfz6UQ/u+nXp5Lb5qvRtT6+WQgFYeeffZZ0aVLF2GxWMSIESPE5s2boz0kTV1xxRUiLy9PWCwW0bFjR3HFFVeI/fv3R3tYIfvyyy8FAI//pk6dKoRwtEC4//77Rfv27UVSUpIYO3as2Lt3b3QHrYK/+2m1WsV5550n2rVrJxITE0V+fr6YPn163H0R8Hb/AIilS5cq59TU1Iibb75ZtG7dWqSmpoqLL75YlJSURG/QKrR0Pw8ePCjOOecckZ2dLZKSkkTPnj3F3/72N1FeXh7dgQfpL3/5i8jPzxcWi0W0a9dOjB07VgmihNDHcymE//upl+fSm+aBlNbPpySEEOpyWURERETGxhopIiIiIpUYSBERERGpxECKiIiISCUGUkREREQqMZAiIiIiUomBFBEREZFKDKSIiIiIVGIgRUQR9+CDD2LIkCEhXccvv/wCSZKUbSzCZfTo0bj99tvDehux6uWXX0arVq2iPQyimMZAiog8HDp0CH/5y1/QoUMHWCwW5Ofn47bbbkNZWVnQ1yVJEj744AO3Y3PmzHHb60qNzp07o6SkBAMGDAjpemTr1q2DJEkem5m+9957+Mc//qHJbfjSPCj0NZZw6tq1K55++mm3Y1dccQV++umniI2BKB4xkCIiNz///DOGDRuGffv24a233sL+/fvx/PPPK5tjHz9+POTbSE9PR5s2bUK6DrPZjNzcXCQkJIQ8Hn+ys7ORkZER1tsIFyEEGhsbVf9+SkoKcnJyNBwRkf4wkCIiNzNnzoTFYsEXX3yBUaNGoUuXLpg0aRJWr16N3377DX//+9+Vc7t27Yp//OMfuOqqq5CWloaOHTti8eLFbpcDwMUXXwxJkpSfm0/tTZs2DRdddBEeeeQRtG/fHq1atcJDDz2ExsZG/O1vf0N2djY6deqEpUuXKr/TPIszbdo0SJLk8d+6desAAK+99hqGDRuGjIwM5Obm4uqrr0ZpaalyXeeeey4AoHXr1pAkCdOmTQPgObV34sQJXHvttWjdujVSU1MxadIk7Nu3T7lcng77/PPP0a9fP6Snp2PixIkoKSkJ6PH3Nxa73Y758+ejW7duSElJweDBg/HOO+8ovytnsj777DMMHToUSUlJ2LBhA4qKijBlyhS0b98e6enpGD58OFavXq383ujRo3HgwAHccccdyuPmel9cLVmyBD169IDFYkGfPn3w2muvuV0uSRL+/e9/4+KLL0Zqaip69eqFjz76KKD7ThSXQt0MkIj0o6ysTEiSJB555BGvl0+fPl20bt1a2O12IYQQ+fn5IiMjQ8yfP1/s3btXPPPMM8JsNisboZaWliqb3JaUlIjS0lIhhBBz584VgwcPVq536tSpIiMjQ8ycOVPs2bNH/Oc//xEAxIQJE8Q///lP8dNPP4l//OMfIjExURw6dEgIIURxcbEAIL799lshhBAnT54UJSUlyn+33XabyMnJUTYj/c9//iM+/fRTUVRUJDZt2iRGjhwpJk2aJIQQorGxUbz77rsCgNi7d68oKSkRJ0+eFEJ4bnh64YUXin79+omvvvpK7Ny5U0yYMEH07NlT1NfXCyGEWLp0qUhMTBTjxo0TW7duFdu3bxf9+vUTV199tc/H3fW++BvLww8/LPr27StWrlwpioqKxNKlS0VSUpJYt26dEMK5YfSgQYPEF198Ifbv3y/KysrEzp07xfPPPy9++OEH8dNPP4n77rtPJCcniwMHDijPe6dOncRDDz2kPH7yfcnKylLG+d5774nExESxePFisXfvXvH//t//E2azWaxdu1Y5B4Do1KmTePPNN8W+ffvErbfeKtLT00VZWZnP+08UzxhIEZFi8+bNAoB4//33vV6+YMECAUAcOXJECOEIpCZOnOh2zhVXXKEEKEIIr9fnLZDKz88XNptNOdanTx9x9tlnKz83NjaKtLQ08dZbbwkhPAMpV++++65ITk4WGzZs8Hlft27dKgCIyspKIYQzCDlx4oTbea6B1E8//SQAiI0bNyqXHzt2TKSkpIj//ve/QghH8AFA7N+/Xzln8eLFon379j7H0vy+eBtLbW2tSE1NFV9//bXb7/71r38VV111ldvvffDBBz5vS9a/f3/x7LPPKj/n5+eLp556yu2c5oHUGWecIaZPn+52zmWXXSb+8Ic/KD8DEPfdd5/yc1VVlQAgPvvssxbHRBSPOLVHRB6EEAGfO3LkSI+fd+/eHfRt9u/fHyaT8y2pffv2GDhwoPKz2WxGmzZtlOk4X7799lv8+c9/xqJFi3DmmWcqx7dv347JkyejS5cuyMjIwKhRowAABw8eDHiMu3fvRkJCAk477TTlWJs2bdCnTx+3+5yamooePXooP+fl5bU47pbs378fVqsV48ePR3p6uvLfq6++iqKiIrdzhw0b5vZzVVUV5syZg379+qFVq1ZIT0/H7t27g7rvgOP+uz6mAHDmmWd6PN+DBg1S/p2WlobMzMyQ7z9RrApvlSYRxZWePXtCkiTs3r0bF198scflu3fvRuvWrdGuXTvNbzsxMdHtZ0mSvB6z2+0+r+Pw4cO48MILcf311+Ovf/2rcry6uhoTJkzAhAkT8MYbb6Bdu3Y4ePAgJkyYgPr6em3vCLzfl2CCU2+qqqoAAJ988gk6duzodllSUpLbz2lpaW4/z5kzB6tWrcKTTz6Jnj17IiUlBZdeemlY7jvg/f77e96I4hkzUkSkaNOmDcaPH4/nnnsONTU1bpcdPnwYb7zxBq644gqlGBkANm/e7Hbe5s2b0a9fP+XnxMRE2Gy28A4cQG1tLaZMmYK+fftiwYIFbpft2bMHZWVlePTRR3H22Wejb9++HhkSi8UCAH7H2q9fPzQ2NuKbb75RjpWVlWHv3r0oKCjQ7L54G0tBQQGSkpJw8OBB9OzZ0+2/zp07+72+jRs3Ytq0abj44osxcOBA5Obm4pdffvG4zZaep379+mHjxo0e163lfSeKNwykiMjNokWLUFdXhwkTJuCrr77CoUOHsHLlSowfPx4dO3bEP//5T7fzN27ciMcffxw//fQTFi9ejLfffhu33XabcnnXrl2xZs0aHD58GCdOnAjbuG+88UYcOnQIzzzzDI4ePYrDhw/j8OHDqK+vR5cuXWCxWPDss8/i559/xkcffeTRGyo/Px+SJOHjjz/G0aNHlQyQq169emHKlCmYPn06NmzYgO+++w7XXHMNOnbsiClTpmh2X7yNJSMjA3PmzMEdd9yBV155BUVFRdixYweeffZZvPLKK36vr1evXnjvvfewc+dOfPfdd7j66qs9MkRdu3bFV199hd9++w3Hjh3zej1/+9vf8PLLL2PJkiXYt28fFixYgPfeew9z5szR7L4TxRsGUkTkplevXti2bRu6d++Oyy+/HD169MANN9yAc889F5s2bUJ2drbb+XfeeSe2bduGU045BQ8//DAWLFiACRMmKJf/v//3/7Bq1Sp07twZp5xyStjGvX79epSUlKCgoAB5eXnKf19//TXatWuHl19+GW+//TYKCgrw6KOP4sknn3T7/Y4dO2LevHm455570L59e8yaNcvr7SxduhRDhw7FBRdcgJEjR0IIgU8//dRjOisUvsbyj3/8A/fffz/mz5+Pfv36YeLEifjkk0/QrVs3v9e3YMECtG7dGmeccQYmT56MCRMm4NRTT3U756GHHsIvv/yCHj16+Jy6veiii7Bw4UI8+eST6N+/P1544QUsXboUo0eP1uR+E8UjSYQ6cU9EhtW1a1fcfvvtht1ChYiIGSkiIiIilRhIEREREanEqT0iIiIilZiRIiIiIlKJgRQRERGRSgykiIiIiFRiIEVERESkEgMpIiIiIpUYSBERERGpxECKiIiISCUGUkREREQqMZAiIiIiUun/A0ao06+8LhYDAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(loss_hist, marker=\"o\")\n", + "plt.yscale(\"log\")\n", + "plt.xlabel(\"Optimization Iteration\")\n", + "plt.ylabel(\"Compliance\")\n", + "plt.title(\"Compliance over Optimization\")" + ] + }, + { + "cell_type": "code", + "execution_count": 230, + "id": "bd470372", + "metadata": {}, + "outputs": [], + "source": [ + "from matplotlib import animation\n", + "\n", + "# repeat the last frame a few times to show the final result\n", + "params_hist = params_hist + [params] * 20\n", + "\n", + "fig = plt.figure(figsize=(7, 4))\n", + "\n", + "ims = []\n", + "for params in params_hist[:40]:\n", + " sdf = apply_tesseract(\n", + " design_tess,\n", + " {\n", + " \"differentiable_parameters\": params.flatten(),\n", + " \"non_differentiable_parameters\": jnp.array([bar_radius], dtype=jnp.float32),\n", + " \"static_parameters\": [n_chains, n_edges_per_chain + 1],\n", + " \"string_parameters\": [],\n", + " \"mesh_tesseract\": TesseractReference(bar_3d_tess),\n", + " \"grid_size\": [Lx, Ly, Lz],\n", + " \"grid_elements\": [Nx, Ny, Nz],\n", + " \"grid_center\": [0.0, 0.0, 0.0],\n", + " },\n", + " )[\"sdf\"]\n", + "\n", + " rho = sdf_to_rho(sdf)\n", + "\n", + " im = plt.imshow((sdf[:, :, :] > 0).sum(axis=1).T, origin=\"lower\", cmap=\"viridis\")\n", + " ims.append([im])\n", + "\n", + "ani = animation.ArtistAnimation(fig, ims, interval=10, blit=False, repeat_delay=2)\n", + "plt.close(fig)\n", + "\n", + "ani.save(\"rho_optim_sum_2.gif\", writer=\"pillow\", fps=10)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4a7ea4ce", + "metadata": {}, + "outputs": [], + "source": [ + "# lets visualize the 3d meshes over the optimization\n", + "for i, params in enumerate(params_hist):\n", + " design_out = design_tess.apply(\n", + " {\n", + " \"differentiable_parameters\": params.flatten(),\n", + " \"non_differentiable_parameters\": jnp.array([bar_radius], dtype=jnp.float32),\n", + " \"static_parameters\": [n_chains, n_edges_per_chain + 1],\n", + " \"string_parameters\": [],\n", + " \"mesh_tesseract\": TesseractReference(bar_3d_tess),\n", + " \"grid_size\": [Lx, Ly, Lz],\n", + " \"grid_elements\": [Nx, Ny, Nz],\n", + " \"grid_center\": [0.0, 0.0, 0.0],\n", + " \"epsilon\": 1e-3, # epsilon, only used for FD of the jacobian\n", + " }\n", + " )\n", + " surface_mesh = design_out[\"mesh\"]\n", + "\n", + " num_vertices = surface_mesh[\"n_points\"]\n", + " num_faces = surface_mesh[\"n_faces\"]\n", + "\n", + " points = surface_mesh[\"points\"][:num_vertices]\n", + " faces = surface_mesh[\"faces\"][:num_faces]\n", + "\n", + " mesh = {\n", + " \"points\": points,\n", + " \"faces\": faces,\n", + " }\n", + "\n", + " plot_mesh(mesh, save_path=f\"tmp_img/mesh_optim_{i:03d}.png\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "dfd2674e", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "fem", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/ansys/optim_grid.ipynb b/examples/ansys/optim_grid.ipynb new file mode 100644 index 0000000..b966e07 --- /dev/null +++ b/examples/ansys/optim_grid.ipynb @@ -0,0 +1,1590 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "62c62e53", + "metadata": {}, + "source": [ + "# Parametric shape optimization with differentiable FEM simulation\n", + "\n", + "## Introduction\n", + "\n", + "In this notebook, we explore the optimization of a parametric structure made of a linear elastic material.\n", + "\n", + "We denote the design space as a function $g$ that maps the design variables to a signed distance field. Then, we can then define the density field $\\rho(\\mathbf{x})$ as a function of a signed distance field (SDF) value $g(\\mathbf{x})$. For adaptive meshing, we define a sizing field $h(\\mathbf{x})$ as a function of the SDF value as well.\n", + "We introduce an adpative differentiable mesher $m$ that takes the sizing field and returns a hex mesh. Finally we denote the differentiable finite element method (FEM) solver as $f$, which takes the density field and the hex mesh as input and returns the structure's compliance. Therefore, the optimization problem can be formulated as follows:\n", + "\n", + "$$\n", + "\\begin{equation}\n", + "\\min_{\\theta} f(m(g(\\theta)), \\rho(g(\\theta))).\n", + "\\end{equation}\n", + "$$\n", + "\n", + "Here, $\\theta$ is the vector of design variables." + ] + }, + { + "cell_type": "markdown", + "id": "e3e34d41", + "metadata": {}, + "source": [ + "## Setup" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "5f5b8544", + "metadata": {}, + "outputs": [], + "source": [ + "# Install additional requirements for this notebook\n", + "# %pip install -r requirements.txt -q --isolated" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "c367fd3b", + "metadata": {}, + "outputs": [], + "source": [ + "# import tesseract_core\n", + "\n", + "# tesseract_core.build_tesseract(\"design_tess\", \"latest\")\n", + "# tesseract_core.build_tesseract(\"fem_tess\", \"latest\")\n", + "# tesseract_core.build_tesseract(\"meshing_tess\", \"latest\")\n", + "# print(\"Tesseract built successfully.\")" + ] + }, + { + "cell_type": "markdown", + "id": "e771cce1", + "metadata": {}, + "source": [ + "## Design Space Tesseract" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "64ebfb56", + "metadata": {}, + "outputs": [], + "source": [ + "import jax\n", + "import jax.numpy as jnp\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pyvista as pv\n", + "from tesseract_core import Tesseract\n", + "from tesseract_core.runtime.experimental import TesseractReference\n", + "\n", + "from tesseract_jax import apply_tesseract" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "8a407fb1", + "metadata": {}, + "outputs": [], + "source": [ + "# design_tess = Tesseract.from_image(\"design-tube-sdf\")\n", + "# design_tess.serve()\n", + "IP = \"172.26.3.35\"\n", + "port = 443\n", + "url = f\"http://{IP}:{port}\"\n", + "\n", + "design_tess = Tesseract.from_tesseract_api(\"sdf_fd_tess/tesseract_api.py\")\n", + "stl_tess = Tesseract.from_url(url)\n", + "# stt_tess = Tesseract.from_tesseract_api(\"bars_3d_tess/tesseract_api.py\")" + ] + }, + { + "cell_type": "markdown", + "id": "bb2d05dd", + "metadata": {}, + "source": [ + "Now we can setup the parameters for the design space and apply the design Tesseract. The Tesseract constructs a 3D geometry using PyVista and computes its signed distance field (SDF)." + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "id": "0fdeb653", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.2 0.2 0. 0.49999997 0.0621019 0.56210184\n", + " 0.12579617 0.62579614 0.18789807 0.68789804 0.24999999 0.74999994\n", + " 0.3121019 0.81369424 0.37579614 0.8757961 0.43789804 0.937898 ]\n" + ] + } + ], + "source": [ + "Nx, Ny, Nz = 250, 200, 10\n", + "Lx, Ly, Lz = 50, 40, 2\n", + "\n", + "grid_fin_params = {\n", + " \"angular_positions\": jnp.array(\n", + " [\n", + " [0, 3.14],\n", + " [0.39, 3.53],\n", + " [0.79, 3.93],\n", + " [1.18, 4.32],\n", + " [1.57, 4.71],\n", + " [1.96, 5.11],\n", + " [2.36, 5.50],\n", + " [2.75, 5.89],\n", + " ]\n", + " ),\n", + " \"plane_height\": 400,\n", + " \"plane_thickness\": 100,\n", + " \"cuttin_plane_1\": 200,\n", + " \"cuttin_plane_2\": 200,\n", + "}\n", + "\n", + "# lets create a flat parameter array from the grid fin params\n", + "init_diffable_params = jnp.concatenate(\n", + " [\n", + " jnp.array(\n", + " [grid_fin_params[\"cuttin_plane_1\"], grid_fin_params[\"cuttin_plane_2\"]]\n", + " ),\n", + " grid_fin_params[\"angular_positions\"].flatten(),\n", + " ]\n", + ").astype(jnp.float32)\n", + "\n", + "normalization_factors = 1 / jnp.array([1000, 1000] + [3.14 * 2] * 16, dtype=jnp.float32)\n", + "normalization_bias = jnp.zeros_like(normalization_factors)\n", + "\n", + "\n", + "def normalize(params, norms, bias):\n", + " return params * norms + bias\n", + "\n", + "\n", + "def denormalize(params, norms, bias):\n", + " return (params - bias) / norms\n", + "\n", + "\n", + "init_diffable_params = normalize(\n", + " init_diffable_params, normalization_factors, normalization_bias\n", + ")\n", + "\n", + "non_diffable_paramas = jnp.array(\n", + " [\n", + " grid_fin_params[\"plane_height\"],\n", + " grid_fin_params[\"plane_thickness\"],\n", + " ],\n", + " dtype=jnp.float32,\n", + ")\n", + "\n", + "design_inputs = {\n", + " \"non_differentiable_parameters\": non_diffable_paramas,\n", + " \"normalization_factors\": normalization_factors,\n", + " \"normalization_bias\": normalization_bias,\n", + " \"static_parameters\": [],\n", + " \"string_parameters\": [\n", + " \"F:\\\\ANSYS Inc\\\\v242\\\\scdm\\\\SpaceClaim.exe\",\n", + " \"geometry_generation.scscript\",\n", + " ],\n", + " \"mesh_tesseract\": TesseractReference(stl_tess),\n", + " \"grid_center\": [0.0, 0.0, 2.0],\n", + " \"grid_size\": [Lx, Ly, Lz],\n", + " \"grid_elements\": [Nx, Ny, Nz],\n", + " \"scale_mesh\": 0.01,\n", + " \"max_points\": 1000,\n", + " \"max_faces\": 2000,\n", + " \"precompute_jacobian\": True,\n", + " \"normalize_jacobian\": True,\n", + " \"epsilon\": 0.001,\n", + "}\n", + "\n", + "print(init_diffable_params)" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "id": "ee45c98d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Starting Jacobian precomputation thread...\n", + "Number of vertices: 224\n", + "Number of faces: 516\n" + ] + } + ], + "source": [ + "design_out = apply_tesseract(\n", + " design_tess,\n", + " {\n", + " \"differentiable_parameters\": init_diffable_params,\n", + " **design_inputs,\n", + " },\n", + ")\n", + "sdf = design_out[\"sdf\"]\n", + "surface_mesh = design_out[\"mesh\"]\n", + "\n", + "num_vertices = surface_mesh[\"n_points\"]\n", + "num_faces = surface_mesh[\"n_faces\"]\n", + "\n", + "print(f\"Number of vertices: {num_vertices}\")\n", + "print(f\"Number of faces: {num_faces}\")\n", + "\n", + "points = surface_mesh[\"points\"][:num_vertices]\n", + "faces = surface_mesh[\"faces\"][:num_faces]\n", + "\n", + "mesh = {\n", + " \"points\": points,\n", + " \"faces\": faces,\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "id": "760cf3ee", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def plot_mesh(mesh: dict, save_path: str | None = None) -> None:\n", + " \"\"\"Plot a 3D triangular mesh with boundary conditions visualization.\n", + "\n", + " Args:\n", + " mesh: Dictionary containing 'points' and 'faces' arrays.\n", + " save_path: Optional path to save the plot as an image file.\n", + " \"\"\"\n", + " fig = plt.figure(figsize=(10, 8))\n", + " ax = fig.add_subplot(111, projection=\"3d\")\n", + " ax.plot_trisurf(\n", + " mesh[\"points\"][:, 0],\n", + " mesh[\"points\"][:, 1],\n", + " mesh[\"points\"][:, 2],\n", + " triangles=mesh[\"faces\"],\n", + " alpha=0.7,\n", + " antialiased=True,\n", + " color=\"lightblue\",\n", + " edgecolor=\"black\",\n", + " )\n", + "\n", + " ax.set_xlim(-Lx / 2, Lx / 2)\n", + " ax.set_ylim(-Ly / 2, Ly / 2)\n", + " ax.set_zlim(-Lz / 2, Lz / 2)\n", + "\n", + " # set equal aspect ratio\n", + " ax.set_box_aspect(\n", + " (\n", + " (Lx) / (Ly),\n", + " 1,\n", + " (Lz) / (Ly),\n", + " )\n", + " )\n", + "\n", + " # x axis label\n", + " ax.set_xlabel(\"X\")\n", + " ax.set_ylabel(\"Y\")\n", + " ax.set_zlabel(\"Z\")\n", + "\n", + " if save_path:\n", + " # avoid showing the plot in notebook\n", + " plt.savefig(save_path)\n", + " plt.close(fig)\n", + "\n", + "\n", + "plot_mesh(mesh)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "8f38e119", + "metadata": {}, + "outputs": [], + "source": [ + "# # Lets figure out a good epsilon value for FD jacobian computation\n", + "# epsilons = jnp.logspace(-2, -0.5, 5)\n", + "# print(epsilons)\n", + "# mean_grads = []\n", + "# std_grads = []\n", + "\n", + "# for i in range(len(epsilons)):\n", + "# eps = epsilons[i]\n", + "# print(eps)\n", + "# design_inputs_eps = design_inputs.copy()\n", + "# design_inputs_eps[\"epsilon\"] = eps.item()\n", + "\n", + "# primal, vjp_fun = jax.vjp(\n", + "# lambda params, design_params=design_inputs_eps: apply_tesseract(\n", + "# design_tess,\n", + "# {\n", + "# \"differentiable_parameters\": params,\n", + "# **design_params,\n", + "# },\n", + "# )[\"sdf\"],\n", + "# init_diffable_params,\n", + "# )\n", + "\n", + "# grad = vjp_fun(jnp.ones((Nx, Ny, Nz), dtype=jnp.float32))[0]\n", + "\n", + "# mean_grads.append(jnp.mean(jnp.abs(grad)))\n", + "# std_grads.append(jnp.std(grad))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "16161ae3", + "metadata": {}, + "outputs": [], + "source": [ + "# plt.figure(figsize=(8, 6))\n", + "# plt.plot(epsilons, mean_grads, marker=\"o\")\n", + "# plt.plot(epsilons, std_grads, marker=\"x\")\n", + "# plt.xlabel(\"Epsilon\")\n", + "# plt.xscale(\"log\")\n", + "# plt.yscale(\"log\")\n", + "# plt.ylabel(\"Mean Absolute Gradient\")\n", + "# plt.title(\"Effect of Epsilon on Gradient Magnitude\")\n", + "# plt.grid(True)\n", + "# plt.legend([\"Mean Gradient\", \"Std Dev of Gradient\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "66e8e4cf", + "metadata": {}, + "outputs": [], + "source": [ + "# primal, vjp_fun = jax.vjp(\n", + "# lambda params: apply_tesseract(\n", + "# design_tess,\n", + "# {\n", + "# \"differentiable_parameters\": params,\n", + "# **design_inputs,\n", + "# },\n", + "# )[\"sdf\"],\n", + "# init_diffable_params,\n", + "# )\n", + "\n", + "# grad = vjp_fun(jax.numpy.ones((Nx, Ny, Nz), dtype=jax.numpy.float32))[0]\n", + "\n", + "# print(\"Gradient shape:\", grad.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "id": "85a4ee0e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from mpl_toolkits.axes_grid1 import make_axes_locatable\n", + "\n", + "\n", + "def plot_grid_slice(field_slice, extent, ax, title, xlabel, ylabel):\n", + " im = ax.imshow(field_slice.T, extent=extent, origin=\"lower\")\n", + " ax.set_title(title)\n", + " ax.set_xlabel(xlabel)\n", + " ax.set_ylabel(ylabel)\n", + " # add colorbar\n", + " divider = make_axes_locatable(ax)\n", + " cax = divider.append_axes(\"right\", size=\"5%\", pad=0.1)\n", + " plt.colorbar(im, cax=cax, orientation=\"vertical\")\n", + " return im\n", + "\n", + "\n", + "def plot_grid(field, Lx, Ly, Lz, Nx, Ny, Nz):\n", + " _, axs = plt.subplots(1, 3, figsize=(15, 5))\n", + "\n", + " plot_grid_slice(\n", + " field[Nx // 2, :, :],\n", + " extent=(-Ly / 2, Ly / 2, -Lz / 2, Lz / 2),\n", + " ax=axs[0],\n", + " title=\"SDF slice at x=0\",\n", + " xlabel=\"y\",\n", + " ylabel=\"z\",\n", + " )\n", + " plot_grid_slice(\n", + " field[:, Ny // 2, :],\n", + " extent=(-Lx / 2, Lx / 2, -Lz / 2, Lz / 2),\n", + " ax=axs[1],\n", + " title=\"SDF slice at y=0\",\n", + " xlabel=\"x\",\n", + " ylabel=\"z\",\n", + " )\n", + " plot_grid_slice(\n", + " field[:, :, Nz // 2],\n", + " extent=(-Lx / 2, Lx / 2, -Ly / 2, Ly / 2),\n", + " ax=axs[2],\n", + " title=\"SDF slice at z=0\",\n", + " xlabel=\"x\",\n", + " ylabel=\"y\",\n", + " )\n", + "\n", + "\n", + "plot_grid(sdf, Lx, Ly, Lz, Nx, Ny, Nz)" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "id": "669ca254", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "rho min: 7.189832558651688e-06, rho max: 0.9823046922683716\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def sdf_to_rho(\n", + " sdf: jnp.ndarray, scale: float = 2.0, offset: float = 0.1\n", + ") -> jnp.ndarray:\n", + " \"\"\"Convert signed distance function to material density using sigmoid.\n", + "\n", + " Args:\n", + " sdf: Signed distance function values.\n", + " scale: Sigmoid steepness (higher = sharper transition).\n", + " offset: SDF value where density = 0.5.\n", + "\n", + " Returns:\n", + " Material density field in [0,1].\n", + " \"\"\"\n", + " return 1 / (1 + jnp.exp(scale * sdf - offset))\n", + "\n", + "\n", + "rho_scale = 1.5\n", + "rho_offset = 1.5\n", + "\n", + "# plot the functions\n", + "sdfs = jnp.linspace(-5, 10)\n", + "rhos = sdf_to_rho(sdfs, scale=rho_scale, offset=rho_offset)\n", + "\n", + "plt.plot(sdfs, rhos)\n", + "\n", + "\n", + "rho = sdf_to_rho(sdf, scale=rho_scale, offset=rho_offset)\n", + "\n", + "plot_grid(rho, Lx, Ly, Lz, Nx, Ny, Nz)\n", + "print(f\"rho min: {jnp.min(rho)}, rho max: {jnp.max(rho)}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "id": "29988ae8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sizing field min: 0.78125, max: 12.5\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def sizing_field(\n", + " sdf: jnp.ndarray, min_size: float = 0.1, max_size: float = 1.0, scale: float = 2.0\n", + ") -> jnp.ndarray:\n", + " \"\"\"Generate a sizing field from the signed distance function.\n", + "\n", + " The field is low (size = min_size) near the structure (sdf=0) and high (size = max_size) far from it.\n", + "\n", + " Args:\n", + " sdf: Signed distance function values.\n", + " min_size: Minimum element size near the structure.\n", + " max_size: Maximum element size far from the structure.\n", + " scale: Controls the transition steepness.\n", + "\n", + " Returns:\n", + " Sizing field values.\n", + " \"\"\"\n", + "\n", + " def gauss(x: jnp.ndarray, mu: float, sigma: float) -> jnp.ndarray:\n", + " return jnp.exp(-0.5 * ((x - mu) / sigma) ** 2)\n", + "\n", + " normalized_sdf = 1 - gauss(sdf, 0.0, 1.0 / scale)\n", + " return min_size + (max_size - min_size) * normalized_sdf\n", + "\n", + "\n", + "sizing_min = Lx / 64\n", + "sizing_max = Lx / 4\n", + "sizing_scale = 1\n", + "\n", + "sizing = sizing_field(sdf, min_size=sizing_min, max_size=sizing_max, scale=sizing_scale)\n", + "plot_grid(sizing, Lx, Ly, Lz, Nx, Ny, Nz)\n", + "print(f\"Sizing field min: {sizing.min()}, max: {sizing.max()}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "id": "41fdbeb2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mesh points: 5140, Mesh faces: 1677\n" + ] + } + ], + "source": [ + "mesher = Tesseract.from_tesseract_api(\"meshing_tess/tesseract_api.py\")\n", + "\n", + "mesher_out = apply_tesseract(\n", + " mesher,\n", + " {\n", + " \"domain_size\": [Lx, Ly, Lz],\n", + " \"sizing_field\": sizing, # jnp.ones_like(sdf) * (Lx / 10),\n", + " # \"sizing_field\": jnp.ones_like(sdf) * sizing_min,\n", + " \"field_values\": rho,\n", + " \"max_subdivision_levels\": 6,\n", + " \"max_points\": 40000,\n", + " \"max_cells\": 40000,\n", + " },\n", + ")\n", + "print(\n", + " f\"Mesh points: {mesher_out['mesh']['n_points']}, Mesh faces: {mesher_out['mesh']['n_faces']}\"\n", + ")\n", + "pts = mesher_out[\"mesh\"][\"points\"][: mesher_out[\"mesh\"][\"n_points\"]]\n", + "hex_cells = mesher_out[\"mesh\"][\"faces\"][: mesher_out[\"mesh\"][\"n_faces\"]]\n", + "\n", + "adaptive_mesh = mesher_out[\"mesh\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "id": "607c29ad", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "UnstructuredGrid (0x725342cd4b20)\n", + " N Cells: 40000\n", + " N Points: 40000\n", + " X Bounds: -2.500e+01, 2.949e+01\n", + " Y Bounds: -2.047e+01, 3.328e+01\n", + " Z Bounds: -1.000e+00, 1.000e+00\n", + " N Arrays: 1\n" + ] + } + ], + "source": [ + "def hex_to_pyvista(\n", + " pts: jax.typing.ArrayLike, faces: jax.typing.ArrayLike, cell_data: dict\n", + ") -> pv.UnstructuredGrid:\n", + " \"\"\"Convert hex mesh defined by points and faces into a PyVista UnstructuredGrid.\n", + "\n", + " Args:\n", + " pts: Array of point coordinates, shape (N, 3).\n", + " faces: Array of hexahedral cell connectivity, shape (M, 8).\n", + " cell_data: additional cell center data.\n", + "\n", + " Returns:\n", + " PyVista mesh representing the hexahedral grid.\n", + " \"\"\"\n", + " pts = np.array(pts)\n", + " faces = np.array(faces)\n", + "\n", + " # Define the cell type for hexahedrons (VTK_HEXAHEDRON = 12)\n", + " cell_type = pv.CellType.HEXAHEDRON\n", + " cell_types = np.array([cell_type] * faces.shape[0], dtype=np.uint8)\n", + "\n", + " # Prepare the cells array: [number_of_points, i0, i1, i2, i3, i4, i5, i6, i7]\n", + " n_cells = faces.shape[0]\n", + " cells = np.empty((n_cells, 9), dtype=np.int64)\n", + " cells[:, 0] = 8 # Each cell has 8 points\n", + " cells[:, 1:9] = faces\n", + "\n", + " # Flatten the cells array for PyVista\n", + " cells = cells.flatten()\n", + "\n", + " mesh = pv.UnstructuredGrid(cells, cell_types, pts)\n", + "\n", + " # Add cell data\n", + " for name, data in cell_data.items():\n", + " mesh.cell_data[name] = data\n", + "\n", + " return mesh\n", + "\n", + "\n", + "# convert arrays to numpy\n", + "pts_np = np.array(adaptive_mesh[\"points\"])\n", + "cells_np = np.array(adaptive_mesh[\"faces\"])\n", + "\n", + "hex_mesh = hex_to_pyvista(pts_np, cells_np, {\"rho\": mesher_out[\"mesh_cell_values\"]})\n", + "\n", + "print(hex_mesh)\n", + "\n", + "hex_mesh.save(\"fem_shapeopt_mesh.vtk\")" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "id": "6612a4b2", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA8wAAAIQCAYAAABUo+eOAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3Xd803X+B/BXdtLddJeWLgqFFlooFChbUDaKoqfHibhwe3rqnXoq4rzT0/PUcyt4iP7cA0Flg+zZPegu3SvpSNLM7++P3vd7+Sbftkk3+H4+Hj7uSL5JvknbvL/vz3i/RQzDMCCEEEIIIYQQQgiPeLhPgBBCCCGEEEIIGYkoYSaEEEIIIYQQQgRQwkwIIYQQQgghhAighJkQQgghhBBCCBFACTMhhBBCCCGEECKAEmZCCCGEEEIIIUQAJcyEEEIIIYQQQogASpgJIYQQQgghhBABlDATQgghhBBCCCECKGEmhBAyIolEIjz99NPDfRoj3oEDByASiXDgwAHutvXr1yM6Otqlxz/99NMQiUSDc3KEEELIRY4SZkIIuQRt2bIFIpGI919wcDAWLFiAn376abhP76JWX1+Phx9+GAkJCfDw8ICnpydSU1Px3HPPQavVDvfpCdLr9Xj66ad5STUhhBBCeicd7hMghBAyeJ555hnExMSAYRjU19djy5YtWLZsGbZv344VK1YM9+lddE6dOoVly5aho6MDf/jDH5CamgoAOH36NP72t7/h0KFD2LVr1zCfJfD+++/DZrNx/9br9di0aRMAYP78+bxjn3jiCTz66KNDeXqEEELIRYMSZkIIuYQtXboUU6dO5f596623IiQkBJ999tlvKmHW6XTw9PTs13NotVqsXr0aEokE586dQ0JCAu/+559/Hu+//36/XmOgyGQyl4+VSqWQSulygBBCCBFCS7IJIeQ3xM/PDyqVyilB0ul0eOihhxAZGQmFQoFx48bhH//4BxiG4Y4pLy+HSCTCli1bnJ7Xcb8xuy+2uLgY69evh5+fH3x9fXHzzTdDr9fzHms0GvHggw8iKCgI3t7eWLVqFaqqqpxeo6KiAnfffTfGjRsHlUqFgIAAXHvttSgvL+cdxy5HP3jwIO6++24EBwcjIiIC+/fvh0gkwrfffuv03J9++ilEIhGOHTvW7Wf37rvvorq6Gq+++qpTsgwAISEheOKJJ3i3vfXWW0hMTIRCoUB4eDjuuecep2Xb8+fPR1JSEvLy8rBgwQJ4eHhg1KhReOmll5xeo6qqCldddRU8PT0RHByMBx98EEaj0ek4+z3M5eXlCAoKAgBs2rSJW6LP/ryE9jBbLBY8++yziIuLg0KhQHR0NB5//HGn14qOjsaKFStw+PBhpKWlQalUIjY2Fv/5z394x5nNZmzatAnx8fFQKpUICAjA7NmzsXv3bucPmhBCCBlBaEiZEEIuYa2trWhqagLDMGhoaMAbb7zBLSdmMQyDVatWYf/+/bj11luRkpKCX375BY888giqq6vxz3/+s8+vf9111yEmJgYvvvgizp49iw8++ADBwcH4+9//zh1z22234ZNPPsHvf/97pKenY9++fVi+fLnTc506dQpHjx7F9ddfj4iICJSXl+Ptt9/G/PnzkZeXBw8PD97xd999N4KCgvDUU09Bp9Nh/vz5iIyMxLZt27B69Wresdu2bUNcXBxmzpzZ7Xv54YcfoFKpsGbNGpfe+9NPP41NmzZh0aJFuOuuu1BYWIi3334bp06dwpEjR3izwBqNBkuWLMHVV1+N6667Dl999RX+8pe/YOLEiVi6dCkAwGAwYOHChaisrMT999+P8PBwbN26Ffv27evxPIKCgvD222/jrrvuwurVq3H11VcDACZNmtTtY2677TZ8/PHHWLNmDR566CGcOHECL774IvLz850GHIqLi7FmzRrceuutuOmmm/DRRx9h/fr1SE1NRWJiIvdZvPjii7jtttuQlpaGtrY2nD59GmfPnsXll1/u0udJCCGEDAuGEELIJWfz5s0MAKf/FAoFs2XLFt6x3333HQOAee6553i3r1mzhhGJRExxcTHDMAxTVlbGAGA2b97s9HoAmI0bN3L/3rhxIwOAueWWW3jHrV69mgkICOD+nZGRwQBg7r77bt5xv//9752eU6/XO73usWPHGADMf/7zH6f3Pnv2bMZisfCOf+yxxxiFQsFotVrutoaGBkYqlfJeS4i/vz+TnJzc4zH2zymXy5krrriCsVqt3O1vvvkmA4D56KOPuNvmzZvn9B6MRiMTGhrKXHPNNdxtr732GgOA+eKLL7jbdDodM2bMGAYAs3//fu72m266iYmKiuL+3djY6PR5stifFYv9mdx222284x5++GEGALNv3z7utqioKAYAc+jQId57VygUzEMPPcTdlpyczCxfvry7j4sQQggZsWhJNiGEXML+/e9/Y/fu3di9ezc++eQTLFiwALfddhu++eYb7pidO3dCIpHg/vvv5z32oYceAsMw/aqqfeedd/L+PWfOHDQ3N6OtrY17bQBOr/3AAw84PZdKpeL+v9lsRnNzM8aMGQM/Pz+cPXvW6fjbb78dEomEd9u6detgNBrx1Vdfcbd9/vnnsFgsvFl3IW1tbfD29u7xGNaePXtgMpnwwAMPQCz+X6i9/fbb4ePjgx07dvCO9/Ly4r2+XC5HWloaSktLudt27tyJsLAw3gy3h4cHNmzY4NI5uYr9mfzpT3/i3f7QQw8BgNO5T5gwAXPmzOH+HRQUhHHjxvHO3c/PD7m5uSgqKhrQcyWEEEIGGyXMhBByCUtLS8OiRYuwaNEirF27Fjt27MCECRNw7733wmQyAejaGxweHu6UDI4fP567v69Gjx7N+7e/vz+AriXI7HOLxWLExcXxjhs3bpzTcxkMBjz11FPcPuvAwEAEBQVBq9WitbXV6fiYmBin2xISEjBt2jRs27aNu23btm2YMWMGxowZ0+N78fHxQXt7e4/HsNjPzPF9yOVyxMbGOn2mERERTvuI/f39uc+Jfc4xY8Y4HSf0WfUH+zNx/DxCQ0Ph5+fndO6OP2PA+dyfeeYZaLVajB07FhMnTsQjjzyCrKysAT1vQgghZDBQwkwIIb8hYrEYCxYsQG1trduzfY6JGstqtXb7GMcZXhZjV0zMVffddx+ef/55XHfddfjiiy+wa9cu7N69GwEBAbwWSiz7GWl769atw8GDB1FVVYWSkhIcP36819lloCvZPn/+PDfQMJAG8nMaKN39vB25cu5z585FSUkJPvroIyQlJeGDDz7AlClT8MEHHwzIuRJCCCGDhRJmQgj5jbFYLACAjo4OAEBUVBRqamqcZk8LCgq4+4H/zQ47Vnnuzwx0VFQUbDYbSkpKeLcXFhY6HfvVV1/hpptuwiuvvII1a9bg8ssvx+zZs53OpzfXX389JBIJPvvsM2zbtg0ymQy/+93ven3cypUrYTAY8PXXX/d6LPuZOb4Pk8mEsrIy7n53REVFoaSkxCmJFvqsHLma/LKvY7PZnAZU6uvrodVq+3TuAKBWq3HzzTfjs88+w4ULFzBp0iReZXVCCCFkJKKEmRBCfkPMZjN27doFuVzOLbletmwZrFYr3nzzTd6x//znPyESibgqzT4+PggMDMShQ4d4x7311lt9Ph/2uV9//XXe7a+99prTsRKJxClZfOONN3qc4RYSGBiIpUuX4pNPPsG2bduwZMkSBAYG9vq4O++8E2FhYXjooYdw/vx5p/sbGhrw3HPPAQAWLVoEuVyO119/nXfOH374IVpbWwWrgPdm2bJlqKmp4e2/1uv1eO+993p9LFtB3JXBhWXLlgFw/hm8+uqrANCnc29ubub928vLC2PGjBFsiUUIIYSMJNRWihBCLmE//fQTN1Pc0NCATz/9FEVFRXj00Ufh4+MDoGvmdMGCBfjrX/+K8vJyJCcnY9euXfj+++/xwAMP8PYX33bbbfjb3/6G2267DVOnTsWhQ4cEk0dXpaSk4IYbbsBbb72F1tZWpKenY+/evSguLnY6dsWKFdi6dSt8fX0xYcIEHDt2DHv27EFAQIDbr7tu3TqueNazzz7r0mP8/f3x7bffYtmyZUhJScEf/vAHpKamAgDOnj2Lzz77jGtLFRQUhMceewybNm3CkiVLsGrVKhQWFuKtt97CtGnTXFoC7uj222/Hm2++iXXr1uHMmTMICwvD1q1bndppCVGpVJgwYQI+//xzjB07Fmq1GklJSUhKSnI6Njk5GTfddBPee+89aLVazJs3DydPnsTHH3+Mq666CgsWLHD73CdMmID58+cjNTUVarUap0+fxldffYV7773X7ecihBBChhIlzIQQcgl76qmnuP+vVCqRkJCAt99+G3fccQd3u1gsxg8//ICnnnoKn3/+OTZv3ozo6Gi8/PLLXGVk++drbGzEV199hS+++AJLly7FTz/9hODg4D6f40cffYSgoCBs27YN3333HS677DLs2LEDkZGRvOP+9a9/QSKRYNu2bejs7MSsWbOwZ88eLF682O3XXLlyJfz9/WGz2bBq1SqXHzd9+nTk5OTg5Zdfxo4dO7B161aIxWKMHz8ejz76KC8BfPrppxEUFIQ333wTDz74INRqNTZs2IAXXniB14PZVR4eHti7dy/uu+8+vPHGG/Dw8MDatWuxdOlSLFmypNfHf/DBB7jvvvvw4IMPwmQyYePGjYIJM3tsbGwstmzZgm+//RahoaF47LHHsHHjRrfPG+iqgv7DDz9g165dMBqNiIqKwnPPPYdHHnmkT89HCCGEDBURM5wVRQghhJBhYLFYEB4ejpUrV+LDDz8c7tMhhBBCyAhFe5gJIYT85nz33XdobGzEunXrhvtUCCGEEDKC0QwzIYSQ34wTJ04gKysLzz77LAIDA3H27NnhPiVCCCGEjGA0w0wIIeQ34+2338Zdd92F4OBg/Oc//xnu0yGEEELICEczzIQQQgghhBBCiACaYSaEEEIIIYQQQgRQwkwIIYQQQgghhAighJkQQgghhBBCCBFACTMhhBBCCCGEECKAEmZCCCGEEEIIIUQAJcyEEEIIIYQQQogASpgJIYQQQgghhBABlDATQgghhBBCCCECKGEmhBBCCCGEEEIEUMJMCCGEEEIIIYQIoISZEEIIIYQQQggRQAkzIYQQQgghhBAigBJmQgghhBBCCCFEACXMhBBCCCGEEEKIAEqYCSGEEEIIIYQQAZQwE0IIIYQQQgghAihhJoQQQgghhBBCBFDCTAghhBBCCCGECKCEmRBCCCGEEEIIEUAJMyGEEEIIIYQQIoASZkIIIYQQQgghRAAlzIQQQgghhBBCiABKmAkhhBBCCCGEEAGUMBNCCCGEEEIIIQIoYSaEEEIIIYQQQgRQwkwIIYQQQgghhAighJkQQgghhBBCCBFACTMhhBBCCCGEECKAEmZCCCGEEEIIIUQAJcyEEEIIIYQQQogASpgJIYQQQgghhBABlDATQgghhBBCCCECKGEmhBBCCCGEEEIEUMJMCCGEEEIIIYQIoISZEEIIIYQQQggRQAkzIYQQQgghhBAigBJmQgghhBBCCCFEACXMhBBCCCGEEEKIAEqYL2JPP/00RCKRy8eLRCI8/fTTbr3Gli1bIBKJcPr06V6PnT9/PubPn+/W8/9WjdTP6sKFC1AqlThy5Mhwn8pFKS8vD1KpFDk5OcN9KoQQQn4jysvLIRKJsGXLluE+FScvvfQSEhISYLPZhvtURrR33nkHo0ePhtFoHO5TIQIoYR4h2MSU/U+pVCI8PByLFy/G66+/jvb29uE+xUH1wgsv4LvvvnPpWDYw2P/n4+ODlJQUvPnmm7BarYN7spewZ555BtOnT8esWbOG+1Rcxg4cNTU1Ddhz2mw2BAUF4aWXXoLNZsOWLVuwatUqREZGwtPTE0lJSXjuuefQ2dnJe9yECROwfPlyPPXUUwN2LoSQ4bFq1Sp4eHj0GH/Xrl0LuVyO5ubmITkn9lpBqVSiurra6f758+cjKSlpSM7lUsLGEfY/sViMsLAwrFixAsePHx/u07totbW14e9//zv+8pe/QCweeSnHYPy9ZGdnQyQS4eTJk2hubsbLL7+MuXPnIigoCH5+fpgxYwY+//xzp8etX78eJpMJ77777oCeDxkYI++39zfumWeewdatW/H222/jvvvuAwA88MADmDhxIrKysnjHPvHEEzAYDC4/t8FgwBNPPDGg5ztQ3EmYWTfccAO2bt2KrVu34sUXX8SoUaNw33334dFHHx2ck7zENTY24uOPP8add9453Kcy7E6ePImmpiYsX74cer0eN998MxobG3HnnXfitddeQ1paGjZu3IilS5eCYRjeY++88058++23KCkpGaazJ4QMhLVr18JgMODbb78VvF+v1+P777/HkiVLEBAQMKTnZjQa8be//W1IX/O34O2338bWrVuxZcsW3HvvvcjJycHcuXORkZEx3Kd2Ufroo49gsVhwww03DPepDJkdO3YgODgY06ZNw7Fjx/DXv/4VarUaTzzxBJ5//nl4eHjg+uuvx8aNG3mPUyqVuOmmm/Dqq686XVeQ4Scd7hMgfEuXLsXUqVO5fz/22GPYt28fVqxYgVWrViE/Px8qlQoAIJVKIZX2/CO02WwwmUxQKpVQKpWDeu5DbcqUKfjDH/7A/fvuu+/G9OnT8emnn+Lll18exjMbWhaLBTabDXK5vF/P88knn0AqlWLlypUDdGYXr507dyIqKgqJiYkwmUw4cuQI0tPTuftvv/12REdHY+PGjdi7dy8WLVrE3bdo0SL4+/vj448/xjPPPDMcp08IGQCrVq2Ct7c3Pv30U6xbt87p/u+//x46nQ5r164d8nNLSUnB+++/j8ceewzh4eFD/vqXqjVr1iAwMJD791VXXYWkpCR8+eWXSElJGb4TG2I6nQ6enp79fp7Nmzdj1apVl9z1Z0927tyJpUuXQiQSITExEUVFRYiKiuLuv/vuu7Fo0SL8/e9/x5///Gfe53zdddfhpZdewv79+3HZZZcNx+mTbtAM80Xgsssuw5NPPomKigp88skn3O1Ce5hFIhHuvfdebNu2DYmJiVAoFPj555+5+xz3MFdXV+PWW29FeHg4FAoFYmJicNddd8FkMvGOMxqN+NOf/oSgoCB4enpi9erVaGxs7PXcjUYjNm7ciDFjxkChUCAyMhJ//vOfeXs0RCIRdDodPv74Y2451Pr16938lLqeJyQkRHAQ4a233uI+j/DwcNxzzz3QarW8Y6KjowVf13G/8YEDByASifDFF1/g+eefR0REBJRKJRYuXIji4mKnx7/33nuIi4uDSqVCWloafv31V6djTCYTnnrqKaSmpsLX1xeenp6YM2cO9u/fzzuOXY7+j3/8A6+99hri4uKgUChw8uRJeHp64o9//KPTc1dVVUEikeDFF1/s5pPr8t1332H69Onw8vLibmMHaBwvFg8fPgyJRIK//OUvPT7nSMAwDBYsWICgoCA0NDRwt5tMJkycOBFxcXHQ6XS8x+zYsQPLly8HAMjlcl6yzFq9ejWArs/Inkwmw/z58/H9998P9FshhAwhlUqFq6++Gnv37uV9d7A+/fRTeHt7Y9WqVWhpacHDDz+MiRMnwsvLCz4+Pli6dCkyMzN5j3E3fnTn8ccfh9VqdXmW+ZNPPkFqaipUKhXUajWuv/56XLhwgXdMX2Lgpk2bMGrUKHh7e2PNmjVobW2F0WjEAw88gODgYHh5eeHmm2922pe5efNmXHbZZQgODoZCocCECRPw9ttvO712dHQ0VqxYgcOHDyMtLQ1KpRKxsbH4z3/+wzuOXap+5MiRPl2rdCc0NBQAnK4rGhoacOuttyIkJARKpRLJycn4+OOPecewn9OBAwd4twvtN16/fj28vLxQXV2Nq666Cl5eXggKCsLDDz/stM1Mq9Vi/fr18PX1hZ+fH2666San6xkAyMrKwvr16xEbGwulUonQ0FDccsstTtsH2GvJvLw8/P73v4e/vz9mz56NzZs3QyQS4dy5c07P/cILL0AikQhuC2CVlZUhKyuLN6AMABs3boRYLMbevXt5t2/YsAFyudzpb2Y4NTQ0ICgoCPPnz+fN+hYXF8PT0xO/+93veMdrtVocPXqUu36IiYnhJctA17XqVVddBaPRiNLSUt59qampUKvVdP0wAtEM80XixhtvxOOPP45du3bh9ttv7/HYffv24YsvvsC9996LwMBAREdHCx5XU1ODtLQ0aLVabNiwAQkJCaiursZXX30FvV7Pm7G877774O/vj40bN6K8vByvvfYa7r33XsF9GCybzYZVq1bh8OHD2LBhA8aPH4/s7Gz885//xPnz57kl2Fu3bsVtt92GtLQ0bNiwAQAQFxfX62ei1+u5fattbW346aef8PPPP+Oxxx7jHff0009j06ZNWLRoEe666y4UFhbi7bffxqlTp3DkyBHIZLJeX0vI3/72N4jFYjz88MNobW3FSy+9hLVr1+LEiRPcMR9++CHuuOMOpKen44EHHkBpaSlWrVoFtVqNyMhI7ri2tjZ88MEHuOGGG3D77bejvb0dH374IRYvXoyTJ086jWxv3rwZnZ2d2LBhAxQKBUaPHo3Vq1fj888/x6uvvgqJRMId+9lnn4FhmB5nQcxmM06dOoW77rqLd/v48ePx7LPP4pFHHsGaNWuwatUq6HQ6rF+/HgkJCb3OoBqNRpf339uP6g8kkUiEjz76CJMmTcKdd96Jb775BkBX0M7NzcWBAwd4I7x1dXU4d+5cr++trq6u2/NOTU3F999/j7a2Nvj4+AzguyGEDKW1a9fi448/5mIqq6WlBb/88gtuuOEGqFQq5Obm4rvvvsO1116LmJgY1NfX491338W8efOQl5fnNAvsSvzoSUxMDNatW4f3338fjz76aI+zzM8//zyefPJJXHfddbjtttvQ2NiIN954A3PnzsW5c+fg5+fXp8/mxRdfhEqlwqOPPori4mK88cYbkMlkEIvF0Gg0ePrpp3H8+HFs2bIFMTExvNoOb7/9NhITE7Fq1SpIpVJs374dd999N2w2G+655x7e6xQXF2PNmjW49dZbcdNNN+Gjjz7C+vXrkZqaisTERN6xfblWsdfS0gKg6/qluroazz77LJRKJa677jruGIPBgPnz56O4uBj33nsvYmJi8OWXX2L9+vXQarWCA9eusFqtWLx4MaZPn45//OMf2LNnD1555RXExcVxsZlhGFx55ZU4fPgw7rzzTowfPx7ffvstbrrpJqfn2717N0pLS3HzzTcjNDQUubm5eO+995Cbm4vjx487Tbhce+21iI+PxwsvvACGYbBmzRrcc8892LZtGyZPnsw7dtu2bZg/fz5GjRrV7fs5evQogK7VgPaeeOIJbN++Hbfeeiuys7Ph7e2NX375Be+//z6effZZJCcn9/g5tba2wmw293gM0LXE2X4CoC+Cg4Px9ttv49prr8Ubb7yB+++/HzabDevXr4e3tzfeeust3vG//PILRCIRrrjiih6ft6frhylTplDh1ZGIISPC5s2bGQDMqVOnuj3G19eXmTx5MvfvjRs3Mo4/QgCMWCxmcnNznR4PgNm4cSP373Xr1jFisVjwNW02G++8Fi1axN3GMAzz4IMPMhKJhNFqtdxt8+bNY+bNm8f9e+vWrYxYLGZ+/fVX3nO/8847DADmyJEj3G2enp7MTTfd1O17t1dWVsYAEPzvrrvu4p1nQ0MDI5fLmSuuuIKxWq3c7W+++SYDgPnoo4+426KiogTPwfF97d+/nwHAjB8/njEajdzt//rXvxgATHZ2NsMwDGMymZjg4GAmJSWFd9x7773HAOA9p8Vi4R3DMAyj0WiYkJAQ5pZbbnF67z4+PkxDQwPv+F9++YUBwPz000+82ydNmsR7LSHFxcUMAOaNN95wus9qtTKzZ89mQkJCmKamJuaee+5hpFJpj7+rLPb3x5X/+or9O2hsbOzxuHfffZcBwHzyySfM8ePHGYlEwjzwwANOx3344YeMSqVi9Hp9j8+3aNEixsfHh9FoNE73ffrppwwA5sSJE269F0LIyGKxWJiwsDBm5syZvNvZOPbLL78wDMMwnZ2dvBjDMF3f1wqFgnnmmWe421yNH92xv1YoKSlhpFIpc//993P3z5s3j0lMTOT+XV5ezkgkEub555/nPU92djYjlUp5t7sbA5OSkhiTycTdfsMNNzAikYhZunQp7/EzZ85koqKieLcJfb8uXryYiY2N5d0WFRXFAGAOHTrE3dbQ0MAoFArmoYcecvpcXLlWEcLGEcf//Pz8mJ9//pl37GuvvcbFEpbJZGJmzpzJeHl5MW1tbbzPaf/+/bzHs3F88+bN3G033XQTA4D3u8IwDDN58mQmNTWV+/d3333HAGBeeukl7jaLxcLMmTPH6TmFPuPPPvvM6fNk3/sNN9zgdPwNN9zAhIeH8363z5496/RaQp544gkGANPe3u50X3Z2NiOXy5nbbruN0Wg0zKhRo5ipU6cyZrO5x+dkmK7fR1euKVy5pnT8e+nODTfcwHh4eDDnz59nXn75ZQYA89133zkdd+ONN/Z6vdXc3MwEBwczc+bMEbx/w4YNjEql6vWcyNCiJdkXES8vL5dm6+bNm4cJEyb0eIzNZsN3332HlStX8vZMsxxHHjds2MC7bc6cObBaraioqOj2Nb788kuMHz8eCQkJaGpq4v5j92U4Ljd214YNG7B7927s3r0bX3/9Ne655x68++67+NOf/sQds2fPHphMJjzwwAO8Co233347fHx8sGPHjj6//s0338ybhZ8zZw4AcEtsTp8+jYaGBtx5552849ilVPYkEgl3jM1mQ0tLCywWC6ZOnYqzZ886vfY111yDoKAg3m2LFi1CeHg4tm3bxt2Wk5ODrKws3l5vIewSLX9/f6f7xGIxtmzZgo6ODixduhRvvfUWHnvsMcHfG0eLFy/mfka9/TfYNmzYgMWLF+O+++7DjTfeiLi4OLzwwgtOx+3cuRMLFizgagUIeeGFF7Bnzx787W9/E5ydYT/HgazcTQgZehKJBNdffz2OHTuG8vJy7vZPP/0UISEhWLhwIQBAoVBwMcZqtaK5uRleXl4YN26c4Hd4b/HDFbGxsbjxxhvx3nvvoba2VvCYb775BjabDddddx0vDoeGhiI+Pr5fcXjdunW8FVrTp08HwzC45ZZbeMdNnz4dFy5cgMVi4W6z/35tbW1FU1MT5s2bh9LSUrS2tvIeP2HCBO7zAYCgoCCMGzdO8LPqy7WKva+//hq7d+/Grl27sHnzZowdOxbXXHMNN1sKdMWI0NBQXiErmUyG+++/Hx0dHTh48KBLryXEsejmnDlzeO9z586dkEqlvNVgEomEKxJrz/4z7uzsRFNTE2bMmAEAgr+TQgU/161bh5qaGt7vybZt26BSqXDNNdf0+F6am5shlUoFZ3mTkpKwadMmfPDBB1i8eDGamprw8ccf91qXBwBeeeUVl64p/vznP/f6XK5688034evrizVr1uDJJ5/EjTfeiCuvvJJ3jM1mw88//8wtxxZis9mwdu1aaLVavPHGG4LH+Pv7w2AwQK/XD9j5k/6jJdkXkY6ODgQHB/d6XExMTK/HNDY2oq2tzeVy+qNHj+b9m00INBpNt48pKipCfn6+U2LHEtoT5o74+Hje3pirr74aIpEIr732Gm655RZMnDiRC5Ljxo3jPVYulyM2NtblICqkt8+Efe74+HjecTKZDLGxsU7P9/HHH+OVV15BQUEBb7mR0M9T6DaxWIy1a9fi7bffhl6vh4eHB7Zt2walUolrr73WpffEdFOZMS4uDk8//TQeeeQRJCUl4cknn3Tp+cLCwhAWFubSsT0xmUzcUjlWUFAQb+m5Kz788EPExcWhqKgIR48edUqKzWYzdu/e3eN+788//xxPPPEEbr31Vqcl7Cz2c3SnTzohZGRau3Yt/vnPf+LTTz/F448/jqqqKvz666+4//77ue8gm82Gf/3rX3jrrbdQVlbG23cqVEG7LzFVyBNPPIGtW7fib3/7G/71r3853V9UVASGYZziEKuvW5IA5/fADgTbbzdib7fZbGhtbeU+iyNHjmDjxo04duyYU2LQ2trKG1R2fB2g6/MS+qz6+7nOnTuXt0x2zZo1iI+Px3333YczZ84A6Irt8fHxTm2Sxo8fz93fF0ql0ul6yfF9VlRUICwszCkJdbzGAbqWl2/atAn/93//53S95TgoAQhfV1x++eUICwvDtm3bsHDhQthsNnz22We48sor4e3t7db7c/TII4/g//7v/3Dy5Em88MILvU70sFJTU/v1un2hVqvx+uuv49prr0VISAhef/11p2NOnTqFxsbGHhPm++67Dz///DP+85//dLv0nK4fRiZKmC8SVVVVaG1txZgxY3o9tqeZsb7qLjHpLsECui4gJk6ciFdffVXwfsegOhAWLlyIN998E4cOHcLEiRPdemx3X05Wq1Xw/fflM+nOJ598gvXr1+Oqq67CI488guDgYK5Ql1B7ou5+xuvWrcPLL7+M7777DjfccAM+/fRTrFixwmlG2xF7EdPTRcWuXbsAdO19b25u5oqh9MRgMAgGZiE9Pd/Ro0exYMEC3m1lZWXd7s/vzoEDB7jiM9nZ2Zg5cybv/sOHD6OtrQ3Lli0TfPzu3buxbt06LF++HO+88063r8N+joO1L5sQMnRSU1ORkJCAzz77DI8//rhgXYgXXngBTz75JG655RY8++yzUKvVEIvFeOCBB2Cz2Zyec6DiR2xsLP7whz/gvffeE2ypaLPZIBKJ8NNPPwm+pn3iNVAxsLf3VlJSgoULFyIhIQGvvvoqIiMjIZfLsXPnTvzzn/90+rzc+awGMi4DXZ/P9OnTuYro7lSO7unzFOLuAHBvrrvuOhw9ehSPPPIIUlJS4OXlBZvNhiVLlgj+TgpdV0gkEvz+97/H+++/j7feegtHjhxBTU1Nr6vWgK7rCovFgvb2dsHkurS0FEVFRQC64rGrWlpanArTClGpVL1e+7jjl19+AdAV36uqqpxWl+3cuRPR0dHdJv6bNm3CW2+9hb/97W+48cYbu30djUYDDw+PQbmWJ31HCfNFYuvWrQC6lrgOhKCgIPj4+CAnJ2dAnk9IXFwcMjMzsXDhwl5HygZqJI1d8tXR0QEAXHXCwsJC3qyuyWRCWVkZb4ba399fsNJkRUWF4Ixwb9jXLioq4rUHMJvNKCsr440ufvXVV4iNjcU333zD+ywc+/T1JikpCZMnT8a2bdsQERGBysrKbpf92Bs9ejRUKhXKysoE73/nnXewe/duPP/883jxxRdxxx13uFTF8fPPP8fNN9/s0rn3dEGTnJzstGzblYTdXm1tLe677z5cccUVkMvlePjhh7F48WJeBcsdO3ZgwoQJgon4iRMnsHr1akydOhVffPFFj0vHysrKIBaLMXbsWLfOkRAyMq1duxZPPvkksrKy8OmnnyI+Ph7Tpk3j7v/qq6+wYMECfPjhh7zHabXaQR84e+KJJ/DJJ5/g73//u9N9cXFxYBgGMTExvX4fDXQM7M727dthNBrxww8/8GaE+7tNa7DYX1d4enoiKioKWVlZsNlsvFnmgoICAP+L/ezstuNn2p+VbVFRUdi7dy86Ojp4gx2FhYW84zQaDfbu3YtNmzbxiq2xCao71q1bh1deeQXbt2/HTz/9hKCgIJeuRRMSEgB0xcNJkybx7mMLZ/n4+OCBBx7ACy+8gDVr1uDqq6/u9Xmvvvpql5a933TTTbxK5P3x888/44MPPsCf//xnbNu2DTfddBNOnDjBuw7YsWNHt4Pt//73v/H000/jgQce6LW7SFlZGbdagYwctIf5IrBv3z48++yziImJGbB+j2KxGFdddRW2b9+O06dPO93f19FYe9dddx2qq6vx/vvvO91nMBh4rXw8PT0FA7W7tm/fDgBcMrpo0SLI5XK8/vrrvPf04YcforW1lbd0Ji4uDsePH+eNXP74449OrTdcNXXqVAQFBeGdd97hPeeWLVuc3is7smx/jidOnMCxY8fcft0bb7wRu3btwmuvvYaAgAAsXbq018fIZDJMnTpV8HehrKwMjzzyCK655ho8/vjj+Mc//oEffvjBqa2HkIHaw+zv749Fixbx/nO3r+Ptt98Om82GDz/8EO+99x6kUiluvfVW3me+c+dOweVU+fn5WL58OaKjo/Hjjz/2OvJ75swZJCYmDujoNiFk+LCx96mnnkJGRoZTLJZIJE5x88svv+yx7c5AiYuLwx/+8Ae8++67XPVd1tVXXw2JRIJNmzY5nR/DMLwWQwMdA7sjFO9aW1uxefPmAX2dgdDS0oKjR48iNDSU2xK3bNky1NXV8SpvWywWvPHGG/Dy8sK8efMAdCW3EokEhw4d4j2nY2VldyxbtgwWi4XXgstqtToNjAt9xgDw2muvuf2akyZNwqRJk/DBBx/g66+/xvXXX+/SXmN2BZfQdcWrr76Ko0eP4r333sOzzz6L9PR03HXXXS7V/RjqPcxarZbr5PLCCy/ggw8+wNmzZ3k1UOrr63H27FnB64fPP/8c999/P9auXdvtikt7Z8+eFWxlSYYXzTCPMD/99BMKCgpgsVhQX1+Pffv2Yffu3YiKisIPP/wwoM3fX3jhBezatQvz5s3j2j7V1tbiyy+/xOHDh/vcaoJ144034osvvsCdd96J/fv3Y9asWbBarSgoKMAXX3yBX375hSsclZqaij179uDVV19FeHg4YmJiMH369B6f/+zZs1xf6vb2duzduxdff/010tPTuZL+QUFBeOyxx7Bp0yYsWbIEq1atQmFhId566y1MmzaNt6zotttuw1dffYUlS5bguuuuQ0lJCT755BOXWlwJkclkeO6553DHHXfgsssuw+9+9zuUlZVh8+bNTqP1K1aswDfffIPVq1dj+fLlKCsrwzvvvIMJEyZws+Wu+v3vf48///nP+Pbbb3HXXXe5vEftyiuvxF//+ldeKyS2gItKpeIC9B133IGvv/4af/zjH7lCY90ZqD3Mrnj11Vfh4eHBu00sFuPxxx/H5s2bsWPHDmzZsgUREREAgDfeeAN/+MMf8Pbbb+Puu+9GWVkZ8vPznXqBtre3Y/HixdBoNHjkkUecCsXFxcXxlnabzWYcPHgQd9999yC9U0LIUIuJiUF6ejq3ssYxYV6xYgWeeeYZ3HzzzUhPT0d2dja2bds2oDOzPfnrX/+KrVu3orCwkNdqKS4uDs899xwee+wxlJeX46qrroK3tzfKysrw7bffYsOGDXj44YcBDHwM7A67ymflypW444470NHRgffffx/BwcHdFi8bKl999RW8vLzAMAxqamrw4YcfQqPR4J133uFWf23YsAHvvvsu1q9fjzNnziA6OhpfffUVjhw5gtdee41bfuzr68u1IxKJRIiLi8OPP/7Yr/otK1euxKxZs/Doo4+ivLwcEyZMwDfffOO09cnHxwdz587FSy+9BLPZjFGjRmHXrl3driLrzbp167jfE1eWYwNd2wWSkpKwZ88eXiG4/Px8PPnkk1i/fj1WrlwJoGsiISUlBXfffTe++OKLHp93oPcwNzY24rnnnnO6nZ2k+uMf/4jm5mbs2bMHEokES5YswW233YbnnnsOV155JZKTk7Fz504olUqnrWMnT57EunXrEBAQgIULF/KKsgJAeno67zvizJkzaGlpcSooRkaAIavHTXrk2H5HLpczoaGhzOWXX87861//4toU2OuurdQ999wj+BpwaCvFMAxTUVHBrFu3jgkKCmIUCgUTGxvL3HPPPVy7i+7aXQm1S3BsPcEwXa0W/v73vzOJiYmMQqFg/P39mdTUVGbTpk1Ma2srd1xBQQEzd+5cRqVS9doOQKitlFQqZWJjY5lHHnlEsIXBm2++ySQkJDAymYwJCQlh7rrrLsF2QK+88gozatQoRqFQMLNmzWJOnz7dbUuNL7/8UvC8HFstvPXWW0xMTAyjUCiYqVOnMocOHXJ6TpvNxrzwwgtMVFQUo1AomMmTJzM//vgjc9NNN/HacbCv8fLLL3f7+TAMwyxbtowBwBw9erTH4+zV19czUqmU2bp1K3cb2+rk66+/5h1bWVnJ+Pj4MMuWLXP5+QdLd+1AADASiYS5cOEC4+vry6xcudLpsatXr2Y8PT2Z0tJS5s0332R8fX2d2lr01MZM6Hf1p59+YgAwRUVFg/m2CSFD7N///jcDgElLS3O6r7Ozk3nooYeYsLAwRqVSMbNmzWKOHTvW7/jhqKcWlGxrIqE2OV9//TUze/ZsxtPTk/H09GQSEhKYe+65hyksLOQd158Y2N25CbX+++GHH5hJkyYxSqWSiY6OZv7+978zH330EQOAKSsr446Liopili9f7vR+HM/JnWsVIUJxxNPTk5k5cybzxRdfOB1fX1/P3HzzzUxgYCAjl8uZiRMnCv7sGhsbmWuuuYbx8PBg/P39mTvuuIPJyckRbCvl6enZ7XnZa25uZm688UbGx8eH8fX1ZW688Ubm3LlzTs9ZVVXFrF69mvHz82N8fX2Za6+9lqmpqXG6FnSlNWNtbS0jkUiYsWPHdv8hCnj11VcZLy8vrsWVxWJhpk2bxkRERDi1+mKvNz7//HO3XqM/empRtXDhQub7779nADCvvPIK73FtbW1MVFQUk5yczJhMJmbNmjWC10O9tdZ0/J35y1/+wowePZrXGo2MDCKGGYC1t4SQEWX16tXIzs5GcXGxW4+79dZbcf78efz666+DdGYj17Jly+Dl5dXr6HZvrrrqKohEInz77bcDdGaEEELI8GlqakJYWBieeuopl7tkAF1L7WNjY/HSSy/h1ltvHcQzHD4WiwUBAQF48cUX+7WyzGg0Ijo6Go8++ij++Mc/DuAZkoFAe5gJucTU1tZix44dPVZh7M7GjRtx6tQpHDlyZBDObGSbP38+HnzwwX49R35+Pn788Uc8++yzA3RWhBBCyPDasmULrFar29cVvr6++POf/4yXX35ZsDL3paClpQUPPvggVq9e3a/n2bx5M2QymWA/bDL8aIaZkEtEWVkZjhw5gg8++ACnTp1CSUmJ25WkCSGEEEKArqKzeXl5ePLJJ7FgwQJ88803w31KhAwLKvpFyCXi4MGDuPnmmzF69Gh8/PHHlCwTQgghpM+eeeYZHD16FLNmzXKpRSUhlyqaYSaEEEIIIYQQQgTQHmZCCCGEEEIIIUQAJcyEEEIIIYQQQogASpgJIYQQQgghhBABlDATQgghhBBCCCECKGEmhBBCCCGEEEIEUMJMCCGEEEIIIYQIoISZEEIIIYQQQggRQAkzIYQQQgghhBAigBJmQgghhBBCCCFEACXMhBBCCCGEEEKIAEqYCSGEEEIIIYQQAZQwE0IIIYQQQgghAihhJoQQQgghhBBCBFDCTAghhBBCCCGECKCEmRBCCCGEEEIIEUAJMyGEEEIIIYQQIoASZkIIIYQQQgghRAAlzIQQQgghhBBCiABKmAkhhBBCCCGEEAGUMBNCCCGEEEIIIQIoYSaEEEIIIYQQQgRQwkwIIYQQQgghhAighJkQQgghhBBCCBFACTMhhBBCCCGEECKAEmZCCCGEEEIIIUQAJcyEEEIIIYQQQogASpgJIYQQQgghhBABlDATQgghhBBCCCECKGEmhBBCCCGEEEIEUMJMCCGEEEIIIYQIoISZEEIIIYQQQggRQAkzIYQQQgghhBAigBJmQgghhBBCCCFEACXMhBBCCCGEEEKIAEqYCSGEEEIIIYQQAdLhPgFCBgLDMLBYLGAYBlKpFGIxjQURQgghlxKGYWCz2WCxWLhYLxKJhvu0CCGXOEqYyUXPZrPBbDajs7MTVqsVYrEYUqkUUqkUEokEEomEEmhCCCHkIsYwDMxmM4xGI0wmExfb7eM9JdCEkMEgYhiGGe6TIKQvGIaB1WqFxWKBzWaD1WqFzWYD0JVEs7/alEATQgghFy+bzQaTyQSbzcbNMItEIi7mA4BIJIJYLIZMJoNEIoFUKoVIJKIEmhDSb5Qwk4sSO9JstVoBdAVKs9kMhmF4wZFdvmX/ay4SiXgJNBtUCSGEEDJysNut2C1XYrGYGyi3H/hmGIYX79lEmY3xbLynBJoQ0heUMJOLjtVqhdlshs1m45ZfsQk0e1t37AOqfVBlA6p9UCWEEELI8GBnku0HxkUiEXcN0Fus7y6BZmegabUZIcRVlDCTi4bQSDOb2LqaMAs9p2MCLRaLnYIqJdCEEELI4GPjsv2qMfsY7ErCLPSclEATQvqKEmZyUehupJnV14TZUXcJtOMeaEqgCSGEkIFlPzAOOMd6oG8Js9DrOG7ZononhJDuUMJMRrTeRprtjxuIhNnxOQFQAk0IIYQMMjbWW61WLtYKsVgsMJvNkEgkA/ba3c1AUwJNCAEoYSYjmCsjzfbHDnTCLPQaACXQhBBCyEBx7HjRW2uowUiYhc6JCoYSQliUMJMRydWRZtZQJMxCrwmAa3NRUlKCoKAg+Pv7UwJNCCGE9EKo40Vv8XIoEmZH9gl0XV0drFYrIiIiqGAoIb8R0uE+AULsuTvSPJzY82KT4vb2dvj5+YFhGBiNRphMJgBw6gs5kt8TIYQQMhTseyuP9LjIFggDAJPJBKPRCAAwm80wmUxUMJSQSxwlzGTEcBxpdjeA6nQ6SCQSKJXKwTrFHtlX3ZRIJNyybYZh0NnZyR3DJtDsiPRIv1AghBBCBgo7MM7WJnE3BhqNRnR2dsLLy2tYY6f9DLd9vRX7BJpWmxFyaaCEmYwINpsNNTU1UKlU8PT0dCuo2Gw2FBcXo7y8HDabDZ6envDz84O/vz/8/f0hk8kG8cy7Z7+0rKcEmp15pgSaEELIpYxhGDQ3N8NsNsPPz8/teFdXV4ecnBxYrVbIZDIuzvv5+UGlUg1b7LSfgbbfrsXORlMCTcjFjRJmMqzsR5qLi4sRFRUFLy8vlx9vMBiQmZkJi8WCadOmQSqVoq2tDRqNBmVlZcjJyYGXlxcvqEqlw/Nr310CbbPZKIEmhBBySWNjfW1tLYxGI9RqtVuPLSgoQG1tLcaPHw8/Pz90dHRAo9GgtrYWhYWFkMvlXKz39/cf1tVmACiBJuQSQgkzGTZCS7DdUV9fj5ycHISEhGD8+PGw2WywWq0ICgpCUFAQgK69RhqNBhqNBkVFRejs7IS3tzeXPPv5+Q1Y4RCRSAR3auj1lECzS87EYrFTUKUEmhBCyMXCseOFWCx2K1Z2dHQgMzMTYrEY6enpUCgUMJlMXGIMdCXUra2t0Gg0qK6uRkFBAZRKJS+BlsvlA/J+3I2/PSXQjvVOKIEmZGSihJkMC/v9S2zi6GrCabVaUVhYiJqaGiQmJiIsLAxAV/BxJJfLERISgpCQEABAZ2cnNBoNtFotCgoKYDKZ4OPjwwVUHx+fIa28ac+xOiibQFutVlit1m5HpSmBJoQQMhKx+3rZ+MwOArsS6xmGQXV1NfLz8zF69GjEx8dDLBZzg+z2JBIJ1Go1N2ttsVig1Wqh0WhQUVGB3NxceHp6coPl/d2u1Z8GM44FQ+23a1HBUEJGJkqYyZDqqbeyKwmzTqdDRkYGN9Ls4eHh1usrlUqEhYUhLCyM20vMzkDX1NTAYrHA19eXS6C9vb2HrE2VI/azYV/fPoG2WCy8ImOObS0oqBJCCBku9kWwHKtguxLrLRYL8vLy0NTUhJSUFG7VmKukUikCAwMRGBgIoKuaNZtAXyzbtahgKCEjByXMZMgIjTTbE4vFgrPErOrqauTl5SEyMhJjx451enxflkmpVCqoVCqEh4eDYRjo9XpuBvrChQuw2WxOCfRwFhURSqDZnpSUQBNCCBluvXW86C1hbmtrQ0ZGBpRKJdLT0532IvclnslksmHbruUuKhhKyMhDCTMZdD2NNAsd64gdaW5sbOxxpLk/S6SArgDk6ekJT09PREREgGEY6HQ6LqhWVFQAAK8Ct31Fb3f3MPdXbwm0TqeDTqfDqFGjeH0hh2vGnBBCyKWNjfVWq7XbWN9drGQYBpWVlTh//jxiY2MRGxs7aAlgd9u1NBqN4HYtX19fLnYOdVLaW8FQq9WK6upqxMTE0Aw0IYOEEmYyqNzprSy0r8l+pHnWrFlDWvVSJBLBy8sLXl5eiIyMBMMwaG9vh0ajQXNzM0pLSyEWi7kE2mq1DmnCLHS+9gm0Xq9HfX09QkJCYDabAQgXFaEEmhBCSH/YbxfqbWBcKGE2mUzIyclBW1sbpk6dyhXz6s5AJ4LubNfq7OzscTXcYHNMoK1WKyoqKjB69GguiaaCoYQMLEqYyaBxZaTZnn0QtR9pjomJQVxc3LB/0YtEIvj4+MDHxwdRUVGw2WxcAt3Y2Ij29nYUFxdDo9Fwo9IqlWpYz1ckEnH7sthRabPZ3GNVTkqgCSGEuMqdgXHAOWHWaDTIzMyEj48P0tPTB6yadV/1tF2LHTBnGAaZmZncgPlwb9cCuvZts58tFQwlZGBRwkwGnDsjzfbYL3qz2YycnBxotVqkpqa61atxKInFYvj6+sLX1xfR0dE4c+YMt2yL7QupUCh4VTmHcobccQRfaAk3O6hhMpl4CTYl0IQQQnrDdrzoS6xnGAalpaUoLS1FfHw8oqKiRmQC57hdq6ysDK2trVCr1S5t1xpsrsR6KhhKSP9QwkwGlLsjzfZEIhH0ej2OHDkCb29vzJo1a9hHmt0hFovh4eGB8PBwAF0XElqtFlqtdtD7QvYFGzBZ9gk0u4TbMYFmR7AJIYT8dgn1VnY1NojFYlgsFpw+fRoGgwFpaWnw9fUdzNMdUGy16sjIyB63a9kPlnt4eFDBUEIuYpQwkwHTl5FmFsMw6OjoQHt7O8aNGzdiR5rdIZFIEBAQgICAAAA994VkA2t/+kIKcecz7CmBZmegxWIxJBIJr4jYxf5zIoQQ4jqbzQaLxcINjLubWLW3t6OtrQ2hoaGYPHnysLVz6g/7Wd3utmu1tLSgsbERxcXFkEqlvMHywdiu5c7khKsJNBUMJaTLxfctRUac/ow0A4DRaERWVhZ0Oh3Cw8MRHR3dp/MY6YmbUF9Idk9UaWkpdDrdgPaFHIiq4a4k0I5LuEf6z4EQQoj77GMAwzBuJ8o2mw1FRUWoqKiAUqnEpEmTLsl4Yb9dC+iaTGhra4NGoxmU7VoDEet7SqDZ90TbtchvGSXMpF8ceyu7G0CbmpqQlZUFtVqN0NBQKBSKwTrVEUcmkyE4OBjBwcEAugYO2Blox76QbFuL4eoLCfATaDZA22w2mEymbouKUAJNCCEXP8ftVu7Ger1ej8zMTFitVowbNw7V1dW/mdggkUi4OA78b7uWRqNBdXU18vPzoVKpRtR2LaEEmgqGkt8ySphJnwzESHNxcTEqKiqQkJCAiIgI5OfnD2tbpuGmUCi67QuZn5/fY1/I7gzWBYl9SwuAEmhCCLlUudvxwlFdXR1ycnIQFhaGhIQErsr0xaq/MWwwtmsNZlztqWBod/VOKIEmlxpKmInb+jvSbDAYkJmZCYvFghkzZsDb25t7nv70NhzuREyot2R/OPaFNBgMXFB17AvJtrWwD1BDeUHSUwJtNBq5UWl2cMXDw4MSaEIIGcH62vGCZbVaUVhYiJqaGiQlJSE0NBTAwMfKi53jdi2TycTF+pKSEuj1+h63aw31Z+lKwVCg6+fv6enJJdIU68nFjBJm4pb+jjTX19cjJycHISEhGD9+PO9LVywWc0k44WOTTLYKt2NfyMrKSjAMw2trMZwXJPYJtEQi4ZZ01dXVoba2FsnJyQD+V22Urc5JfSEJIWT49afjBQB0dHQgMzMTYrEY6enp8PDw4O67FBLmwTx/uVzutF1Lo9FAq9UKbtca6GKh7hJKoDs7O3Hs2DHMmjWLm22mgqHkYkYJM3EJO9Lc2NiIvLw8zJo1q88jzYmJiQgLC3M65lIIokPFsS8kW2WcDaplZWVgGAZSqRQXLlwY8r6QQufLvjYbONkkurOzkzuGTaDZZV2UQBNCyNBit9bs3bsXM2fOhKenp8uPZRiG25c7evRoxMfHOy3NpVjvHoVCgdDQUG6GXmi7FtvT2tXtWoPJfvk2uxebCoaSix0lzKRX9iPNbOVEd77YdDodMjIyBEea7fU3iHZ2dsJkMg1bv8Ph/LIXiUTw9vaGt7c3Ro8eDZvNhpKSEjQ3N6O5uRklJSW8wiNsW4vh+pzsE2j75JkSaEIIGR7swDhbm8Rms7kVky0WC/Ly8tDU1ISUlBQEBQUJHicWi/u1/cpisaCjowPe3t6/uVgPOG/XamlpQVZWFgwGg0vbtYYC+3tD9U7IpYISZtIjx97KbHLjqurqauTl5SEyMhJjx47t8Uu7PwlzTU0NcnNzYbPZIJfLoVaruWAxlJW3R8qouVgshlKphIeHByZNmgSbzca1taivr0dRUdGQ9IV0xO5hduRqAs0u3aYEmhBCBo5jb2WxWAyxWOxyTGtra0NGRgaUSiXS09N7bJPUn1jf3t6Oc+fOwWAwQCKR8LYhDecqquEiEomgVCohEomQmJjo0nYtLy+vQf+ceor1ACXQ5OJDCTMRZN9bmWEYLjFxdWSYHWlubGzscaTZXl+CqNVqRX5+Purr65GUlARvb290dHSgpaUFFy5cQF5eHjw8PODv7w+1Wu1StclLif0yaD8/P/j5+SEmJqbHvpCDOdDQXRAVOm+hBJotItbZ2cld0FECTQghfdNTxwtXYjLDMKisrMT58+cRGxuL2NjYXr+D+xLrGYZBVVUVCgoKEBUVhYiICC4xZFdRDeUg8EgZHGfZ/8y6266l0WhQVlYGkUg06AMN7sR6oPeCoZRAk+FGCTNxIjTS7E4AbWtrQ2ZmJhQKBWbNmtXjSLM9d4OoY1ERmUwGs9kMtVoNtVoNADCbzVy1ydLSUuh0Ol6xDD8/v2HtbTyYevosHftCWiwWtLa2QqPROA00sIF1IPpCuhpEHTlWYmcTaKvVCqvV2u2oNCXQhBAizH5gHHD+nu1tgNxkMiEnJwdtbW2YOnUqF096426st1gsyM3NRXNzM6ZMmQJ/f3+uzaKPjw+ioqK4VVQtLS1DOgg8EvT0WQpt12IT6MHcrtWfWA84FwxlGMYpgaaCoWQoUcJMOK70Vu6p9ZP9SHNMTAzi4uLc+gJzJ4iyS7Dtl3qzQd+eTCZDUFAQN8PNVpvUaDQoLCyE0WiEj48Pt4Tbx8enz3t9LuYva6lUyusLaTabuQS6r30hhfQ1iDoS6gsplECzwZT9X3dboBFCyKXIvuOF/XepvZ5iskajQWZmJnx8fJCenu7WgKo7sZ5dgq1UKjFr1iwoFArBaxD7VVRA1+ozdrCcHQQeiBjGnv/FSiwWCw40DPR2rYGO9QDVOyHDixJmAqD3kWZWd3uazGYzcnJyoNVqkZqays3wusOVIGq/BDs5OZlru+Aqx2qTBoMBGo0GLS0tqKqqgs1m44plqNVqt/f6jNRlWu6SyWS99oW0n6n39fXl9YXszkAFUUfdJdAWiwVms5m733EPNCXQhJDfEnd6KwvNMLPVmEtLSxEfH4+oqCi3v0NdXerNLsHuywC8RCJxGgRmB8vtYxg7WO7r63tRrzbraxwT2q7V2toKrVbbr5n6wY71ACXQZGhRwkxcGmlmsQmz/ZchO9Ls7e2NWbNm9Xnpbm9BtKOjAxkZGZBKpUhPTx+Q/UkqlQoqlYrrbazT6bigWl5eDpFIxAsUw1WBuy8GMnnvri+k/Uy9YwItdPExVAMK7iTQ9n0hh7MVByGEDCZ3eys7rigzGo1cNea0tDT4+vr26Tx6i/WOS7DZpLc/ZDKZYAxraWnhWjPZD5b3Vll6JA2OD+S5SCQS3ra2nrZrsTP1Qtd8g5UwO6KCoWSoUML8G+bOSDOLvZ/9gi4rK0NJSUmfR5odn7u7L352CXZ3fR0HgkgkgpeXF7y8vBAZGcnt9WlpaUFjYyOKi4u5pUrsqLSr+7MvNUIz9ewMtOPFh/1S96EKoo56S6Crq6vh6+sLtVrNKypCCTQh5FLAViF2NdYD/BVlTU1NyMrKQkBAACZPnuzSiqLu9BTr2WrbKpWKW4I9GOxjGMMw3GozjUbDrTYb6srSI5HQdi2tVgutVovy8nJ0dHQILnUfrgGF3gqG1tTUwGq1IiwsjBJo4hZKmH+j3B1pZrEJhMFgQF5eHvR6fb9Gmh2f23H5lztLsAf6y85+r090dDSvsnR1dTUKCgqgVCq5QDGSRpyBoRvhBf43U8/2hXS8+LBarfD19QXDMJBIJNxF23BxTKCbmpqgVCphNpt7rMpJCTQh5GLi2FvZncSAnWEuLCxEZWUlxo8fj1GjRvU7rrAJs32M6u8S7P6ej4eHBzw8PDBq1ChutVlLSwtXWZpduqxWq7nPciQZqs/KsS5Md9u1VCoVV0C2P4Mr/eW47Uqn06GzsxPBwcFUMJS4hRLm36C+jDSz2GNPnDgBtVqNWbNmDdiXoeOo82Aswe4P+0qSsbGxsFgsXKCoqKhAR0cH2tvb0dnZyY20DmegGC5CFx9s+4+qqioYDAb8+uuvI2r0nk3k2Z8XezHHJtBs0KUEmhBysejrwLj948+fPw+xWIyZM2fCy8trQM7L8RwsFgtycnKg0WgGbAl2f9ivNmMrS7e3t3OFsVpbWyESiZCXl8etOBvOCtzDmbx3t12rvr4eVqsVv/76q0vbtYZKd7GeCoaS3vz2ruZ/w/oz0gx0JdolJSUAgJiYGERHRw/oF4h9wjwUS7D7SyqV8gpjZWZmQiaTwWq1oqioCJ2dnVygUKvV8PHxuaiLivSVSPS/vpCdnZ2wWCwYNWqUU19I+xZWg9EXsieOs/FCS7jZvf5ms5k7xj6BZoMqIYQMNzbW92VgHADq6urQ0dEBtVqNKVOmDGjssv9ebW9v55Zgp6enu5x4DuV3rVgshq+vL3x9fREdHY0LFy6grq4OCoWCW22mUql49U76WoH7YscudZfL5dDr9UhJSXFpu9ZQcSXWU8FQIoQS5t+I/o40GwwGZGZmclW0w8LCBvzLgl3+lZOT06cq2MP95SUWi7kRaQDo7OzkksLc3FxYLBZeoOitqEh/Ddd+4Z6wAzWOfSHZ0fumpqZB6wvZk96WiLMB0/59sAk0OwMtFosFgyohhAwVx44X7sZ6q9WKwsJC1NTUwNPTE2FhYQM+0MueT2VlJYqKivq0BJsdXB+O71i2AnNcXByArhly+wHgnJwceHl5cYPlrnaR6I+RFmvY6w9Xt2sN1XWRK7GeCoYSIZQw/wbYzyr3ZVSsvr4eOTk5CAkJwfjx47Fnz55uezH3xNbYBCjkEPv4CN5vNBrR3t4OkUjU5yXYwxk0HF9bqVQiLCyMCxTssmSNRoPKykowDMNLCod6VnU4CCXxjqP3jn0hz58/D7lczisqMtDL8202m9tbE1xNoO2D6qX+8yWEDB/2O4iNz+5exHd0dCAzMxNisRjp6enIy8vrU6xnvwc9PT0F72cH7ktLS0fEEmx3OX6PS6VSp329jl0kfHx8eMuSBzLBGmn7qQHhWN/dXnF2Bpq9LhrM7VruTiS4mkDTdq1LHyXMlzBXeyt3x36kOTExEWFhYdzzuPsFbT55Eq1rbwSUSvj//BMko8J591dXV+P8+fOQSqVIS0u75L5s7JclR0REgGEYdHR0QKPRoLm52WlWVa1WD/ue7cHS2+9gd30h7Yut9aUvZE/Yme++sk+g2b8NoQTaMahSAk0I6S/7Abu+LsGurq5GXl4ebxuUfZVsV5lMJnz77bfo7OzEvHnzEB0dzbu/ra0N586dAwCkpaUN2L7oodbT5yKXyxESEoKQkBAA4M2q1tTUcKvN2G4b3t7el2QscKXrCrtX3PG6yHG7FjtY3t+Jhf4WHO0ugaaCoZc+SpgvUf0dadbpdMjIyOBGmj08PLj7hKpZ98ZyvgiwWgGdDrbqKi5htlqtyMvLQ0NDA2JiYtDQ0HBRf7G4enEhEomcliU7zqr2NykcqUuy3T2ngeoL2RN3Z5h7Yt/SAuAn0CaTqduqnJRAE0Lc1d/tVhaLBXl5eWhqakJKSgo3Swo492F2RWdnJ9f/tqWlhUuYGYbBhQsXUFhYiJiYGBQXF/9m9vmyy5LDw8O51WZsBe6KigoA4GZV1Wo1PDw83I4FIy129CXWC10Xsdu12Nae/d2uNZCxnj3nnhJomoG+dFDCfIlhZ5WNRiM3QtzXkebIyEiMHTvW6Q+7LzPMyjXXwNbYCLGfH6TTpgFwroLd0dGB+vr6rvdhNMLW3AxJeHhPT3vJEJpVZZcpsUmhUK/Di81ABKvu+kKyI9I6nQ5eXl7cBYgrn1V/Z5h70lsC3dOo9Ei7CCKEjBxWqxV6vb7PbXDYnsdKpRLp6elQKpW8+/syw+zj44NZs2ahtbUVSUlJAJyrYKvVahQXF3PJBdvL97eQRNivNouMjOQKn9nX8JBKpU5JYU8uliXZ7hqM7VqDGesBKhh6KaOE+RLCjmpVVlaitrYW06ZN69NIc2NjY48Ft/oywyxSKuH54APcv4WWf+n1ethsNjAWC7QrVsJaUgrPp5+Cat06t17rUiCRSASTwpaWFl6vQ/tAcbFU4B7owOBqX0j7/WOOBVgGetS5J0IJNPuf0WikBJoQ0iO240VHRwcOHjyIK664wu2CWZWVlTh//jxiY2MRGxsr+Pi+DI4DwJgxY7j/zyblQlWwGYbBqVOnkJ+fj1GjRmHRokUuPf+l9D0oEong4+MDHx8fREVFwWazcSuoamtrUVhYyK02Y5dwu7uCajgMxgq3gdiuNZSxHqCCoZcSSpgvEewfoNVq5RJad/7g2trakJmZCblcjlmzZjmNNNvrKYgyNhva77kX5nPn4POv1yCbPp13v/0SbMflX8B/kweDAdaycgCAJTvX5fcw3Pp6ceEKx6SQ7XWo0WhQUFAg2KrhUlmS7a7u+kI6FmBhZ6B9fX0HfdS5J/a1BSQSCS+BLioqgs1mQ0xMDFeZlQ2ofZlRIoRc3OyXYLN//+7EHZPJhJycHLS1tSE1NZXb6iKkt8HxvLw8ZGZmYuLEidxssv15skuwhZJyNl42NTUBAJqbm11+D+zjh8tgvrZYLObiOPC/LUgtLS2oqKhAbm4ub7WZv7//bzbW92W71nDGeqD7BLqpqQllZWVISUmhgqEjFCXMFzl2pNlisXDFDCQSicszwI77ilxp7dBTELXV1cH0yy4AgPGH7byEmV2CLZPJBJNydvmX2Nsb3m+8DvOpU1BtuN2l92EwGAa9bcNIwvY6DA0NFWzVYLPZIJPJIJfL0d7ePuCVJvtqOAK7/WcF8Auw5OfncxXkq6qqEBQUNOR9IR3ZJ9DsRTH7t8HuDWRvowSakN8Ox97KbMyz2WwurTDSaDTIzMyEj48P0tPTe52p7G0PMztYm5+fz0uY7Zdgd5eUs889c+ZMFBYWOhUH647JZBoRS5CH6hyEtiCx8aukpAQGgwEqlQpmsxktLS3w9fUdEavNhiPWu7Jdi70+lsvlI2JrG5tAs9fy7PlRwdCR57eTYVyCuiv24eq+I7PZjJycHGi12l5Hmu31NJMqDguDcv1NMJ85C+Xa33O3s0uwo6KiMGbMGMGExP55FUuXQLF0iUvnU1RUhKNHj8Lb2xuTJ09GYGBgv6smX0y6a9VQVFQEg8GAs2fP8ipN+vv796moyEAYCSPhjgVYdDodTp48CYPBgOzsbFitVm7Zl1qthpeX17Al0OzAB/v6jjPQ9gm045IuSqAJuTR011uZ/V7obYCcYRiUlpaitLQU8fHxiIqKcum7obdriZSUFGRnZyMxMZG7racl2PbYeO/v748ZM2b0ei4AoNVq8eOPPwIApkyZgpCQkBEzGDxUZDIZbwVVZ2cnqqqqUFVVxQ0A+/j48CpwD0f8GgmxXmi71tmzZwHA5e1aQ8W+uj0VDB2ZKGG+SDmONNv/sbiyx5gdafb29sasWbPc2hPT0/OLRCJ4PfUk92+LxYL8/Pxul2Abd++GbuMmyJcvg+jee/o0atvY2AgAaG9vR0VFBc6fPw+VSsUFDH9//9/U7DPbqsHb2xseHh6Ij493qjQpk8l4CXRPS/AH0kgIovZEIhH33idMmACJRAKdTufUL3sw+0L2RKgFRndLuG02G5dAswX/KIEm5OJms9lgsVi4gXH7v3/2f3uK90ajEVlZWTAYDEhLS4Ovr6/Lr93bDDO71BrofQl2R0cH9u7dC4VCgYULF/apoJhWq+U+h/LyclRXVzu1YxyqWDZSKJVKqNVqNDY2YsaMGdwKqpaWFly4cAE2m21Y4tdIi/VA13YtqVSKUaNGITg4uNvtWuzy7aGcrRdaJdJTwVCqdzL0fjtZxCWiu5Fmez0ltAzDoKysDMXFxYiPj0d0dHSfSv8zDAPz6TPo3PoJFGuugXzObKfjeluCDQCd2z6Dra4OnR9thuyuO90OoDabDR4eHvD09ERsbCwmTJjAqzDNLlliRxHVajW8vb3BMMyAL8UZzD3M/eFYaVKoUAYbdPvalslVIzGIsj8z9kKU7QvJVjDtqS/kYM/Wu7LUsrsE2mq1wmq1orOzkxJoQi4y9sWB2O9Nx79X9rbu4n1TUxOysrIQEBCAyZMnuz1wLBaLYbVauZVKfn5+vNlkltlsRm5ubo9LsCsrK6HVagEADQ0NfYqXEokEXl5e8PX1RXp6OkQiEdrb29HS0sIVyHKMZQzDDPiKs5H6vSm02swxftnvke5LWyZXjcRYD/DPq6ftWmy/bDaBZmvDDNZsvSv9oe3jvONqM0qgBx8lzBcRx97KQgEU6D5hZkea9Xo9pk+f7tZIs9DzdzzxJKznz8N86hTURw/zjnFlCTYAqG5ZD2tVFRTLl8Emk7kVQPV6PTIzM8EwDJYtWwalUgmTySRYIIvteZiTk4Pa2lpYrVaMGzcO8fHxl/SSLqH3JVQoQ6gtk32hjIGaoR+JAwo99SoXiXrvCymVSnkj+AN5AeJKEBU6Z6G+kGwCbb+siy0qwra1uFT/Dgi5mDhut+rpb1Mo3ttsNhQVFaGyshLjx4/HqFGj+vS3zSa1eXl5KC4uBgBERkbCx8eHO6a1tRWZmZm9LsGOiopCWVkZFAoFgoODcf78eZfjgdVqRX5+Purr6zF37lwEBgZyyQG7fQZwjmW1tbUwGAwIDg7G5MmTB3TGcKTFsu6qnAvFr5aWFqe2TOwgw0ANLozUhLmnmOq4XcuxNgy7Xct+tn6gEuj+xHrAebuW0Wh0ivU0WN4/lDBfBFwZabYnFEDZkWa1Wo309PR+za6yQVQ2dw6s589DNnsWd19vS7AdyefOhXpPV5Gwjo6OHoOQ1WrFwYMHodfrkZSUhJKSEoSFhSEhIaHHWXWFQoGwsDCEhYWho6MDVVVVALqWcre3t3MzsAaDAR4eHkhMTLwk+kG6GtClUikCAwMRGBgIoGufDxskioqK0NnZyRtl9fX15X0+JpMJVVVVCAkJgaenZ6/nNNK+qO0HoHoj1BeytbUVWq1WsC9kf5e7s1Xv+6OnBNpisXD3C7W1GGk/K0IudY4dL9wtwmkwGJCZmQmLxYKZM2fCy8urz+fCPndISAhyc3Ph5eXF9bl1tTUVy9PTE8uXL+f+3dsMc1ZWFkpKSpCUlISGhgZIJBJupVp3j3OMZT/88AOArqSe3d/LdkWwWCyYNGnSJbGE29VYbx+/HNsyCVWV9vf3510rssUxVSoV9xn395yGmqvXIN3VhmGvjSoqKgZ0u1ZfEmahc+4ugaaCof1HCfMI585IM8t+iZbNZkNxcTEqKiqQkJCAiIiIfv9hsEHU6/HH4HHP3RD9d7S5vb0dmZmZgkuwGaMR+n+/BZFCAdWdd0AkMMrbWwBtbGzEhQsXAABnz57FzJkzERYWBoZhUFtbC4VCAQ8PD8HHZmZmoqioCCkpKUhNTYVGo8HEiROhVCrR3t6O4uJilJaWAgDq6+sxatQot3seNjc3o729Hd7e3r0Gk5FMLpcjJCQEISEhAISXKbEtrNRqNTIyMlBdXQ1PT0+sWrWqx+ceiQlzf9pM2C9v664vpFKp5AVVd0bwByKIOuougbZYLDCbzbwE2r6txaUwiETISCXU8cLdwlx1dXXIycnhBpL7O5vKXktERETghhtu4L4HeisYWlJSgqamJkyaNIlLsIWeu6d4n5GRAYZhcPr0aUyePBljx46FWCyGVquFwWCAv7+/4OdTXV2N48ePIzQ0FGlpaSgtLcWYMWMQFBQEg8GA+vp6HD9+HEDX5xUdHc3Fele317S2tqKqqgq+vr68ntMXG/vVZnFxcU5VpXNycnhFsZqbm3HmzBkAwIoVK+Dt7d3tc4/EWA/0Paa6sl2L7RPdl+1aAzE4LnTOriTQVDDUNZQwj2DujjSz2ITWfqR5xowZPX659YSxWGDatRuS2FhIE8bxAp34v8u62QqN3S3BNu7YCcOb/wYASMePh/yyBU6v010ALSgoQF1dHcaNGwcPDw+YzWYuWQa6gvORI0cgEomwfPlywfdZVFQEs9mM4uJiLFnyv+rbzc3NaGtrQ1RUFIqKiiASiTBmzBhYLBZUVlZyo+q9LU9mR14BIDs7GwsWOL+/4TAQX3qOy5T0ej2vKBbbP9NqtaKjowOenp7dvu5IDKLu9izvSU/L3V0ZwRc6t8FOVCmBJmR4ddfxwhVisRgWiwV5eXmoqalBUlIStyezL+rr62GxWBAeHs5LxtnvqdbWVmRkZMDT01OwYKher8fhw11btEQiEdLS0gRfRyje19XVIS8vD7GxsQgNDUV9fT0mTJiAhIQEAF2r0H744QcwDIPp06cjJibG6XnLy8thMplQWVmJadOmcZ+FXq9HTU0NwsLC4OHhAb1ej+joaPj6+joVw+xteXJ5eTn0ej1Onz7tUivOoTAQ5yC0nc2+KJZGo+GObW9vh6enZ7dxYCTGemDg4v1Ab9dytTVcf8+ZCob2HSXMI1BfR5pZbJA7cuQIQkNDMX78+H79IRrefQ/6V14F5HKojx7mLQFjA3VjY2OPS7Cl48YCMhkglUIS6xzk7M/b/ovWaDTixIkTALpmmMeNG4fExERIJBJ0dnZyF/bA/5aus+rr65GZmYmoqCikpKSguLiY1yvSYDBg9+7dYBgGkyZNwqpVqyASiXgj4iaTCVqtFi0tLbzlyWxAZYtAiEQi+Pn5QavVYvTo0X3+rAfSYAQskUgET09PeHp6IiIiAgzDcKOrNpsNp0+fhlQqdSoqMpjn1F/9mWHujeMSQaER/J4GZIYiYXbUWwIN/O+Cnq06Sgk0IX3DtozpS6xn5ebmQi6XIz09vdtVVq5oamrCzz//DABYsGABb7Waq0uwFQoFvLy80NHRwfXDFSKUMJ86dQotLS2orq5GXFwcZs+eDQ8PD1itVuh0OthsNu4xbNwHumL58ePHoVQqER8fj46ODoSFhfGS+YMHD0Kr1SIwMBDLli2DwWDg9mJHRUUJLk/29PTkxTL2uzk4OBgtLS2IjIwcEfFssJY/OxbF0uv1KCkpQWdnJ0pKSnD+/HleQujt7c19HiMx1gODF++7266l0WhQV1fX63at4Yz1QM8FQ4Guaxm5XP6bTqApYR5h+jPSDHTN8rHFOdhiH/0mUJmTYRi0t7cjIyMDcrm82yrYLGliItQnjwNiMcTdzHTbf9G2tLSgvLwccXFx8Pb2Rnt7O2JiYjBx4kSIRCK0tbXhhx9+gM1mw+LFizFnzhyoVCre7HJubi6am5vR0tKC3/3ud05Lp9jPlmEYSCQSwQsNuVzO63lo37KhqqqKa9mgVqsxatQoxMfHIy4uzrXP9RIgEol4M6r2QYKtWqpQKLgAYbVaR9wX7UDOMPdGqC8kO4JfXFzs1BdyMJZpuau7BDo7Oxu+vr7cNg/HqpzDfd6EjGTshSlbm6QvF6HV1dVcUauUlJQB/5tjB7F7W4JtTyKR4KqrroLJZOp2OTbwv+uIzs5O5OfnIygoCAEBAWhpaYFarcb06dO5i/jt27ejtbUVqampWLx4MXQ6HcLDw7nnKi8vR11dHQAgJiYGixcvdno9NtllV8o4ruzpbnlyS0sLr9uGWq2Gr68v4uLiup09v1R5eHhg4sSJAOC0p7e8vBwi0f86SBiNxmE+W2FDFe/tt2sB6Ha7FjtQbjabB7yau7u6i/VVVVVoaWlBUlLSb7pgKCXMI0hPvZVdodPpkJGRwf2bTfL6S7XhdkhiYiCJjYVYrYaospIrCBUdHY24uDheoLZW18BaUQHZjOkQ2d0u7qUqt33CvH//fuh0OpSUlCAkJAQLFizgvnjYZJ0dVOjo6EBcXBw3Us+KiYlBc3MzoqKiuh0JX7p0KTca7dJn4bA8WafToaWlhfef0WgcMT0hh/pLzDFIWCwW3qh9R0cHiouL0draygWKgW7v5a7BnGHujeN+ccclcJ2dnSgqKkJQUBC3omGo+kJ2hw2ONpuNG3Fmt4+wM9COCTQbVAkhzr2V3Y337MqupqYmeHh4cMun+yswMBBLlizhlmRXV1fDZDLh6NGjgkuwzWYz6uvrERISwvsel0gkPSbLwP+S8XPnzuH8+fMAgNDQUFx22WWIjIwE8L9VY21tbQAAjUaDpKQkLolnZ1bDw8O5wdnukvl58+Zx5+oKx8HNzs5ObrC8ubkZFosFGRkZ3Gqz4e62MdSv7bin12azoaOjAy0tLWhsbIRWq+UGRUbK9RAwfPG+p+1alZWV6OjogEwmg8VicWm71lCwT4TZWP5bLhhKCfMIwC53tFgsfR5prqmpQW5uLiIjIxEXF4e9e/d2WzW6x3NhL3jt/lBFUikUS7v2/bIJkMlkwuTJk52KW9na26FdshSMTgePv/wZHndscPm17RNmDw8P6HQ6KJVKrqq31WrFzz//DI1GgwULFmDatGmwWCyC+5iAroS5u/tYPj4+vBYZ7rAPGKNHj0Z+fj5sNhtUKpVgT8ih/gIcCVUqpVIpAgICuKV5J0+ehFqthtVqRUlJCTejyn5GA9n2w1VDOcPcG8clcAcPHuSK1Qx1X8je2A/s2f/M7Kv6m0wmLniywbS8vBzx8fED1qqMkIuFux0vhLS1tSEjI4OLjZmZmX2L9f+98HX8O2QTSnalV1tbG8aOHYuYmBinc92/fz9qa2sRGhoqOKvbE3bQje2sIJFIMHPmTC4enzlzBjk5OUhOTsZll12G2tpaTJgwQfC5fH19cdVVV/X4enK5nEvE+0KpVHLdNurr61FeXo6AgADB/sZqtbrXAYOBNBJivVgs5q6noqOjuRVTKpUKNTU13PWQ/ZJkVwuqDqSREu8dt2tlZWVxyaYr27WGkn0dJXfqndTU1CAwMLDP19gjDV2xDLOBGmlubGxEcnIygoODuS9Pd79ErWXl0K6+GhCL4ff9t5A4BBd2CbbVakVERAQvWWYsFtgaGyFSKsH8dykO899RYQCwdXSg4/G/AmIJvF94DiKB5c/s+66oqIBUKkVqaipv/7Ver0dTUxOArqVoQ7Ucit0r3VsAFIlEUCqViI2NBeDcE9K+4iS7rGu4ZwuHg5+fH/e7Y98jOz8/HyaTiVeB29vbe9ATwuGcYe4NwzBcuy77gmtarZbbEsB+Xo57yAab1WoV/P3tKYHWaDSYMGECGhsbL+pK8oS4y35gHHCt44Xj49k9xDExMVyxqZ5aKnbHZrNh586daGlpwdy5cxEdHc27n12C3dLSAk9PTy6msXQ6HVQqFbeiy3H5bWZmJurr6zFt2jRutZEjkUiE9vZ2NDU1ISEhwamidllZGQCgtLQUKSkpiIiIcOs99oXFYuGWXveE/dwjIyO52VXH/sbsbPdwJofDjb0eio2N5V0PVVRUuFxQdSBxxWpHaLz38fHhBnUc23uyv5f2n9dQXT/2FOt7SqBvuOEG3H///Vi7du2QnOdgo4R5mAzUSHNmZqbTHmL7JZPuMGdmckmuJTubS5gZhkF1dTXy8/MRHR0No9HI+8JhGAatv7selnMZ8HjoT/D9v09hKSiE8urV3DGm3bth+nFH1/9ftBCKFcu5x2q1Wnh6enLnW1lZibS0NPj5+QHoqjpdUlKC1NRUJCcno7m5maua2V/Nzc2oqqpCXFycYL/K1tZW/Pzzz2AYBldccUWPe7ccOY4g2i+3te8JaZ8cDkaRrpHEsRCIfY9shmF4Lazs94gPRJ/D7oyUEWdH7HcE+7cmVHDNsS8kAO7z8vPzG9Rlgt0FUUf2CTRbibO3ft2EXErsO17YX2C6ymQyIScnB21tbU57iPuSMBuNRq67QU1NDS9htq+CnZCQwH2vsDIzM5GRkYHg4GAsWLAAlZWVvJlbg8HAbQ3Ly8vDrFmzuPt0Oh0YhoGnpyc6OztRWlqK8ePHc8WzampqcOrUKURFRSEtLQ0FBQUYP368W++tOwaDAUVFRQgODhasIm6z2fDzzz+jvb0dkydPdusaQ6i/cXfJoVqtHpRkZ6TFMMdY73g9JFRQ1T4hHIwJBfbvZKR9VoBz0S/H7VrslgCtVovCwkIYjUan1WaDlUC7E+vtv990Ol2/ihCONJQwD4OBGGm+cOECCgsLeSPN9voSRBWLr4DlD2sBiQTyhQsB8PdKsUuw8/Pz+bPXNhssuXkAAHNGBjzuuRuyKVO6EqBPtsHW0ADFlasgDg0BxBJIU6dwDy0sLMSJEyegUCi4L4Zp06ZxySu7x4lhGOTl5bm97MtRXV0dmpubER8fD7lcjoMHD3IXD5dddhnvWLbPHvs5tre395gw9/YztF9uyyaH7OxqZWUlAHAFxNzt4Xex6KlypkgkgoeHBzw8PDBq1Khu+xw6VuDu72c0UmeYexsNd9xDxu7tZ/fZlZaW9qsvZG9cDaL2dDodZDLZsBc3IWQo9LfjBdC1bzczMxPe3t5IT093mqnsS6xXqVRIS0tDQ0MD1znCfgY7Li4OMTExaGxsdHruxsZGAF2DzR4eHlxCW1tbiwsXLmDcuHEICwtDQ0MDoqKieO9j+/btYBgGsbGxMJlMiIuL43WVyMvLg1arhVarxY033tivjhPt7e0oLy9HZGQk/Pz8kJGRgfLycuTn5+Oaa67hzWayP6eOjg4AgFar7fG5e/sZSiQS3lYk+9lCNtkZyJVUI2FJtqPe4qpjQVU2IdRoNMjLy4PFYnFaPdXfOD2SZ5h7q5JtvyUAAG9yYbC3a1mtVrdXSLAD+n1tZzsSUcI8xNgqwoWFhUhOTnb7F9rVapV9CaIilQpez2zi/m1fBTs9PZ03g80wDHSv/QuGDz6E5wN/hM9b/4Zp336obr2Fe7wlKxu6pzZ2nY+vL9RHjzi9JlvMw2g0IiwsDOXl5ZBKpWhoaEBBQQHGjBmDCRMmoLS0FOPGjXPr/TgymUw4cOAAGIZBQ0MDpk+fDm9vb26kjmWz2bBv3z60tLRg9uzZSElJAcMw/dr/5Mg+OWRnCx17+LnaE7I7IzWIunrB2F2fQ/tlb/ZtGtRqdZ8SsZE6w8z+/bqalIpEIm4PWVRUVLd9Ie2XdPVnwKEvfSN769NNyKWCLUyVkZGB2NhYt1d7MAyD0tJSlJaWIj4+vtvilX1ZTQZ0ddFgk13764qpU6dyy6jZwlzV1dU4dOgQgoODMXXqVHh6ejq1VNq/fz/MZjNaW1txxRVXOL0eO7vMvp6vry+USiUMBgPOnTsHPz8/jB07Fi0tLYiKiur3xf6xY8fQ3NyMoqIizJs3j4vxHh4evOfOzs5Gbm4uJkyYgDlz5qChoWHAVrCxHGcL7QfL2ZVU9gPBl8J3pLttpewTQvvtR+yEAls8rD+f0UifYXYnnjoWoB3M7Vp97RGt0+kEV25erChhHiL2I80WiwVNTU1uBwT7kWbHapWOekqYGYaB/rV/wXbhAjwfewzioECn++2XYDtWwRaLxTCbzej87P8AvR6dn38O/927IL9sAQDAkpsLS1ERZNOmQeTtDaajA5KxY53Ow2KxQCqVwsfHB+PGjUNCQgLKy8ths9lw7NgxaLVa1NfX49prr8XUqVMB/K9nZXfVFtlkXuiLQSKRQKFQoLOzE3V1ddi9ezdWrFiBxsZGnDhxAlVVVVi0aBFEIhE3il5TU8O9NtC1d9psNnd78dLXJNUx2XGnJ2RvzzuS9Kc3o9CyN/s2Dfn5+fDw8OB9Rq4UWRuO/oeuYP9++3pujn0hrVYr2traeC2/euoL2Zu+zjBfSku0CBFi31tZo9FwFWVdZTQakZWVBYPBgLS0NPj20GGit8HxiooKlJSUICkpSbBzBrsE28vLy+m6gk3GKyoqYDKZUFVVhZkzZ2LmzJkAuhK/qqoqREREwN/fHw0NDYKD+Ozgga+vLwIDAzFz5kzeyrGioiIAwOrVq3HddddxjzMYDFAqlX2KGZ6enmhubobRaMSuXbuwbNkyhIeHIzMzE1999RVmzpyJyMhIlJWVgWEYlJeXY9KkSVwrTq1Wi8bGRkRFRQlea/VnQFqlUmHUqFFOK6mam5tRUlLCDWyyg+WufC9fSrFeaPuR42ckkUjcXm12Mc8w98Td7VruDjj0JdYDXXWHLqXtV5QwDwHH3spSqRRWq9XlLxSGYVBWVoaSkhKMGTMG0dHRvT6upyBqzc2F4Y03AQCSqCh4/PF+7j5TfT0Ky8rQqNcLVsE2HToE75f/Af3ChfB87C/o/Pg/UN1xB3e/TauF9uo1gNkM1X33wv/Xg2AMBkgcWjl0dHQgIyMDMpkMS5cuhVKphNFohF6vR3NzM8LDw6HVanntnhiGwU8//YSmpiakpaVh/PjxMBqNOH78OBQKBVJTU3v8TKuqqqBSqSCTydDe3t71/iUSmEwm6PV6AMDevXsxZcoUJCUloampCUqlEo2NjQgKCkJTUxMOHTrEPZ9joZSB5E5PSHa/j+OX7cU+w9wbxzYN7GdkX2TNy8uL9xkJDTKM1CXZ7PfFQH5ejn0h2eWPjn0heytUY7PZ+vS5sSPOI+3ijpCBINRb2d3VXk1NTcjKykJAQAAmT57c68Bob89/5MgRmM1mGAwGLF++nLvdZDKhvLwcFRUV3BJs+7/Ljo4OnDhxAgaDAfPnz0drayuCg4N5A1779u1DU1MTAgICsGzZMnR0dDgtwbRYLMjOzoZWq8W8efPg7+/P1S4Buqpysxf89kW/MjIykJmZifDwcFx++eVgGAYZGRnQaDSYNm1aj6uJtFotOjs74evri9bWVgD/Sypqa2sBdHVsaGlpwZQpU1BYWIjAwECUl5cjKioKDMNgz549MJvNaG5uxowZM3r8GfSH0Eoqx369KpWqx4HgSz3WC31G7OCvfZE1+89I6PeDXU02EuPPQA7c97Rdq7m52e3tWmyVbHfYbDaaYSbusR9pdmzB4soXCjvSrNfrex1ptie0TMt04CAsBQVQrL4K4tGjYauvh2zm/wJB6/79MN1+B4KVSsTt/BEeAlVsda+8ClluHrzLyqHMyYLyv60cGJ0O1ooKiEaNAiQSwGyGSC6H2McHcCgpz7bAioqKwpgxY7g/xFOnTqG9vR0HDx7EDTfcgEmTJvEu2G02G1eopL6+HuPHj0dpaSnKy8sBdCVM7NI3pVKJtrY2eHp6QiqVoqysDMePH+eea/r06dzyqPDwcERFRaGyshJ6vR65ublYsmQJcnJykJ2djezsbMyZM4c3UiY0c9mfoGWxWLgWS0K/Ez31hGT3r9jvfx6pX1IDGUQdOX5GJpOJW/YmVCSDHWQYyUuy+7Ln0VWO++yEqpiyqxrYwMr+3rPJfF9mmC+lEWdCWI4D4/bxnr2tJzabDUVFRaisrMT48eMxatQol/722WXT9lpbW1FWVoaYmBiMHj0aJSUlvC1FOp0O3377LaxWK6ZNm+ZUBRsAioqKuJVWALB06VLufba0tPCKMkkkEq6tkD22BZZKpeLNXpeVlaG6uhrV1dWIiIjA9ddfD6lUyrsor6urAwA0NDRwz5WVlQWga+Zq8uTJkMvl8PX1hV6vh0gkgkqlQnt7O1eoEwCSkpIQFhbGnVtycjIKCgpgNBqRl5eHa665BkqlErt37+ZeJyEhAVKpFGazudtY39d4zzAM2tra4OXlJfj9aV+nw766dEtLC6/bhv1A8Eg0mEk8m+z5+fk5FVljV+R5eHhwn5Gfnx9kMtmIjfVA35JSV7m7XYtd1cB+Vn1dTQaA9jCT3gmNNLO/fOwfRW8jSk1NTcjOzoa/vz/Xi9hVjqPO1vp6tN16G8AwYNrb4b9vT1dSq1BwS7Cbdu1ChM0GiV4PWWMT8N+CG9bqGhg2b4Z87hwor7kaHYXnoVv4vwJZDMNAe+VqWEtLobrnbvj/uB2WslLI58/nnZPVakVBQQHq6uqQkpKCoKAgbj+xh4cHN7osl8shEom4EcKcnBzk5OQgJSUFc+fORU1NDRITE1FZWQmVSgWpVAqLxcLt95LJZIiPj0deXh68vb2xbNkybpQZACIjI7kLhLa2NhQUFCA6Ohqenp4oKirCmDFjAPCT4l9//RUSiQShoaEICAjAqVOnoNFouIIpBQUFOHfuHAIDA7nHu+LcuXMoLi6GRCKB0WhEcnJyt70m7Qnt92GTQ7Y4lkQigaenJwwGw5D2hOzJYCbMjuRyOa+nsVCRDPukeSjPzRVDvVTcsYop2wZKq9U69YW0753qjo6OjhE7mENIX7GxXmiQy5UZZoPBgMzMTFgsFsycOdOtvxGh5z9w4AC0Wi0qKyuxatUqzJw5k/tb1Wq1OHXqFJfEs62h2PeRk5MDmUyGiIgI5OfnAwAvKTt16hTy8/OhVquxePFi1NTU8FaCAfxtXfaFSVtbW2GxWHhLjBUKBZdI19XV4ddff0VQUBCmTZvGbQtrbGyEXq+Hv78/N0u2Z88eAEBKSgoyMjIgFouxdOlS6PV6LllTqVQYN24c5HI5t09bqVRi+vTpOHHiBEJDQyGTyXiz+Lm5udysbnJyMkpKStDW1oa5c+dCIpGgqakJBw4cgFgsxpQpU1y+LquqquJWw3V0dCAoKAiLFi3q9XHdddtoaWnhum2oVCpYLBa0tbUNaWvBngxlPHUc/LVfbVZSUsJNRrB/V31dYjyYhjLeu7tdy2w29zlhvpTiPSXMg6C7kWYW+4tntVoFl1vZbDYUFxejoqICCQkJiIiIcPuLxzGIijw8IPLxAdPaCnF4OERiMaBQwFRZiZbrbwBEIkS8/RZU6gCIAwIgnTKZe6zuhRdh+ukndH7yCQKys1A/dy60Gk3Xe7VaAYaBtaam6z1VVEASGwNJbAzvfPR6PTIyMiASiZCens4lcOfPn8fx48chlUqxevVq1NfXIygoCP/3f/+HxMREJCcnIy8vD0ajEfn5+Vi9ejWio6ORn5+PkydPAuga+WaXTwHgllEBXX+0TU1NaG9vR2RkJHx8fLhl3wEBAThz5gzq6upQXl6Oa6+9FsnJydzP0GQycUux2QGQuro6GI1GGAwG5OfncwkzW+W6ubmZ25vtiuLiYl7FdDaxb2trQ3NzMyIjI3t9Lvv9K/Y9IQsLC6HT6bggbb8narh6Qg7n0jHHIhnsHp/q6moYDAb8+uuv3EyqWq0e9irlw723WiaT8aqYGo1G7iKEXdVx5swZbgTflVYper2e9jCTS4ZjxwuhFSG9Jcx1dXXIyclBWFgYEhIS3L4wZWuK2PP09IRWq+UuViUSCWw2G3bs2MEN9I4ePRptbW28AdqSkhKuJdQVV1yBlStXcvGZ/T5iC3W2t7dDLpc7bU2yWq3Izc3lddYAumLb999/D4ZhsHDhQowdOxZisRi7d++Gn58fFi1ahNLSUuj1elRUVGDatGmYPXs2tFotvv/+ewBAWloaysrKeDPf9fX1AMDtF6+trUVYWBh8fX1hNBpRVVWF2NhYlJSUoKCgAACwaNEiXH311dxztLe3Izg4GDqdDjqdjquY3dzcjI6ODm7/bGBgIOrq6mC1WmG1WtHQ0MDtee5NeXk5zGYz97NiP0d2b3hISIhLq28cu22wn1dTUxP3s7MvhDkQnST6Yji3OjmuNmMHGerr62Gz2XDo0CFeQayBrCjdV30trDUQetuu1dnZiYKCAgQEBLjcV1yv10Mmk11S/ccpYR5g9rPK3e2VYG8TCqL2I80zZszo83IGxyAt9vaG/55dsNXXQ/Lfypjt7e0o27oV4XX1kALwrqqG4pGHAQCMyQTjL7sgSRgH6YTxMP30EySxcYBUyhXWan9qI4zbPoXHIw/Dd8tmmI4cgShAjbb7/wiPu++GNKGrqnV9fT2ys7MxatQojBs3jvfFxPZltVgsYBgGSqUSlZWVMJvNyMrKglQqRVhYGJqamhAfH4/S0lJuSQnr5MmTSExM5PYoi0QitLe3Q6lUIjg4GCdPnkR7ezukUikaGxvR2dmJ+vp6zJo1iwuAarUaZrOZ++M+evQolwSPHj0aCoUCjY2NCAsLQ0BAADIzMxEXF8edQ0pKCvbt2weGYXDixAmkpaV1O/LM7lGLiIjA5MmTUVJSgvDwcFitVowdOxZWqxW7du2C2WxGS0sLUlNT3f7Z+/r6wsvLCyqVCqNHjx7ynpDdGSmzuPZ7fCwWCwwGAyIiItDS0oKmpiZe4RX7oiJDabgTZkds67eQkBC0t7fj3LlzGDVqFDQaDQoKCmAymXrtC0kzzORSwfZW7q04X3dLsq1WKwoLC1FTU4OkpCTB3sCuEErIFyxYgJaWFl59h7Nnz6KlpQVAV9ydMuV/7R1ra2vBMAz8/Py4ZeReXl7ccu/y8nIcOnQIISEhmDVrFoqKiuDt7Y2DBw8iKiqKS5rta5PYd9YAuhJDdsDUaDTC09MT9fX1MBgMMBgMOHz4MDw9PeHj44OQkBDU1NQgPDyc977OnTuHqVOnQiQSQalUwmazwWq1QqFQwNvbG5WVlaiqquI+l+rqaq6ol7+/P0QiEXcRz8aiyspKHDnS1cHDy8sLiYmJqK+vh1wux4QJE7h9mGwyERcXx/UNPn78OJYuXdrtIKDRaMTJkychl8sxduxY6PV6BAYGQiQSISIiAgBw/PhxVFdXw8vLCytXrnTrZ88OlqvVahgMBkyZMoXrJGHfbYMdKO9Lt42+Gkn7qtlBBnbJ/pQpU7jVZvYVpe23tA31dcpIiveOM/aHDh3C6NGj0dnZ2et2Ldal2BGDEuYB4k5vZbaxt2MQra+vR05ODkJCQjB+/Ph+JTFCQVQc0DV7zPZxLigoQMySpZCVlkMkl0E+by53rP71N2B4621AqYT6xDEoViyHODSUO3ebzQbTjzsAhoFxx0543HkHpJNT0DwhCbBawRgM8H73HZw/fx5VVVVIio1FsL+/0xdCUlISFAoFfH19uT+umJgY5OXlwWq14vTp0wDAVbe0WCyora3FtGnTcO7cOVitVq4S5uWXXw65XI7Gxkbs27cPQFcLCYPBwI2Gy2QydHZ2Qq/XY8+ePbjyyisRHR2NgwcP4uuvv0Z6ejqioqJ4I9gxMTFOgduxxVRwcDC35+nChQu4cOECPD09MW3aNFRVVUGr1SItLQ0+Pj7Izc1FfX096uvr8bvf/Y5bws3ubZLJZNzvjv3vEMMw3FLwGTNmuLx3aah7QvZkpCTM9thAxe7xiY6O5hVeYZcoKRQK3oXHYI+cDueIc2/YJW322wLs+2jaL3n3/+/ffUhISJ+LgBw6dAgvv/wyzpw5g9raWnz77be46r/1E7pz4MAB/OlPf0Jubi4iIyPxxBNPYP369bxj/v3vf+Pll19GXV0dkpOT8cYbbyAtLc3t8yO/HQzD8JLl3uoMCMXijo4OZGZmQiwWIz09vV+rLoSeXyKRcLNrWq2Wq4KdkJCA5uZmXtukuro67Nq1C0DXzOu1114LsVgMhUIBvV4Pm82GCxcugGEY1NXVQS6XY/Lkydi1axdqa2tRWVmJqKgobqY8MjISERERTpWdg4KCsGDBAphMJsTGxiInJwcBAQHQaDQwGAwoKysD0LUEWafTcUn5lVdeiaCgIDQ2NsJsNuPEiRNYuHAhAgMDYTab8d1338FisUCtVnPfyY7XVydPnsTMmTOxevVqZGRkYOfOnYiNjcX06dO5vdIAEBYWhkmTJvHOe8mSJbx/q1QqqNVq1NTUwGQy4fvvv4dSqURCQgKUSiXOnz+P8ePHY/To0aioqOAS+MjISF67rY6ODphMJsFYDwClpaUoKCjAhAkTXCowyl5z2sexnrptsIPlrq6Gc9dIjvVsS0+2Sjm72ozdJy4SiXiD5YO92qyvRTSHis1mg1qt5lZA9LZdS6lUcgmzu0ZyrKeEeQC4OtJsj10ixT6+oKCA25vruB+oL7pbBmaxWJCbm4vm5mZMmTKlK4n68H2hJ+j6X5EIEIkgiYoCABh/3AHF66/D8/LL4fXsJnR++TVUG27vOlYqhWzmDJiPHIVo5kycPHkSVqsVM2JiYVx9DVr0evh+9imkqVPQ0dEBDw8PSCQSXvA2GAyorKzkEgWZTAaz2cy7KGELFMyZMwcHDx7kCnBI/zv7bR8AQkNDMXnyZHR2dnJfiiUlJdxIe1lZGXx9fbmq2adOnUJrayvS0tJQXFwMDw8PtLW1ITQ0lPtMc3JyYDabkZyczL2WyWSCn58fOjs7uefq6OhAbm4uV7TkxIkTiIuLw+jRo1FXV4eQkBB0dHRwxUhOnjyJ0tJShIaGYvHixdBoNLxEvb29HSUlJdxn0NvMc3cBazh7Qo7EICoUqOwLrwA9F8QarAuPwSwC0l+Oe8DYgjtCfSE1Gg1ee+01bN++HX5+foiOjsaZM2eQkpLi8oCATqdDcnIybrnlFt5Syu6UlZVh+fLluPPOO7Ft2zbs3bsXt912G8LCwrB48WIAwOeff44//elPeOeddzB9+nS89tprWLx4MQoLCwXb7xDS23YrIY6xuLq6Gnl5eRg9ejTi4+P7/TfeXaxnGAYVFRVcXY7uumvY38b+HQNdifbhw4e5gqMmkwmhoaFcUjpq1CjU1tYiPDwc+fn5qKmpwaRJk3DmzBmcOHECkydPxqRJk2AwGLgEfPR/66IAXd+p7MA4WzTMMda3t7fjhx9+wIIFC7Br1y4YDAbeZAQ7G84Ozk2ePBlTpkyBXq9Ha2sr5HI5t1KstrYWSqWSi8fl5eUwGAxISUnhinvJ5XJezY/y8nLU1tYiMTGRi9MMw3AVvQ0GA4CuGfusrCwoFAoYDAacOXMGbW1tCAsLg0Kh4K5NHGe15XI5lixZgqioKG6Ag8W2FcvOzu41Ye5uNleo2wb7nczOkrOrgtRq9YAuTb5YYr1jRWmhglgymazP7Rdd0d8WkoOJHSC0j9U9bdf6/vvv8dhjj2HUqFHQ6XTYs2cPZs2a5fKg4EiO9SJmJK2buMi4O9Jsb//+/Zg8eTJkMhkyMzMBdC3rHaj9fWfPnoVareZ90bLLKJVKJZKTk3tcmsOYzTDt2QvJuLGQ2lXQbFl0OWylZbD4+yH0zGnnxzEMmquqkHn+PDdTbjt9Gq03rAUAKDc+haNhoaitreUq9vn4+HCzrN9//z3XbmLFihVQKBT4+eef0dnZifT0dBw/fhxmsxk+Pj7w8vKCt7c3CgsLAXQlx2PHjuWWZbe0tCAkJMRpRoudYbfZbOjs7ERzczMaGxthMpm4C6HrrrsODQ0NOHDgAABgwoQJSExMRGNjI3fbtGnTuPPOyspCbm4uACA+Ph5NTU3Q6/WYNm0aioqK0NTUxD33FVdcAbFYjF9++QUMw2DRokUICgrCrl270NzcDJVKxRtRa2xsRFlZGWJjY5GbmwuNRoPZs2c7tfxyxCZ17rS/su932NLSAq1W26eekN3Zt28fZs6cOWKKkAFd++hFIhHi4+NdfozJZOICBDtD4u3tzavA3d/Z4bq6OlRXV7u9JH8oNDQ0cPsMXcGuFnnkkUfQ0dGBxsZGiEQizJs3D/fee69LxW9YIpGo11Hnv/zlL9ixYwdycnK4266//npotVr8/PPPALoq5U+bNg1vvtnVYs9msyEyMhL33XcfHn30UZfPh/w2sLGeHchyNdZnZ2dDpVIhOjoaeXl5aGxsxKRJk5wSpL6qrKxEY2Mj73vCbDYjOzsbbW1tSE5O5gb+ulNXVweGYXiD9SdPnuSKfq1atUrwOdra2pCdnQ2RSISUlBQolUps27YNNpsNERER3PYlkUiE5ORkMAyDpKQkSKVS3vOnpqZi/PjxOHDgAKqqqpCcnIy6ujpuf3JERAT8/Py4v2cvLy9uwM3X1xd1dXVcj2dHTU1NXG2Q5uZm1NfXw2g0cnuJ58yZg9DQUHz99dew2WwICwtDWloaFAoFvvzySzAMg4iICMyZMwdA13ff3r17AQCxsbHQ6XTQarWIjY2FVCrlBgEAYNKkSRg/fjy2b98OvV6PpKQkTJw4EdnZ2dx7WbFiBbf1Tq/XIy8vD4GBgdDr9VydlHHjxvX486utrUVtbS1vmb0rOjs7ucFyjUYDq9XKazXUn6XJGRkZCAoKcnmP91Bgt1tNnz7d5cfYz9JrNBpuu5/9YHl/V5uZTCYcPnwY8+bNG3GryiwWCw4dOoQ5c+a4XOCupKQE//jHP/DTTz/By8sLtbW1mDFjBq699lrcd999Lr/2SIv1NMPcR30ZabYnFotRX1+PyspKREZGcgUw+qrj+Rdg+nEHPDc9DcUVl/NaTTAMg6qqqq4l2HYVK3siksmgWLrE6XbV2rXo+OdraL3sMqj3H4A0JRni/wZShmFQXFyM8vJyTJgwgfuiFKelwePRv4DRaFCbNg21/y3WxQZboKvqc2hoKHx8fLhiDexyLbbaXmNjI+bOnYvMzExIpVKkpqbC09MTDQ0N0Gg0qKur45ZXJSUlIScnBxKJBCtXruQlaCKRiBvpNhqNKC4uhsFggEQigVQqhUKhwKFDh7jEm2EY5OXloampCTNnzuSqcrPVtaVSKfz8/AB0LSdLTk7mfbFERkaipqYGBw8ehFQqhUqlQmtrK/fz2b9/P2QyGQICAjBmzBjo9XpkZWVh4sSJEIlEOHz4MDo7O1FZWYnVq1e7/IXKzjA0NTU5nVO3P/cB6AnZ0/mwrzGSMAzjdpCSy+W8EVb75chs5VIfHx9ukKEvy9xH0p4mR+5WGZVIJJg+fTrGjBmDSZMm4fHHH8e5c+ewf//+QXmPx44dc0rCFy9ejAceeABA1wXKmTNn8Nhjj3H3i8ViLFq0CMeOHRvw8yEXL7bgo8Vi6VOrN7FYDIPBgKNHj0KpVGLWrFn9GnSsqKjAiRMnEBsbi6lTpzrNMLNLsL29vZGenu7SxbzQ/umYmBiUlZXBZrOho6ODq43BamhoQHZ2NlesjP07nj9/PqqqqhAXF4effvoJALgeykBXzJ02bRpUKhXXBnLcuHGQSCTcVqjy8nLMnz8fp0+fhl6vR1xcHKKiotDZ2YmSkhJ0dHTg8OHDAICEhAScP38eNpsNs2fPdtouxVaYZpeUd3R0AAA3YVBQUICqqirIZDIYjUbU1tZix44dWLlyJfz9/dHS0oLa2lpuT7inpye3Lz0mJsZphmrMmDH48ccfuRjADswDQGFhIQoLC+Hn54cxY8bAaDQiNzeXG2zIyclBSUkJioqKcMUVV7jUMYPV1taGo0ePIjEx0eXtWkqlEuHh4U6FMNmlyexKKzaOuTPQfbHMMPfGfpYe4K82Ky8v5+pysNdDfVltNpJnmNlzcyfex8XFYdasWaisrMTBgwdRVlaG/fv3OxUnHAhDGespYe6Dvo40sywWC8xmMyorK5GcnNzv5X+M1YrOjzYDDIPOTz/jEmabzSa4BJthGDBGI0R9KP6gunk92pYthexPD6Pt1tsgHjsW6p93cv2iDQaDU7EykUgEj/8u2/ZvbuaS+fj4eJw/fx4AuIJZCoUCcXFxOHbsGFeYKykpidtzXVZWhujoaEyePBlWqxV79uyBRqOBXC7ntcdgAxR7ocNqaWlBTk4OIiIiEBsbi/Pnz3NLqMViMa655hpoNBrs2rULDMNg1KhRqK+v51o2dHR0YMyYMSgoKEB7ezsOHDiAwMBAhIeHIzExEW1tbdDr9U4BKzw8HCtXroRUKoVSqYTVasXo0aOh0+nQ3NwMq9WK6upqjB49GjU1Naj5b9XxqKgoKBQKdHZ2wmw2o76+3mk/dXfa29u552EDNIv9THr7Yu9LT8juvlhHasI8EL0ZHdt82S9zr6ys5ArqsBcfrixzH8kJc1/3V+v1eu6Cc+rUqZg6deognB24LQ/2QkJC0NbWxrUXs1qtgsewlXQJ6e/AOLtiR6vVIi4uzqXB6t4UFBTAYDAgLy8PqampvLZ4Qkuw+9pCJygoCNdccw22b9+Offv2QSQS4eqrr4aHhwfXL5rtcWwvMjISkZGRsFqt8PT0hE6nQ2RkJGpra7mB5qKiIgBdM7T5+fkoLy/H8uXLMWPGDOTk5KClpQXbt29HaGgo5syZAx8fHxw/fhzFxcW8pdBA1wUxe1HPxn329jNnzkChUCAlJQXNzc3c8mwAuOyyy+Dl5YUdO3agsbERoaGhaG9vh06ng8Vi4bbI/frrr7BarTh+/DiCg4MREBCA2bNnIycnh3dtwVIqlVi5ciVMJhO8vb1hsVgwZswYtLW1cQP6jY2NkMlkXHy22WyIjY3lJaRlZWVc3ZHeWK1W1NbWcv+fnQ1nn9tisfQ6cCK0NNmx1RBbx8OVmdWRmDAPRKx3bPNlXxOGXeZuf00kVPxS6Lz6kksMBavV2mNNpu7odDruOic2Nlaw1/tAGMpYTwmzG/o70gx0jQJmZmaCYRgkJCQMyF45kUQC1X33wrRjJ1S3rAcgPKqtUCjA2Gxo/f0fYDl9Gl7/eAnKXjbTC76eSASxXo/MVStRlZKMCadOoaOjA/7+/piQmwfLBx/C/NBDkCVPcnpsQEAArrvuOjAMgzNnzsDLywsdHR286pk1NTVcZc7Zs2cjNTWVW5plNBq5QmHffvst15rBz88P6enpaGxshFgsRlhYGPz8/Lhl26ysrCzU1taipqYG0dHRXECSyWRIS0vjWjGx59PW1oYrrrgCRUVFUCgUKCsrg1arhVKphNFoRGNjIxobG5Gfn4+AgAA0NzejtrYWV199tdOXJLs03GKx4JdffuFGoAMDA9HS0gKpVIrIyEhUVVVBJBIhNzcXhYWFWLhwIfbt28dVOmX3U3eH3XvD9pdkGIYXeNva2vDLL78A6BqJY/dmucKVnpCOBcQc/0ZGWlAY6GIbIpGIKyoSERHBW+Zu3yfbsQK34+cykhPmvu6vZoMoISNdT72VXWEymZCTk4O2tjYEBQXxBiz7IzExEXq9HrGxsVwRTovFgnPnzqGtrQ1Tp07llk9nZWXh3LlziIuLw+zZs91+LceVaocOHYJarYbFYkF8fDyys7PR0dEhuJ1FIpFg9erVMBqNuHDhAtra2ril0ewARHNzM9dqSavVIjo6Gq2trWhubuaWQvv7++PkyZPc4LrBYMDKlSthMBi4pdAREREwGAy8i/KysjKu/V14eDh8fX25fswTJkxAW1sbqqqqoNfrAXTNmC9ZsgQVFRVgGIabRVSpVDCbzWhtbUVrayuKioowevRoNDc34+DBg9yWKnsKhYKbwT5w4AA3cx4REYGGhgaYTCZERkaitbWVawtVUVGBBQsWwM/PD1qtFiUlJYiPj+9xtpitWiwWi7mBBPvVAjabDb/88gu0Wi2mT5/uVtIiFou5doExMTGwWCxobW1FS0sLb2aVTQyFum1c6rEeEK4J013xS7VazVWft3cxxPq+JsyXEkqYXTQQI80XLlxAYWEhoqOj0dTUNKB7FTwf+CM8H/gj91pswR3HUW1Gp4Plv0ui9a+/CcXy5RDJZF19h3/cAcZkgmL1VV19mrshNplgiI5C7aSJgEiEoqIizJo1C5GhoWi55lqAYaBXKuH73rsAuvZT/fLLLzAYDLjiiivg6+vLFVMAuoJIVFQUqqurodPpEBsbiwsXLiAmJgY2mw3nz5+HWCzmRtKPHj2Kyy+/nAvkKpUK06ZNg4+PD7esqbCwEFOmTHHad2VfqEQsFiM8PBxXX301jh8/zrWWAABvb2+0t7ejvb0dKpWKmwnT6XTYuXMnLBYLlEolN6ItEom40WaJRML73SgrK0Nubi7GjRuH+Ph4VFdXc0tTRCIRLr/8cm6E3Gg0YsWKFdzSLZFIBF9fX0RFRaG4uBjt7e1oa2tDaWkpgoKCoFarUVRUhFGjRiEoKIibdbdYLPD398e0adMQERHBm0nWarXcuWo0Gl4xk5KSEojFYsTExLj0+y3UE5INFuxovv2+XvY9jySDHayElrmzI/f19fU4f/485HI5b+mbQqHo88zQUOjruel0uj63ynNHaGgoN8jGqq+vh4+PD1QqFSQSCSQSieAxfW3vQy4N9h0v2Atsd7+zNBoNMjMzub95+9VP/RUREcG1JAK6LtA7OjqgVCqdlmBXVFQA6Kq4nJKSwg3aNjY2oqGhAfHx8T3OErIzS2wy1tjYiPDwcCQlJWHPnj1ctwf7hPn48eMoLS3FjBkzEBsbCw8PD5w+fRoWiwU+Pj6YMGECWlpa0NraipCQEHh7e8PDwwOBgYGora1FXV0d93pnz55FXFwcb3XSjBkzuDaQRqMR+/btw5gxY5wGJNjOFXK5HH5+flAqlbjyyitRXFyMc+fOccexA93s9zJbJdtms2H37t0wGAxQKpW82WSj0cj9f/vYodVqcezYMfj5+WHGjBkwmUxcssyeOzuIbbVaERQUhLa2Nhw6dAhA17VDUlISDh8+DJvNhpaWFlRXV4NhGIwdOxbnz5/nlrIDXYVEa2pqIJfLERsbi6SkJN4WKXZFGNA1IGCfMNfW1kKj0SA+Pt6lbVVSqVSw20ZLS4tgt42BmM0daENxTj0Vv2Sviez3iXt6eo74hLmvsX4oWkgOZaynhNkF/R1pNpvNyMnJgVar5ZZFa7VawcqWvbEUF8N8+AgUK1dALLBch12C3draiuDgYKcgIvb2hnzpEph++hm28nKYT5yEfPYsmI8eQ/sfH+g6SCqF8spV3Z/El18h6PsfMLG0FOevuRpTpk9HVFQUGIaBfPEVMO3ZC4VdK4bq6mo0NzcD6CpElZ6eDn9/fwQGBqKjowMpKSnc/l022CQkJKCzsxOnTp2C2WzGnDlzsGvXLrS1taG2thYHDhzA4sWLUVNTgwsXLuDXX3/F3LlzIZPJuM3/BQUFmDlzJnceBoMBRUVF8PHx4S0FVSgU0Gg0vLeYmpqK0tJSyOVy5ObmIiEhASqVCidPnuQCZ0REBFecxGg0oqGhgesPmZ+fzyU/ubm5aG9vR2ZmJhd82R6SCQkJ3BdSY2Mj9u7dC5FIhIULFyIoKAj+/v6QSCSIioqCTqfD6NGjUVRUhOLiYhQWFiIkJIRLuhYuXAhvb2/IZDJYLBau8igboE+fPo36+npMnToV48eP50bwWRcuXMCpU6cAdH3pu1utne0J6enpyc2s2veEZJfhnT9/HgEBAUPaE7InQ710zHHk3mq1crMZbOsPDw8PiMVirkq8q/vEh0p/guhQjDrPnDkTO3fu5N22e/du7vtALpcjNTUVe/fu5QqK2Gw27N27F/fee++gnx8Zmdjlq/0ZGC8tLUVpaSni4+MRFRXFVWN2l8lkQklJCUJCQrj9k46vVV5ejqKiIshkMkyZMsXpXCdMmIDDhw+DYRgUFBRg6tSp3Aonq9WKlpYW3vJdRxqNhlvFJZFIEBcXh+TkZIhEIkRHR6OhoQExMTG8c2KLcJ49e5ZL0NhkLzExEWPHjgXQFQdMJhPmz58Pm82GwsJCVFdXY/LkySgvL0d+fj4sFgu+++47rFixAoGBgdBqtcjKyuJePysrC62trWhra3M6j7y8PEgkEkybNo3bMy6VSrn3wxo1ahSXgNfX10OlUiEwMBDFxcVcNw2RSIRrr72WK4Sp0+lgMpkgFotx4cIF6HQ6qNVqlJaWQqvVQqvVQiKRwN/fH0FBQWhubkZ8fDyXsFksFmzfvh1GoxHJyclYuHAhRCIRgoKC0NnZidGjR3MxgC0K297ezrXekkgkCA4O5gY72CrcbJwoKytDdnY2xo4di+nTp6OhoQFJSUncezYajVzxUqPRiMmTJ3f7O9Ad+5lVdhsSmxheuHABFosFlZWVMJlMUKvVg96ayRVD3bqpu2sijUaD5uZmlJSUQCKRcEmzfYX2kYJi/f9QwtwDx97KfUmW7QtwzJo1i9cnsC8Jc+sNa8E0N8N87Dh83n2bd19bWxsyMjKgUqm4/nLce7Fa0fn5FxAplVDde29X6ydfH0gnjAdjMEDk493VQophoP/7S1AsWwqRTAZzRgba7/8jpImJ8H7zDYgkEhgDAqAAEFZUjHGLFkH53z21IpEIPm/92ykBsf8CqK6uxokTJyCTybBo0SLk5OSgvr4earUaIpEINpsNWVlZKCgo4EZgU1NT0dnZiYCAAJhMJnR2dqKxsRGenp4IDAzE0aNHAXRt/p8xYwbCw8PR0NDAFexgLzbq6+u5JWH19fWIiYlBSUkJKioqkJiYiLKyMi6xZwPtN998w33JpaWlcVXMFQoFJk6cCLlczhUQE4lECAgIQGhoKDcyXFBQAJlMBolEArPZzFXS/n/2/js87vQ678Y/02dQZtB77wBRSAAk2JZ1uVxyl8ttklaybFlJ7OT6RYkTxa9jJ3kdy+W1E7/Jz7GduCpxkWxJlna1hctt3EZyWUH0SrQBMMAAg5nBYHp//8A+z84ArNiVRK33XNdeS4KYme98y3Oec5/73HdeXh6BQIArV65gs9no6upibW1NWmR1d3dLSXyR3KLRKAUFBVJgLDU1FZPJxNLSEiqVijfeeIPs7GyOHz9OX18f09PTGAwG2eEQHf2pqSn27t0rr0lih0J8j0/CNmGjJ2QgEOCDDz5Aq9V+op6Q4pxtNRH+pNHdjT7Zgp44PT2N2+3m/PnzSQrct6K+/bhjKzPMAm3fSofZ4/HI+xfWN4S9vb1kZWVRVlbGr/3ar2GxWPibv/kbAP7Fv/gX/PEf/zG/8iu/wj/5J/+Et99+m+9973ucOXNGvsfXv/51vvKVr9DZ2cmuXbv4gz/4A7xeL1/96lfv+/g+i5/uSHS8EPnrfnN9oo7Hrl27JKNmq7n+6tWrTE5OotFoeO6555LWqES6d319PWazOel4LRYLTqeTmpoasrKycLlclJSUEIvFiMViqNVqotEo09PTNDc3k5mZSSgU4q233iIcDnP06NFN1NGdO3cmqTU3NDRQX1+/6TyJ7xsIBLh+/TqhUIjW1laMRiNra2uEQiG5D1pYWJDeziqVir1796LT6TCbzZhMJlwuF36/n3A4THV1Nd/97ncJBAJ0d3ej1+uprKxkYGCAsrIyFhcXyc/PR6lUEgqFZDfPbDZTVFSE3W6nv7+f/Px8ysrK5L9Ho1E6OzulS4XZbObYsWNJ+bCzsxO1Wi2FHh0OB36/n7a2NhwOh9T0iEQiaDQaYrGYtIBUq9VUV1czNjbG3NwcTzzxBKFQSHap+/v7efbZZ2Xuu3DhAjabjfz8fCorK+U1yMrKkuM8H3zwAWq1mhMnTmAymRgYGGBmZobW1laUSiUjIyN4vV6GhoZ45plnJHARiURYWVkhIyMDnU5HMBj8RJxZEseQxN7zypUrpKamysJQrVbLJkJWVtaWwPJbWRzdT/ykc33inqi8vFyKqi4sLLC2tsbly5fR6XRJ41o/6abCx9Er2crI6YOc6z8rmG8TG72V7zeBxuNxpqenmZiYoLa2dpMHolKplCj2/YTSZCRqt6PI+GiuJZHuLVSwJyYmiF2+gvtvv4Xh536W6MQk3v/0fwNg/NbfknXjOigUhC9cXBfvKixE8/BRwm++RWxpab2I1mgI/vBFXIEg89EodYNDBDMzGC3IJ+XXfpWOzAy0t1hsN56n1NRUCgsLWVxcxOfzyUF7n88nk0pqairl5eW43W5JnWhpaaGlpQWLxSILRlhX4BOdc5PJREVFBWazGbvdzrVr1zhy5AgrKyu89dZbAHLGqKioSIoyCbrMtWvXJLDQ1dUl1bGzsrJQKpWkpqbi8XiwWCycOXOGxx57jJKSEnp6enjllVc4fPgw2dnZSfeJ6B5WVVWxtLQkkdzEjZPX65W07Pn5eRYXF9m/f79MYl6vF7fbTXp6ukwSsJ7wGhoaKCoqQqfTSdS/u7ub5eVlvF4vBoNB0sCsVisXL16UHpgrKysYDAa5aYlEIrzyyivyfR9//HEp/nGvMTU1JQVS7mRfIhJVdXW19Nz8uJ6QwWCQ1157jVAoxNGjR2/ZiblbPGjUMY1GQ25urgR7SktL5XkS1LcflXfmvUY0Gt0SuLFV1Pn69escPnxY/v3rX/86AF/5ylf4q7/6KxYXF5MEfSorKzlz5gz/9t/+W/7H//gflJSU8Jd/+ZcShAL4whe+gM1m49d//dexWq1s376d1157bZM4yGfx6Y6N41ZbKZZXVlbo7+8nOzubHTt2JD0bWy2YxUZ5I7tkowq26HZeunRJjseI3CdGfMSfv//97xMKhWhqamJgYIB4PM7a2hqZmZksLS3JvNHX10dTUxO9vb3k5ORQXFx8S/rixvMUjUZpampicHCQaDQqAeJgMCifz3A4zJ49ewiHw1KoKicnh0cffRS/38/zzz8v54qLi4spLS2V4ENLSws9PT0SRH7qqaeora3lxRdfZGJiQto26XQ6Ghoakujig4OD0qrqmWeeIRgM4vF4pKp2RkYGdrudUCjEmTNnOHLkCI888ggjIyNcuHCB9vZ26urqkujhontYWlpKOBzmzJkzhMNhOVIjzokA6v1+Pz/4wQ/Yvn07RUVFUq9lcXFRHodo0EQiETIyMnjyySeJx+NS0VqIbQomhM/nk93Jy5cvy/MWCoXIzc3F5XLJ83fhwgUWFxcxmUw89thjeL3eu1qOJYbD4WB4eJiSkpI72lWK2fq8vDxycnJkYZjYSBBuGwIsvxcW1cWLF5mbm6Ojo0MyFe4nHjQhMqFlEolE8Hq9tLe3S1eSjU0FAZb/uNlmW+0wezyeLQl9Pci5/rOCeUN8kkizz+ejq6vrlqINKpVqS0nU9A/fIzI4iGbXLmB9UR0cHMTpdEq6N6w/iMb/978RdLuJDAyS+h//w3oHWalEkZUF4TAKnY7ASy9BJEJsbg79L/1rVMUlaDo7UH4416o7/QR9RiOu7CzmhgYpLCyksbGR0J/8Kd6+fgLbtpH58ou3PFZBz7px44ZMIlqtFp/Ph0KhoKCgQBbM7733Ho899ljS65eXl4F16pZIPkLcSwidWK1W9uzZg8/nY3l5WXavEuXr33nnHTIyMjAajXR0dNDb28vo6Citra2Ul5djNpspKyvDZDJx6tQp+bqVlRUp3iESqVDyFsraVquVUCjE+++/j06nIz8/H4vFIi21Ll++LK/z7t27UalUDA8P4/F4SE1NRaPRSNsss9nMkSNHOHv2LMFgkOHhYbq6utDr9Rw7dgyn0ykVslNTU7HZbLz33nukpaWxZ88eZmdn5eeKDVEsFkuam1EoFFLhe9++fZKCCOtWHvdLzYrFYly9elXOZB08ePC2v7tRJVuj0WyyZhLK0uLY7+YJubq6miTaspWC+cdN07rXiMViaDSaTXPiiefJYrFs8s68ldDaJx0/7rmmQ4cOJTFmNsZf/dVf3fI1ibOKt4qvfe1rn1Gw/xHHx3W8iMViUjG6sbGR4uLiTe8hLIjuNzo6OiguLiYzM1OKb83MzEgQvry8HIVCIamwFouF8fFxnn32WekakZqaKsEtm80mqeGBQIC2tjaUSqUs1PLy8qQI58TEBGtrazQ2NtLb20tfXx8DAwM888wzt+1ILi4ucuXKFVwuF0qlEp1Oh1KpxOv1UlhYKP2PxUiO1+uV52ZtbY1AIJAkwqVUKtm5cycmk4l4PM7S0hIlJSVS4ExQlgUTEGB4eFjO9La3t0uqd3p6ulTqLikpQaPRcOTIEXnswWAQv98v55lhvbitqKiQRa3ZbKa0tJQ33niDUChERkYGk5OTlJeXo1arJbsA1se1ysrKGB8fZ3l5WSonezwewuEwY2NjHD9+nDNnzuDz+bh+/bq8DgcOHGB+fl5aYel0OlnEBwIBDh06hFqtlgyz6upqrFYrkUhEzqzDR7Zgi4uLPPHEE2g0Gjl65nK5UCgU950ve3t7WVpawmKxyPvvdpFYnCaKXMJHLCqn08nk5CR+v1+yqAQIvDG/CHtUWGdQbKVg/kl3mG8X4rg2zoknNhUmJyclQ0ucpzu5knxSsVWBT+GIcb/xIOf6zwrmhBBI8/DwMOnp6bdMfncLQfvJzMxk7969t0WDtoo6KzMz0X44c5RIwRZUpsT3jxQXoRodIzoygufXfx3icQy/9Et4/uXXiFrmMX7zmyhiH92Yvl/+v0j73d9Bd/IEANHZWda+8lXSHjmGKzsLrVbL3r17CYVCrASD9D92koW2VvZMTlJdXQ3AyMgIc3NztLe3o1QquXLlinz/wsJCDh48KMEI4Xt4/fp1SUPWaDTk5OSwsrIi7ZwaGxul0mhGRgZ+v5/U1FTef/995ubmJDq9urqaRJkuLS1lbm6OaDSK3W6X9k1i0S0rK2PPnj3s3r0bhUKB1+tFr9ejUqlYW1vj3Llz8hq1tLSQlZWFwWBAp9NRV1cnlUpHRkYkwjszM8PMzAyHDx9OQuRTUlIoLCyUfr2wnpA7OzsZHx+XKsqDg4OkpKTg8/mSlDfT09N5//33uXbtGgcPHpTotFhQY7EYLS0twDoKLDrnOTk5kvql0Wjkxm1tbY3vfe971NXVkZmZidPpJBKJsLS0dFfULdGmQqFQkJ+fj9VqlcV8KBTi+vXr0itbLOh3WgRha56Qubm5ct49cYbtfuJB6zCLuFVyFwI8xcXFkvomzpPwhVQoFEmUrh/F7NhWCuZoNIrf7/+xCIF8Fp/FnUIAfPPz8zgcDpqamu77GfH7/fT19RGJRNizZ89t7+st5/oPRSlhfU0dGBjA7Xazc+dOOZYjfi+xo33+/HlCoRBFRUWsrKxw5coV2trakl4jlJ5FJycej/Pmm29Kj2KlUklnZye5ublyhlaAo4cOHQLWweL+/n4qKyupra3lvffeS8o1zz77rDx2Afq9+OI6uD41NSWZNAJ0ttvtlJWVMTU1hUqlori4WL7f+Pg4ly9fRqVS8fTTT1NaWioL8mAwSFVVFfPz8xJMhHWqs8j1WVlZNDY2SjHLYDCIQqFAq9VKJWkBXNfV1WE0GuWoVWdnJzMzMzQ3N+N0OmVBv7KywsrKCmtra+zYsSOJZSY60cJCNBwO09HRwdraGnNzc2g0Gi5evEhqaio+n0+CoYLavLi4SHd3Nw0NDezYsSNplnx5eZnGxkZ5Td59910CgQAmk0kW7EqlMinvvvDCC6Snp1NZWcnIyAgAExMT9+TzHAwGZa4vKiqS1pYKhYJ4PM7Q0BAOh4MdO3YkjdvcqZsrrr3Y4wSDQQkCDw0NSWVpkesFCNzV1cXc3Bzbtm2763HfKh7kXH+rfLqxqZB4nkZGRgiFQlJoTVhYfdKAwMfpMH/acv1nBfOHkYg0B4NBdDrdfT1YsViMiYkJzGYzDQ0NlJSU3PH1d6Nku//T/03w+RdI+43/jP7zn0v6t0QKtvA3S/yseCyGEnA99hh5o+sCHLGpdbGIyMAA0Q+FI/x/+qek/uq/JzI0RPRDy4bgG2+i/8IX1n93bIy4x0PbCz+ksLqKhi9/GZVKRSQSYeqrX8Xi8xIHJj8smKPRKFc/VOC+cuUK+/fvl0h3Q0MDDQ0N658RDPLqq68Si8XYtWuXpE5VVlayurpKdnY2Go2GsrIyNBoNhYWFPPnkk7z88stMTEwwNTUlfQ5hPSELc/lwOIzZbJZzzWIB8fl8aLVaqcadaDelUCgYGRmht7eXjIwMHn30UZaXl2UCzMnJYdu2bUloaUdHhzzfdXV1eDwegsEgKysrwEcm70eOHJGU5ZdeeknOZdtsNoLBIJOTk9J0XcyULS0tkZ6ezvT0NCsrK2RlZaFWq6Uid39/P9PT0zQ1NcliWdCslEolY2Njsjg1mUx0dXXhdrvJy8uTM0xiEzQ3N8fJkyf5wQ9+QCQSYWxsTNpa5ObmEg6H8Xg8csY8Go3y2muvsba2xr59+ygrK+PQoUNJFN3Z2VmJdIvCTty3ApT6JD0hi4uL7+oJead4kDvMd0tUtzpPQlREKNGr1WqZULOysj6R+fStJFGxIf1xqGR/Fp/F7SKRgi2okPe7iV5aWmJgYIDCwkIaGhru+CzcrWCempri0qVLlJWV3VKASyhuG43GTSrYoigxGAy43W7i8bik/zocDpkHRkdHOXXqlCx4otGoBKTVajWRSER2VtPS0jh+/Ljc7BqNRqLRKG63G7PZLIG8np4elpeXsVqtlJSUYDQak1S0xTl97733pOjUrl27mJiYIDs7m6ysLFZWVlCr1XL2VaVScfLkSW7cuEF3dzcKhYLPf/7zMtdHo1FisRiZmZkSLH7nnXcIBAJSZCscDksA1el0EgwGJQisUCiw2+28+eabqFQqTpxYbw6ItUmj0bBt27akNTLRQzYajVJTU4Pb7WZ5eVkC/wDbt28nPT2dhYUF3n77bakaLa7/jRs3+PznP09nZyfxeBy73S5tP30+Hx988IEsEMU+Ym5ujtXVVVpaWqiurpYz3UIcymazyX1BJBLhqaeewuFwSIXgwsJCLBYLU1NTuFwu9u/fj9VqlSyuhoYGbDabpPo6HI4kLZHu7m7Gx8eprq6We7Wamhp5v/t8PgYGBoD1pkCimGosFktSE79T6HQ6CgsL5cicUJZ2OBxyLyHyV2dn55aFsR7kXH8vx7XxPCUKrc3Pz98TK+9+Y6sF81b1Sh7k+EdfMN/KW/l+KVSJSPPu3bvv6Sa522cE/+H7EA4TeOGHSQXzrSjY8WiUyNQUqspKYouLrD79LCnxGI5v/AZp//W/gFpFzOsj+K1voSotId7eTuTGjXXhr7Q0Ml97Fc83fovAX/814XfeJXztOsr2HdzMzUVx8gR5GRk0/ZN/gkKlwmw2r89R6nXsbN7G1NSU7GwqlUqKi4uxWCysrKzI2djW1lZGR0cZHR3l4YcfJhQKSST0/Pnzkmadk5PD66+/ztLSEgqFIqkoBeRGQXTSDxw4gNlsxul08vzzz9PV1UVubi7Xr1+XryksLKS9vT3pfZ599tlNVHuBSrtcLmKxGGVlZSwtLRGLxUhJScHpdN6WvpSWlsaBAweYmpoiKysryd85PT0dpVIprR1gfQOi0WhYWFiQHQRxT9hsNkKhEKFQiIMHD+Lz+XA4HLKIjsfjcoHMzc2lsbGRt99+m6WlJdRqNeXl5UkjANnZ2VJkYm1tjStXrpCZmUl7ezs3b96kpqZGWlLMz89TWVnJG2+8gcfjobq6GovFIul7TU1NBIPBJKS7rKwMhUKBWq1meXkZh8Mh1TsFiCFidXWV5eVlfvjDH/Loo4/el//zvXhCRqNRvF4vtbW1d93EJsaDjDrfb3JXKpWYTCY52y/ojg6Hg4WFBcbGxtDr9Ukd6K0ADVsRAhGb0k8b6vxZ/PRELBYjFAolUSDvp/sbjUYZGxtjYWGB5ubme7IluVuuF2JRU1NT7Nu3Tz7zt6Ngu91udDodarWaN954A5vNRnp6OseOHZO6Bzdu3ECv12MymRgaGpJeyMeOHWNhYYE333yTYDDI4OAgbW1tLC4uStBx3759pKWlsbq6Sk9PD16vl+bmZiYmJigvL5fHV1lZKYvGF198kWAwSFFREeFwmDfeeINt27bR0tKC1WoF1oFenU7Hzp07qaqqoq+vj/HxcWKxGJ2dnUnriViThNNDU1MTOp0Ov9/PG2+8Idf44eFhWTCmpKRw/PjxpLVcsHA2Wj+J7q/b7aagoIBt27Zht9tJS0tjaWmJ8vLy217LnTt3SrXumpoaeQ8IdlwiNTQUCrFjxw66u7spKCiQxyGuo1gTBQPA4XAwNzdHamoqWq0Wj8eD1+tFqVSyf/9+vv/977OysoLP56O9vT1p7TaZTJKlFYlEuHz5MqFQiLa2NsLhsOzU1tfXSwXznp4exsfHSU1NJTs7m9nZWfLy8jh69CiAnDEX1xDWRcy8Xi9ms5ni4mKys7OTxsVg/TmxWCyYzeb79n/eqCydCAILRxBY36tlZ2fT1dV1zzns05TrbyW0JpiKTqdTsvIyMjKSWHlbGTvZ6vjVJyEo9yDFP+qC+XbeyvdTMC8tLTE4OEh+fj6NjY33fGMJ0aPbRep/+o8EX3qZlH/9Eef+dhRs97/7ZUIvvYz2+CNojx8nbrejALTjN9H/238DgP873yU6Nk50bBzDv/5XRPr6UJaUoPyQ6qE9cojAX/81KJX4Zs34/n//kvTiYrJ+6V8R/sZv4fnGb5L2O7/NBx98QCgUQq1WU1NTk0QNGh8fx2azSaqOmCvyeDwSIb5+/TpHjhyhpKRE0qX0ej05OTncvHlTCn4Jqml2gnXWkSNHmJ+fJyUlhXg8TkpKCrW1tXz7298GYGxsjJSUFClgUlZWRkZGBleuXKG0tJSioiKcTicul4vS0tKka1VZWUk8HqeiokL6tu3bt4/XXnuN+fl5LBYLTzzxBGazGZfLRUNDwy0X6ZSUFHnMsVgMs9lMeno6aWlpaDQaCgoKaGhokKIgG4WTampqZNEpuuD5+fkSydfr9fT39xOJRJibm8Ptdsvz3dPTQ3d3N2q1mubmZkZHRxkYGKCoqAiDwcDw8LCkkQl6PKyPEczOzpKSkkJ+fr68VoFAQCLEVquV6elpGhoa6OzsZHp6mlAohM/nIyUlhVAoxNtvv008Hqe+vp6nn34aSBaFEYW2KOLup2DeGLfyhHzppZcIh8OMjIywvLyc5AkpgItbxYOKOm91digxRNdFzI4JX06n04nZbGZoaIi0tLQkUZF7EfPaaodZbPQ/i8/ixxkCGBfjQFvJ9R6Ph76+PpRKJXv37r3nzeDdOswtLS2EQiHKysrk8347Cvbk5CQXLlxAr9dz8uRJmS9FF7WwsBCv1ys7lEKDIxKJSPprTk6OtKtTKpVSCKyrq4uxsTEuXLjAkSNHGBgYkPoXKSkpnDhxQq7nVquVwcFB2Z0Wud7r9UrKsqB979ixg76+PnkOSkpK5LkUITRBRAgBSbHOqFQq6urqePXVV6VFY3V1tewEm0wmmpqa6O7uJjU1lYaGBoLBIAsLCxQWFiZ1JPPy8iSwXFBQgEKhoLW1lf7+foaGhmQHPBQKMTMzQ1VVVRKdXYRKpUoqEq1WK4FAgLy8PLxeL/n5+dTU1JCdnU1VVdWm9bKoqEhek+LiYsmY8nq9TE1NkZKSwtjYGC6XC6/XS19fH1qtlkAgwPLyMi+++CIKhYKmpiZmZ2dZXFxkcXGRwsJCrFarvHZarZb9+/cDH1mciqaAEGANhUKyeHe73bz22mtkZmayc+dOKdy2vLwsqcEXL17EbrczNTXFY489timHhsNheU/Y7fYtiT+JuBUIfP78efx+P/Pz8wSDQdLT02VReKcc9mnO9QqFgvT0dOn9LoAG0XAZHx9Hq9UmgeX3wjbbSq4X+/fPOsyfkriTt/K9JNFYLMbo6KhUB75fz9q7fYbhZ7+M4We/DNydgh35cCYldP4Cab/5DXTPPovf7ycWi+L57d8h5Rd/geiHHrgAoYsfYPzW36LpaEfxoUdvdHIK7WMn8T3xBEs/+AH5djsau53Yt/6O2OwswdlZUn/538niKB6P83d/93fS5++VV16Rs7lKpZKHHnooSSWzvr6esbExVldX5QyN8BC2Wq3Mzc0lLRhtbW1SBEOEUqnk2rVr+P1+Ojo6aG5uRq1W09jYyOzsLNXV1Zw9e5ZwOExdXR2Tk5MyaczOznL69Glef/11KR6xb98+FAoFDoeD9957D1hHVJubmyUQYDKZcDqdmEwmvF6vpHoLG4D29vZNXtcixsbG6O3tBeCJJ57YJIBwq0U9NzeX/fv3MzQ0hNlspqKigkgkwjvvvEMsFqOmpoZnnnmGWCyGx+OR1lGCngPI7qvYyNhsNsrKypIKVJvNJqnSw8PDRCIRSXk+cuQIS0tLVFRU4HK5pC2Ex+Ohv7+fRx55hOvXr2O32yXNXafTodFopPp24v155coVrFYrra2tpKWlUVlZmbTR+CRCq9XS2NjI2NgYLS0tFBcXJ3lCxuPxJFpy4lzvpwl1vluo1WpycnLIyckB1jdKG5XKEy2sbicqspUEL4TuHsRz/Vl8euNO3sr3WjBbLBaGh4cpLS2lrq7uvu79uxXMeXl5khoMyRTsffv2JemgCKZSIBDA7XbT0dGB1WrF4/Fw9erVTXsDq9VKe3s7VVVVMt/Y7XaKiorIzs5mYWFBFrgLCwuy0F5YWJCAvFKp5Ny5cxiNRp544gl6enpkXof1gr+wsJDe3l4UCgUtLS1cuHCBUCjEjRs3MBqNFBUVyeKmp6dHjjjF43FKSkrYvn170jlRKBTSzzo/P59HH30UgMbGRskiunjxIgsLC5LFdOnSJfn63Nxcenp6WFlZISUlhccee0yyCUR3Xa1Ws7KywkMPPbQukiqETj8UJ3377bfxer3Mzc3JmfC9e/fecv0S1HBYF/fcqKdxq1yv0+k4ePAgfX19jI2N0dzcjFKp5PLlyywvL5OSksLp06elRdfi4iIajUYKvcH63nB5eVnOns/OzlJYWJikfO12u2UuWVxclL87MTFBZ2cn2dnZ5Ofno9FomJmZwe12MzMzg9PplOdbdLoPHDgAIAstMboozsnU1BT9/f3U1dVJoDrR//mTCJVKRUNDA06nk7y8PNnxdzgcd3Xb+DiWVD/K+FHk+kSgobKyUqq1C4HAkZER2WAS/91KcykajW5JmXurAp8PcvyjK5gTvZUTkebEUKlUsst2qxBoH3BfSHNi3KsQSCIFu6Oj45a0YP2TT+H7/d8Hn4/QB5dI/6+/h29igoLjJwjE48R9PtQfzg8DRLu78f2v/0XGX//V+t8nJvD+5m8BsALkfvWrqK1LqGpr0D3zDNHpaTT79hIzGmXCFpuMiYkJOjo6ZLGs1WppbW2lsrKS8fFxVldXWV1dZe/evRiNRnw+HysrK7S1taHRaDh79iyALFg1Gg0lJSUMDQ2xtLTEsWPH5EISjUYl/SoRkd61axe7du0iEAgkWTIkboREgSBibm6O+fl5SktLk35PzPGKgrmrq4vGxkY5xyVsnwR1WyT05eVleXxms5mSkhK5MCuVylsuhkIwpKKiIunf+/r6sFgszM7OSsqzQJYTqWomk0ladWm1Wqqrq6UQmMPhQKvVotVqMRgMxGIxGhoaWFlZkYtleXn5JpQxNTVVdhxDoRBWqxWTyURDQwMDAwPU19ej1+tJT0+XNKmbH4Ixra2tTExMMDAwQFZWFkVFRfj9fqampoB1QTiTySQTqDiPOTk5n0iy2LZtW5IYyEaqksPhSPKETElJwe12EwqFHkjU+ceh6KnVasnPz5czfkKUTtiHCPGVRAVuob+wlQ7zp42i9Vk8uHEvjhd30xKJRCIMDw9js9nYvn17khDjvca9FuW3o2AnRm1tLYODg8B6cbJ//34aGxv5zne+I31+jx07Jn/f6/Vy6dIlaa0E8P777xMIBFhYWGDHjh1SfLO5uRmPxyPFnQT1VexTBKAq6LkKhYLy8nLa2trw+/3S1SI1NZXKykpmZmakmnRHRwcvvPACwWCQsbEx6Rst6LwvvfQSJ06cSOpIiRwvCjxYZ4KJYvTll18GNud6nU6XtFEXKtS7d++WTAPxuoWFBdkJE6NUomDOyMiQXddIJMLs7Czt7e0STIjFYkxPT0vv58TrvTG8Xi8LCwuUlJQkdbtnZmZk/szNzU3qhuv1epkDRK4S56SxsVGKnAkgMhKJkJOTQzgcJjU1lfb2dm7cuIHT6WR8fJyGhoakwsdkMkn7rXg8Lo+jpqaG5eVlMjIySEtLIz8/H4/HQ0pKCq+++iqAFOdcWFigt7dXAh49PT2EQiH6+/spLi6mublZ7j+E//NWtUYSo6CggKeeekr+PVEYS8z1CgurWCyG0WjE7XYTiURuS7f/ScaPo5AXI3KihkhUKhdWZWLvJxS4hV/7VnRPtqqS/SDHP6qC+U5Ic2LcKcEtLCwwNDS0JaQ5Me6lYL6TCnZi6E6fIvCtbwFxNDvXRReUqamEc3PRLi+jbmxE/+WfQVVRju+P/xeR69eJ3OghMjWFuqqKkMlEODMT9eoq5Y89RnrXLmLPfx+Xy0WqyUTW22/Jz2pubsZsNuP1eonFYhgMBkn5EXO2NpsNp9OZ9LCsrq5SWlqKz+djx44dpKWl0d/fj8lkksUnIMWdhGVUYvEK60VRLBajtbU16RxEo1HGx8fJysqSYEddXR1qtZrKykqpslhbWys3Ag6Hg/z8fDIyMjh48CAWiyVJgVJcJ0HHUiqVnDp1imAwKCnKzc3NvPXWWwQCATIzM+V3qa+vl6qRqampm0QqfD4fb731luwMJxZ6BQUFWCwWcnNzpZ/hyZMn6e3tlZZU+/btA6C0tJTV1VXKysrYuXMn8/PznD9/nkgkQn5+PkajkbGxMenpmHhNRLdczM3ZbDZGRkbo6OhAqVQyOjrK8PAwAKdOnZKbrtXVVTQaDVVVVUmz2Q6HQ3Yr5ubmsFgsSTN+ic9UPB6XyqRCCfR+wu124/f75Tm6UyRSlcrLy6Un5AcffCBp4kNDQ1KI5ifhdXir+ElYYOj1+luKrzidTmZnZ2WnPhKJEAwG78vXUiDOn3WYP4sfdSQC43B7b+U72TuK/KvX69m3b9+WxfLuJdcLCrbH49mkgp0Y6enpUrhLqDgrlUo0Gg2RSESuX6dOneLmzZuScjs9PU1VVZXc/AYCAUpKSmhsbJQuFILmLaKpqQmfzydFtGAdhNyzZw8jIyNkZ2eztLTE3NycpJPHYjGpOh4MBtm2bRtFRUXMzc1JUTBAvl8wGJRF6fXr1zlw4AAqlYp4PE5VVRUmkykpH8NHjDu1Wi3XdaPRSDgcprKyUlJyu7q6OHPmDLCemwSr8NixY5jNZhYWFsjOzk4qrhML9v3790tAta+vj6KiIvr6+pienkatVqNWq5mfn8doNPLYY4/x6KOPEgqFbuky8d577+FyuTCbzVLkE9Y1RlQqFWq1WmqPdHV1kZWVRW9vLy+//DInTpxAq9VSUFDA2NgYaWlpNDc309TUxPPPP084HCYnJ4e0tDRWVlYwm80YjUbJ5hGWWCMjI+zcuZP29nbMZrP0fhYWld3d3cB6Djh9+jSwDhQEAgFyc3PJzs6WoMjKyoos8CwWC/F4nNTUVPkzhUJBJBKRz1x3dzcTExPyXN1PhEIhVlZWyMvLu6dxHoPBgMFgSHLbGBwcxGKxAB81XgQIvFUBsU8yfhK5fqNSuWCbORyOdZ2iYBCj0ShHMO/nGD+tjhj/KArm+/VWvhXqHIlE5GxkW1ubRLO2dDw+H2qLhegdZirvRMHeGKqiIrIunk/+Dlotk7/9m+xtbET1IfVWe+AA8XCYlZERzDs7Kb74ASnp6fQPDJD/Z39C5eQk2vz173X+/HlmZmaSrCdg3RuytbWVl156icLCQin4VV1dTXl5uZwnhvWFX8w4CbuiPXv2EI/HefXVVyX9Kzs7m6KiIlwuF8FgkMLCQkKhEG63m6tXr1JQUEBmZiYffPABZrOZ1NRUdu7cKT/H5/NJOpiYyxUPvsPh4MaNGxI1Ky0tZWpqing8TnZ2Nj/84Q/lsU5NTaHVau9IF9ZoNGg0GmpqaiQVO7GTLEKhUNDX14fVaqWzs5MbN26wurrKzp07ZZdOJLONSaCuro6KigpJv4J11Fyon4qu8tTUFEVFRZSVlWGxWHC73XLxF8qpRUVFcq5NUHH0ej0ajUYWi2I2OlFMTGxCgE0U68HBQXluDx48yMTEBLCuEpqdnY3L5ZJUbrPZzM6dO7l27Roej0duhuLxuJyPFvSyew2fzydV1u9XUAQ+8oQsKytjcHAQrVZLaWkpfr//nj0hfxzxk6aPbRRfSezUr6ysMDQ0lDQjfTdREa/X+6lDnD+LBy8SHS8E4Hi7uBU4Ho/HmZ2dZXx8nMrKSqqrq7cM8sTjcUmJvd2Gc6MK9p3AOoVCkdRBFj8zGo0cOnRIMqmEmrAomIeGhsjPz6evr4/c3Fy2bduGRqMhHo8zOTnJxYsX0ev1PP300/Lzy8rKKCsr48033wTWwXIhMrR//37Onj3L8vIyFouFiooKqXodi8WYn5+XAqhXr15ldHRUegoLvRBhA2kymZifn2d2dpbR0VG2bdvGxMSEtKRMpPRGo1HZ8e/s7CQlJUWKGjocDgYGBpLmWYVlYm1tLWfPnpU09pmZGfx+P9u3b7/ttRWUVkAWuUJQdOO6PDc3x+DgILW1tfj9fsbHx2lqaqKkpAT4iJK9MddnZWXx9NNPy3l68d6CAenz+VhbW5PU8qeeeorp6Wnsdjs5OTnodDoCgYDUO2lubpbWQzabTeq9CFHTiYkJmpubuXHjBrBu11VQUCCL3Wg0mtQBFvotsL5Pq62tZXV1lW3bthGPx+WeSdxn+/bt4+rVq5LlBiSNiwmg5H7i3LlzsikgGgX3GsJFQjAeFAqF7OILtw29Xp90v/wkwPJYLPYT1/bYyDYTnfqpqSmsVqt0Ytlo9XWrEKyQz2aYf8riXpHmxNiIOrvdbnp7e6WC5MexZYlHIjhPPIZ2bg7jz3wJurqS/j0cDjM0NHRHCva9hFKpJKpWy2JZhGbnTsZ+/ivM5WQzEY9R0NNDc3MzmW+dw/sb38CvVJL5zjm52In/i7BarXR3d+PxeJiYmJAK1F6vl2AwSEFBgfTk1ev17Ny5k/HxcSk+UFJSQjgclsWyQqFgx44dcp722rVrKBQKKisr6e/vR6lUys66uG4+n4+3336bQ4cOYbfbuXTpEqFQiM7OTnQ6nUQVx8bGqK2tpaKiQtJx5+fnZZdsdnZWbpYWFxflrJDb7ZbXOBKJMDk5KQVCbhXHjh3DbrdLBens7GxycnKk5+TQ0BALCwvAuhBKe3u7RPNvp759K9pSU1MTExMT1NTUyLng8fFxqeI9PT3NyZMnOXXqlPwscd6E9dCVK1cIh8NoNBoyMjIIBoPMz8+j0WhQq9VoNBo5C3bgwAFZ7L722ms8/vjj6HS6pM2CTqeTc03xeJysrCwKCwsxm83Y7XaysrIoKSnhxo0bEuH/zne+g0qlYvv27UxMTOBwOHC5XEnq3reLWCwmrUWATaMTY2Nj2O12OS99p2hubqaqqoqrV6+SnZ0t6cK384QUNPVEsbEfZXwSQiCfZIhOfUpKCpOTk+zZs0cmVXEv6nS6pAI6kRXzaZxp+iwenLiV48W95noBpAtRpNXV1Y+Vf0VcunSJmzdvotFoNhXM90LBvtcQtN3E91cqlVJc0+Fw8M4771BdXU1BQQEvvfQSsD5SJoDYQCBAKBSSBYPX6+X69esydwmGkbBzKi4uZnl5WRaFXV1dXL9+HZ/Px+zsLBkZGbS0tEjNElgHg8WewWw2Mzk5SUtLi+xSivUh8TycO3eORx55BKVSyZUrV1heXqaqqkoyXZRKJSMjIxiNRnbv3i3nWScnJ3G73RiNRhwOh6QzLy8vSyaUzWaT+jOiUREOh2/bpNixYwcFBQVoNBrGxsYoKysjPz+fd999l9XVVSkKFwgE6Ovrk+fm0KFDWK1WUlNTN7FyblUoiT2LACGE8nZ1dTWTk5MAPPnkk5w8eRKv18va2posUoT10M2bN2X3vri4mJWVFUKhEMPDw+j1esLhMFNTU4yOjlJXV8exY8d46623uHjxorTzTDw2hUKRZBvlcrmorq6WoItOpyMvLw+j0Sgtys6ePUssFqOurk6Krk5PT2+a8b5VCG2RRPvQxLBarUxMTFBdXX1XDaH8/HyeeuophoeHycjIkNclUQRT0JIFWC5U9EtLS3/krKgHLdfDR536xcVFioqK5HMkBEMBaWG1URdGPF+ftnz/qS6Y7wdpTgyBtCV2eisqKqipqfnYD048ECD2YQLSzFs++nk8zupf/RWLg0NEnn7qjhTse4lb0cDi4TCrTzyJvrICDh1EpVKxZ88e0tPTCQhUTaGADZ3SM2fOUF5eTnNzM2+//bZU9xaWD16vlxdeeIFoNMrBgwc5evQoCoWCgYEBVlZWaGpq4vz59Q64oDwXFBRIClUgECAej2O1WiUFWDxoWq1WFjJ79+4lGAyyuLjI3NwcIyMjLCws4PF4CIfD9Pb2yu7w+Pg4gUBAItZpaWlSFTIej0u1aIPBgF6vJyMjg9LSUoxGY9K88/DwsBQ4efLJJ29JrQ6FQpSUlDA9PY1Wq6WsrIx4PC6tqWpqagiHw1KdW4RKpeLKlStEIhEOHTp0x0Xf5XJx4cIF4vE4TU1N8vyI44ePhDjEvzkcDqanp9m+fTtVVVWEw2F57eLxuBSaERug/Px8rFarRIMXFhaSVFt7e3sljT03N1cKhYnicXJykmvXrgFw4sQJamtrMRgMBINBSdkTyujRaJTFxUW5WRPHmXhe/X6/9H8GuHHjBmNjYzQ1NXH48GG8Xm9S4vX5fBI512g0SSwEAZwloseigyr+LOJ2npATExPSZqOurk4yH7Zi1XAv8ZOgad1LCJBJrVYnWX1Fo1G5+Zibm2N4eJiUlBRcLhcrKyssLS1teYb5f/7P/8nv//7vY7VaaWtr44/+6I/YtWvXLX/30KFDUhMhMU6ePCkpmj//8z/PX//1Xyf9+/Hjx3nttde2dHyfxU82bud4cbcQ4J/wGe7r6yM9PZ19+/Z9IrOWiZofifl4fn6evr4+dDodu3btuiew8E6hVCql57KIy5cvy/UWkB66a2trkt2U+DqFQiE7zfv27ePatWtyYwwfgbivvfYaDoeD2tpavvSlL6FSqZidnWVsbIyGhgYJuC4uLrJjxw6ampqYm5ujrq5OghLxeJwLFy4QiUTk3wFJRa+ursbtdtPf34/b7ZaCoYFAgEAgwPDwMI2NjajVajkiJhS6xdq9srIic5SgnKvVaoxGIzU1NUSjUerq6uT3s9lsXLx4EVi/LyoqKpLOp8jhRUVF0p1CgBy1tbX09fVRV1dHPB5ndHQ0ifmk1WoZGxtjZWXlriNIsVhMCo5lZmbKHKVUKuX+Q61Wo1Kp0Gq16HQ6LBYL4+PjeL1edu3aJcVMRezfv1/uCYUdowAVADlfLBpLZrNZsh7KysqkFZfQrvB4PHKeefv27Tz11FOo1WqUSiUFBQWkp6djt9slSDE1NSWL35GRkaS8HYlEcDgckp4O6zTvCxcukJGRwaFDh1haWtokAnv9+nXZiHniiSc2XSu1Wr0pr29cFzaKYAaDQZxOJ4uLi7JrXlBQQGVlZZKGxycdD2quB6Sbi2CblZaWSuaM0+lkZWUlSRfm4sWL0glmK13zBznXfyoL5q0gzYkhKDG9vb2srq5Kv+MtH08shvtf/RKR3l7S/8cfYPzzP2Pt/fdZ6min+sPjnX/jDQy/9TvkASnbtqG7T+rJxlAqlaR338A/P4/+uedQaLXEvV5ic3PUzs5iysyk6nd+Wy7Auue+gLKwEGV+PqriYpkcg8EgbreblZUVamtrSU1NZXV1FZ1OR2dnJ2q1WnrgwnqSzM3Npbe3F7VaLQt/n8+H2+2WdkzHjx9ndnZWKkvqdLokBLGgoIDJyUmqqqpksZaSkkJHRwcXL15EoVCwuLhIWVkZmZmZspvMh+ezqamJy5cvy469oHXV19czMTEhkelDhw4RCASSOur9/f1SHEGAFhqNBqfTyeuvv052djY1NTVcvXpVImn79+/H5XIxOjqKxWLh6NGjkj5kNptZW1ujsrIySTTG7/fLBOVyuZKQ7vHxcSKRCI2NjSiVSvx+v9xU+Hw+Ojo6iEQizMzMkJ+fT0NDwyZhM7vdLilsSqWSvLw8MjIyWF1dpbi4WCY/tVrN8PAwVquVXbt2UV5ezurqKmq1GpvNhl6vJzU1VYp3ra6uUlVVxdTUFJcvX5bdWWFxIs6j2DAMDQ0xPT0NrAubeDweeY0UCgVra2tJQhzBYJAzZ84QiUTYtWsX1dXVwDrtTfy/ra0t6ffn5+fl93O5XElsgHg8zrvvvovVaqWjoyNpkyTo4bdLVom0ZL/fz+LiouzYJ1o1CJpSVlbWJ7LRhgc3iSYWJYmhUqmSuu9CVOSFF17gD//wD5mbmyMjI4Nf/dVflc/HvRTQ3/3ud/n617/On/7pn9LV1cUf/MEfcPz4ccbGxm45GvP8888nrSV2u522tjY+97nPJf3eo48+yv/5P/9H/v3jAJSfxU8uNnor32+uh/UNvdls/tidXlgXN+zv76e5uZl9+/YxPj6O1WqVBbPT6ZQWfIWFhR+7WIb1okOAw+KZEvPCSqWSRx99VOYeMUcaCARk8QfInArr1k8CgBWCkuL1YpRHrIUDAwM4HA7ZkVer1UxPT9PU1ATAzp07aWtr4zvf+Y5kf7W0tMjcZzAYpIhlamoqQ0NDeDwempubsdvteDwelpaWKCwsJCMjg0uXLpGfn49erycSichcFAwG6e7u5pFHHgHWi27RVYV15w2TyYTD4cDv9+Pz+RgcHJS5XhRY8XgclUrF66+/TiQSYc+ePVy7dk1qq9TU1FBRUcHi4iIvvPACDz/8sBzRWltb47333iMzM3OTe4YAhxN1P8R5tFqt1NfXSwq1AK09Hg8tLS3s3LmT7u5uubdIS0tLyjNLS0uEQiGmpqbIyckhOzubiooKRkZGpBCYKBiXlpbo6emhoqKChx9+mNnZWXQ6HVarFYPBgE6nY2Zmhng8jtPppKqqSoIOqampVFVVJQmxLS4uyjnz+fl52WBIT08nIyNDfgdhPdqQIEAL6/Pdy8vLlJaWSvurhYUFOQ+v0Whkzo7FYszNzZGSkkJRURFjY2ObGg0jIyP09vZSXFws2W8i7pZTdTodBQUFpKSkyIJZCIYJx5VEX+PErurHiQc118OtbaXEGIjRaEzShRkcHOTv//7vZePrn//zf87DDz/M4cOH72mM9UHP9Z+6gnmrSHNi+P1+vF4vBoPhE0GaY4uLhD5Ugw6+8EPSfue3ULa1Eh4YIDA6xsTQEE4FNKakgN+PqrqayNg4qsoKYktLuH72KyhSDJi+/S2UCXYBd4r4zQkq/+RP8QLEQf9zP8u03Y7jn/1TShwOGn7536FK6JYqFAq0hw7Kvx89ehSr1Uo4HJbiUK+88goej4fs7Gw8Ho+0dUjs5FksFjwejxRFEyiUsJFIjERqu8FgoLi4mPn5ecLhMMvLyxQXF9Pe3s7w8LCkdR0+fJiMjAwMBgOTk5NYLBYaGxv5mZ/5GXntAUm5gfVENTs7K7vbWVlZWCwW6uvrJaJdUFAgk3mimrLf78dkMlFfX8/s7Kz0/otGo7JYBmQXMh6PY7fbcblcks43OTlJMBhkfHycHTt2yPOQlZXFzp078fv9ScnVarXKTqnBYKCyspK8vDx27dpFNBqV3VpBa5+fn5c0t8TIzMyU3YRLly6RmZnJ8ePHef311xkbGyMQCLB37148Ho/cKC0sLMikFY/Hefnll+WMVOK8n5g/1mg0vPvuu/j9fnbs2CEtnCYmJigvL5fKjOK7pKamJome3Ep1NnGEwu/3MzExwdLSEk1NTdy8eZOUlBT8fr8Ee9566y3W1tYwGAycPn16k791PB6Xxfzi4mJSwSw2sfeyRtTU1GAwGEhJSZHf6VZd1dTUVJlQhcjV/S7Qdyvkf5IhEujdzpkQFfnFX/xFfvEXf5Gvf/3rjI+Ps7y8zD/7Z/8Mq9XKN77xDX71V3/1ju/z3//7f+cXfuEX+OpXvwrAn/7pn3LmzBn+9//+37d87UYa7Xe+8x1SUlI2JVGxOfosfjrjdt7K9xNis7WwsPCJdHphnZUkuqDbtm1j586dvPHGG3i9XoaHh1lZWSEtLQ23201WVhZutxutVotGo+HcufVxqEOHDt1SPOp2YbPZWFpawuVy8fDDD7OysiKfv/b29k3rbGIDoLW1VRaM7777LuFwWILNarWarKwsRkZGMJvNPP300+j1emkzdOHCBSlKCh/ZGiXmX1jfh2m1WoLBICkpKRgMBnbt2sXExITUjDh48CAul0vOCQtfYiFo1t/fj9Fo5Etf+hLwEXBnNBrJyMhgaWlJKnlPTExI/RWx2a6srJTK3PDR6I2YfRbHUVRUJP8NYHR0NKlb6/V6WV1dJRqNEo1GmZ2dlYC82P8IrYfEa3jgwAHm5+eTFMuj0Sjvv/8+sVgMv9/P3r17USqVHD58mOXlZbkvEGKiTqdTzpEnRl5eHqurq3JmXKlU8sQTT8hu96uvvsoTTzwhnT1gHXjes2ePBNqvX7/+oR1pjNTUVFkUe71e2Z2en5+nu7ubpqYmDAYDfr8fh8PB2tqaLKCETolGo+HgwYNJ+7yNAm7wEX3X5/Nhs9kYGxtLYrEluivcuHFDjpo9/vjjtLS0bJo5FnuZxcXFTfT3e7WQNBqNPPLIIxJUEkCK2M/abDYmJibQaDRJI0hCCPd+16GftoJ5YwhdmIceeogPPviAV199la997WsYjUZ+7/d+jy996UscO3bsrl3dBz3Xf6oK5o+DNMN6Ap6enmZiYgKlUkl7e/sngh4pi4rQfemLRHp60H/xC+s/UypRmWdx/9NfoCAWo+ov/gz9+feI+/z4/viPCX73e2j27UP76HFiHyJb4e5udAnFxh0/02TC0tzMwKnHKNRoMHV34/V6aXvqSeK//Cu4/82/xfgXf47yNjMGgqZ87tw5uViKzUViZ9RisUi7DZvNhtfrxWg0UlpaSiAQ4KWXXiIWi7F7927q6+uTPiMvL48nn3wSQG5U8vLymJ2dlYim0+mUc+cajYbe3l6qq6upr6+XC+fq6iorKytJmwCFQsG2bdvw+XzU19dL+lAgEJCdSoPBsOk1Yta3rKwMp9MpH/CbN29KeyeTySSR+fT0dAoLC6mpqZFU70gkwuXLl6XiaGNjI8FgcFPnQqFQ3NLDOS0tTVLl9Ho9r7zyCuFwWApqjI2NcfToUTo6OhgfH09KwCLEuVOr1UmAj1KplNfR5XLx1ltvycI7NTWVaDQqZ6eApC7A0aNHmZmZ4erVqywtLVFcXCyBAkCKq4yPj2O325mbmyMajVJRUUFBQQFms1l+1p3CYDDQ2NhIPB6nurpaCrMJFNPlcjEyMkJ7e7uk3MF6R1OhUGyiASmVSrq6uqRnemKIrv29JCuFQrFpI3irrqoQnBsdHZUz8w0NDVRWViZ5Qt4pRCH/oHpGbuW4NBoNra2t/NEf/ZEUjLkX9eDu7m5+7dd+Tf5MqVTy8MMPJ/mu3im++c1v8txzz20SHHv33XfJy8sjMzOTI0eO8Nu//ds/ltn0z+LjxycBjK+srNDf349CoWD79u2fSLEM653MwcHBTWvNa6+9JjuUR48elZvv559/Hq1Wy7Fjx+S8sGAO3WuIHL28vCw1M1paWpiYmODSpUscOHDgtve2UqmkqKiIc+fOyfUw0Z5RgKM+n0924Xt6eiQ4vG/fPnQ6HS+//DIOh4PS0lKOHDmS9BlqtZrTp0/j8XhkgZabm8vc3JwscMxmM3l5eWi1WsLhMPPz82RmZrJnzx4uXLgArBe5s7Ozm+i5Asysqanh2rVrMv9otVpJ2xVMJREbR29EtyoUCmEymSSFu6CgQOaYwsJCamtrCQaDaLVaQqEQQ0NDVFZWkpqaSnl5uRTW3Mj4SrQ+Sjz3aWlprK2tYTKZuHjxIvPz83R2duJwOHjllVfYu3cv9fX1eL1esrKyNq1jsVgMs9ksnTAcDsem6xgMBrlw4QIOh4NAIIBOp8NoNDIzMyOp54njWidPnsTj8fDWW2+xvLxMYWEhkUhEshbm5ubo6OjgwoULhMNhzGYzer2e4uJinnzySZxOpwT97xbNzc1YrVZaWlq4ePEiDoeDpaUltFotHo+HK1eu8PjjjwPI5wOQe8KNsX37dkZGRm45e3w/IPTG52VjV3Wjr/EHH3wgVdJbWlrIzMy8Z0ryg1wwbyXfq1QqcnNz+W//7b8B62utYBneLn4acv2nomD+JJDmYDDIwMAAXq+Xbdu2MTo6+onNJSoUCtJ/+7eSjnd5eZm4243iww2j0u1Z7x5nZhL5kAoS6e1F+6XnUBYUoKquAhR4fuf/wfDzX9kk5rUphoaY3buHqFbLfDiEifUZ4Mjf/T3eD+kSkWvX0R4+JI/JZrORnp6OwWDg8uXLjI2Nyberr6+nuroai8VCWVmZFN8QN7mwJoB1ZK+7u5v29vZNCzesP4A9PT0Eg0E6OzuTCjqFQkFWVhZ+vx+j0cjS0hLd3d1ycXQ6nQwODtLQ0MDJkyfp6+tjZmaGM2fO8Oijj5L5YQe+t7dXKiC2t7djNBrlvK3NZiMQCCRZd4TDYc6dO4ff75dd7NTUVGnB0dLSQm5urkSkl5eXJeVIIK06nQ6DwYDb7SYQCGC32xkZGZGWTzdv3sRqtd4V6fJ4POTn51NRUYFCoZBI7/T0tPzz8vIyFRUVcmZ7eXkZpVIpk7TNZpMI+I4dO6ipqZGfe+jQISwWC2azWV4z+IhZEQqFOHbsGOFwmIcfflgWx0LMRMwDi9nwnp4eVldXpeiZwWAgLS2Ny5cvy669wWCgt7cXWN943YmKOzo6ysjICAqFQlLNV1ZWKCoqYnV1FY/HIzsmKpVK+kEKr0xht5IYif6diXG7DvPCwgL9/f1UVlZuAnruFBqNRm6MHA6HBGecTicej4dYLJYklCGsP253XA9iEt2qQInX65X0OYVCsWkDe6tYWVkhGo1uKh7y8/MlZe5OcfXqVQYHB/nmN7+Z9PNHH32Up59+msrKSiYnJ/kP/+E/cOLECS5duvRAghSfxUchcv1WgfFYLMbExARms5nGxkbGxsY+UQ2CRAcFWH/2E2eYxQY0IyODmZkZYH2z6PF4yMjIIBaLUVJSwrVr1ygpKbmroJHT6ZRjZOFwmNnZWfbv3y8LKVhnOSVuEEXHMjMzE7PZLLucsF4UtrW1sby8LAWcRF64fPkyra2t0v3C4/Hwzjvv8MUvfjGpyE6MqakpZmdnaW1tTep0CwC6pKREzusKgDotLQ273Y7dbqe+vp59+/YxMjJCX18f77zzDi0tLbS2thKPx1lYWJCzx/X19eTk5GC32+VMrNvtlvsCEdeuXWNmZob29napgp6Xl8f8/Lz0lhbiYTabDa1Wi9FoJC0tjWAwiEKhICUlRTZovF4vAwMDpKSksG/fPgYGBpiYmLhr7vD5fBKAb2ho4Hvf+x6wDh4IVpTZbGbPnj2SXux2u1lbW6OwsFCOa4l9gVKpZN++fXIf19bWRlpaGi6Xa1PBYrPZWFlZkQ4I7e3tcp5XOMUIcD0nJ4eGhgZu3rzJzMwMBoOB8fFxUlNTUSqVmM1m3G43k5OT7N27l7fffhtYb6jcaZ232+1cvnwZWBcmKy4uxuFwUFRUhFKpxOPxJIEMDQ0N0v5K2GRtjKysrNuqad+qw+z1erl8+TIpKSns2rXrntf/jb7G4ln2er1JbhuCbWYymW6bN3/Sjhh3iq3k+0RWAJA0J367+GnI9T/1BfMngTTb7Xb6+/vJzMxk7969hEKh2/ow3y0iIyPE19bQbFC/FiFUOJ1OJ+GaatL/5H8R93jQPXFK/o52/z78ff3EvV68//7XwONBUVSI+2v/CkIhonPzmP70f93WAzUeDBL4d79MY34+/U8/RU5nBx0dHevCZ48cI/jCD1Gkp6PZ9dFiMzw8zPXr19FqtTz77LNycVWr1ZSUlLBz505UKhV6vZ6VlRW0Wq2ch/V4PJSVlfHcc89x5swZ3G43MzMzVFdXc/z4cdbW1hgfH2dgYICjR48SiUQYHBwE1mnDG32PE30AxeIYj8fJycmRiVsUHnl5eXKheuedd3j66afXr0NC8lYoFDz66KOSDlZTU0MwGExS8BO0Wlhf5IX/4OOPP47NZpOd2oKCAgoKClhYWMDhcJCeni6l9wX1Ni0tjW3bttHb28vy8jILCwukp6ezurrK0tKS7KqL2Eh5uX79Oh6Ph7W1NR577DGqq6sJhUI0NzdLFLg4ATBZXFzk3XffBdYVu3NycigtLWVkZER2yxPf32QyYTKZpPVVQUEBhYWFWK1WFhYWKCgo4OrVq0xOTlJfX08gEOD69ets376dmpoaWfAKQa7du3fLayRAh8TFUlAQRYyNjWGz2aQftwBchMWHuKfFnx9++GFJs66srCQSiUiQRaFQ0NXVxQsvvAB8NPsUi8UkBe9OcbsO8/DwME6nE5fLdV8Fc2JkZmbS3t4uZ/bUarWk/AtVTqVSmWRpIWjmD3rBvJXk/pNQyf7mN79JS0vLJtGQ5557Tv5ZbL6rq6t59913OXr06I/1GD+Le4uNjhdbHbfq6+uTs6lpaWlMTExsKd/7/X5sNhvFxcW3fB4EY21yclI6bAQCgaQCoqSkhL6+PgD6+vpYXV1FoVAwPDzMwsICY2Nj/MzP/Axw+7GRK1euyC5wRkYGhw8fRq/XyzXQ4XAkFfB2u51XXnkFWN9Mzs7OyvUmOzub3bt3YzQaycrKkoCfKCaFveHp06cZGhpidHRUgubHjh3DYrGwurrKt7/9bdrb26mvr5dilZFIJGkcR3wf8bxZrVb5bzk5ObIIDAaD5OTkUFFRIc/VwMAAFRUVGAyGpAJdAMSJ88CCCZYYgt0yPT1NQUEBy8vLdHV10djYKOeHBXNobW2N2dlZ0tLSpKevWAPz8vIoKytL6qB5vV65JyksLJT2jOL4Eu/b0dFReY7r6uro7Oxkbm6O1tZWFhYWWFpaSso/oVCIs2fPEo1GaW1tlTPrJSUluFwuGhoakr6rVqulsbERm83G3Nwcer1eAvEDAwNyPO2DDz6Qo2evv/46+fn5HDx4kO3bt+P1eqmtrUWlUtHQ0CBnkIeHh+nr6yMlJUU+P4FAQNpQAVL3pbKyktraWnp7e/F6vXR0dGyiLisUCpqbm2loaECtVhOPx2lra0saZ6qrq2NiYgKXy8X8/DyVlZXYbDaqq6vvaXTyVh3mmZkZ6S9dU1NzyzGxe4l9+/ZJcbuMjAwCgYBkmwlAPxEsF+Na8OB2mIWDwP3me4/H86nM9T/VBfMniTQ3NDRQUlKCQqGQaPDtCtLbRWRyktVTpyEWI/2P/xDdh5RcES6Xi97eXlJTU+no6ODSpUtojz8i5yNC776HMi8X7ZEj+P/8L1GkpaFqaCBy6RKq5mbiNhuxuXkifX04n/0c0ZER0v/wD/H/rz8hOjuL6X9/E3VLMxGFglB5GRlT0+xXq8lLED5QFRaS8cPnNx27SBKhUIibN29iNBoJh8NysRXS8mfOnCEYDKJUKqXwRmNjo6S/HDlyhBdffJF4PI7FYmHXrl1oNBpJxR0cHKSrqwuDwSDtjYRHMyDPBSALlpycHEl1EUbrgorT0NBAT08P4XBYbhrC4TDbt2+X6J942EURJ7yUEyM7O5uysjJpGyS8J7dt2yZFLISStdvtlsp827dvp62tjVgsRnd3t6QM+f1++bnZ2dkSXNiIngnl58bGRqkSXVJSwujoKCUlJahUqqQF4KGHHtp07RJprWLmXPhM+/1+bty4QXt7+6ZFr7GxkYaGBhQKBcFgEKvVSmlpKU1NTXJDJTyfYX1WurGxUVpLeDwe+RqdTodCoZAda4/Hw8mTJ2Xn2+FwYDKZUKlUEi0cHh4mOztbbhhKSkpQKpVUVFSQnp4uKXGJNGufz0c8Hk9Kjnq9nubmZhwOB3l5eZK+o1arb9lt3njubmU1V1VVJcXNthoKhWJTsZ1I+Y/FYtJDNNETMlEZ9UdtZ7GV+DgF8/36Mubk5KBSqZIE5WBd5OZuTA2v18t3vvMdfvM3f/Oun1NVVUVOTg4TExOfFcwPYAjHi0RGyP0+G0tLSwwMDFBQUEBjY2OS7+39FszxeJwzZ87g9XqpqanZ1NEKhUL09/dL1WIxfyvWE7vdjt/vJy8vj9TUVHw+X9IcqnhOYrEYV65cYXx8nNbWViKRCGNjY3R0dNDQ0JC0Fqanp/PEE0/I86JUKjeJHsFH+hOw7iYRjUZJTU2lurpaUp63bdvGBx98wMzMzLqA6IejR/n5+TQ3N8u8ZDab8fv9mM1mOjo6qK+v5+///u8lKF5dXU1RUREWi4WcnBxmZ2clwJCY64PBIGazmZycHILBIBqNhn379km6OKyDAcK2EtbHjjQaDcXFxezbtw+FQkFOTs4m94NbUe1bW1vl93zzzTfx+/2UlZVhtVoJhULU19dLXZB33nkHn89Hfn4+R44cIR6Ps7i4yPvvvy8ZVKL40Wq15OXlYTabN80az8/Pc+HCBTIzMzl27JhUlL5586akgNfW1soRq9t15MQ5i0ajDA0NYbVaycvLIxKJ0NPTQ3t7+6ZiJTc3l2effVb+vbe3l9zcXGn7CcgiVDiWxGIx2cwQ9ppiLwNIESyfz8epU6dkrhdMvkgkwvz8PH6/n9XVVbKzs2XuF64kGo2GY8eOEQqFZKdW5PpwOIzX692k/9Ha2srNmzepqqri3LlzxGIx3G73bZWUE+NWHebi4mImJiYwGAybmAj3E4LeL0Kv129y2xBguXiuBFAeDocfyIJZrIv3m++9Xu8mWvTd4qch1/9UFsyfNNK8e/fupI2cuHE3igfdNUIh+DChx/0fGbTH43FmZ2cZHx+nurqayspKwuEwqZNTuH/5/8Lw+c8RnZnB82v/EVQqMt85R1b3NRQaDVHbCq7HHif03e+hPXSQ0Nw88aUloh/eVMEXfkjkQ4++4Ftv4VmxMTkyQuy3fpPI++dp/bD7d7fIy8tjdHSUaDRKb2+vnAednJzEZrMxOzubhNTEYjEWFxc5ceIEeXl5DAwMsLy8TGdnJzt27MDhcEiVTGE7Mz09zezsLEVFRTz77LMsLy/z+uuvA/Dwww9TXFyMQqEgFotJm4ra2lr6+/tZW1ujt7eXL37xi0nHLWi7AwMDFBYWMjAwwODgIOXl5RgMBq5duyaL0TsJKV2/fp3Z2Vnq6uqSrKMSrToSFw+R7BcWFqirq5PddxHNzc1oNBpsNhsulwu3201tba1UiRZUXFEsCjGQ+fl56urqqKmpYWlpiUAgIN/X4/EwOTlJSUlJEr0uPT2dqqoqcnNz5cYDkDT0paUl8vLypPJjQUGBRJnF/W02m2WxX1VVRVdXF8PDw+h0Oqqrq6VgWmII64v5+XkOHToEIOnpSqVSzvsAcgYqEAiQlZXF6uoqPp8PpVIpWQU3btyQ4ip79uzh3LlzqNVqTp48icFgkGh1PB6XnXRYX1AHBweT1DQhWVTudnE7UKyqquq+imWhAKrRaG7r4bkxlEqltGWCZE9IYQdz7do1iUgLwOEnHR+nYL5fWymtVktHRwfnzp2TzIxYLMa5c+f42te+dsfX/sM//APBYJAvf/nLd/2c+fl57Hb7Xemvn8WPN+LxeFKxvJVcH41GGRsbkxoGG6+x8GK+37gdBdnpdNLb20tGRgZ79+5Fo9EQj8fp7++nqKhIAs/xeJx9+/bx1FNPEY1G0Wg0koYsaKiiSy28boPBIJFIhImJCfLy8ujp6ZF+y9nZ2fcE8hsMBpkbhAAUfEQlBZLOkdCOKC4ulp3P4eFh6uvr2bt3L6Ojo0m5obOzk8uXL+Pz+bhw4QJHjx4lFArxwgsvEAwGaWpqYufOnTIPi/OVlZVFXl4ew8PD0lFjo6hPa2urnG+NxWL88Ic/lNTjS5cuYTKZpGfz7bp2s7Oz9Pb2YjQaN1HEE2nzIoTLx9ramuxWJ65jJSUllJeXY7fbpUdtRUUF2dnZuN1uScUVIlQOhwOv18vS0hImk4mnnnqK+fl51tbWZMEmgJG0tLQkBwkBwioUCqqqqnj55ZeBdYBGqG+npKRQW1vL6OgoKpWKtra2JGBlbW1NFq6Tk5M0NTURDAYJh8OS5r3Rg7m3t5ebN2+iVqt5+umn5UiBYOWJ4xHnTq1WMzMzQ0FBATMzM+j1ekZHR9HpdFLIS+jKdHR0MDIygs/n48CBAxQXFxOLxXj11Vfx+/2yky6+59WrVwkGg9TU1KDT6fD7/feU6+HWHeaMjAzJaLzXmJ+fZ3V1lfr6+lvOUW+MRLeN0tJSWeSLeW0xC5+dnS0ZZ5+U28bHia1qqfh8vvsumH8acv1PXcG8EWneCiojNtj5+flJSLOIRG/G+ymY1Y2NGL/1t8SdDrQJHreDg4Osrq7S2dkpF0SlUknFt79NyLpE+Oo1Uv7FL4ovCNEoCoMBhUpF+IOLxIXtQ1ExmqNHUbe1QjhMpK8fwy/9azDoiS8s4srLQ/tPf4FyQP9vfonAn/05/j/7c7Q/+Ac0d/D9m5+fl/ZOsF48WywWCgoKpJhXQUEBSqWSgwcPcvnyZSmCYbVaSUtLkwIPKSkp7NmzR75XLBaTNClhVaBQKDZtfEQxKoRExsfHyc/Pp6ysDL/fT3d3NzqdjrNnz3Lo0CFZ1AYCAVZXV6moqGDv3r1yBmpxcVEuZHNzc7S0tPDGG2/gdrvZuXMnsViM0tJSuSgJ1HpxcZGOjg4OHDhAT08PDodDehgKpDslJYXW1lb6+vok5To/P5+UlBSqqqooLS0lPz8flUol1bcFuii8kYX6qEi0TU1NUpRD0MUEFUwIqFy+fBmbzcbU1BRPPfWUPHfnzp0jEAgwNTWFTqdDr9dLATOfzyf9nsU5np+f58aNG6hUKk6cOEFqaioFBQXo9Xq0Wi3Z2dnodDouX74s56MOHTq0CekVz0ksFuO1114jKyuL/fv309fXJ9XEhUjW1atXpa/zF76wLnwndAM0Gg16vV4mX1inxQuhueXlZdbW1tDpdBLAMJvNZGdno1Ao5EZBMBYee+wx4vG47CzE43EGBwfxeDzs2LEjKbmKdWR1dVXS1LcS09PT9HwIXKWnp9+ThcLGSPSEzM/Pp7e3l9LSUpxOJyMjI1KMRiTUH5Un5N1iq/NWW+kwA3z961/nK1/5Cp2dnezatYs/+IM/wOv1SiXNn/u5n6O4uJjf/d3fTXrdN7/5TZ588slN4h4ej4dvfOMbPPPMM9K+7ld+5Veoqanh+PHj9318n8WPJj6JcSuPx0NfXx9KpZK9e/feErDZSodZoVBw4sQJlpaWpGhSIgW7rq6OsrIyebyJSvqPPPKIXMdEx0soSNvtdnncNTU1xGIxiouLuXnzJo2NjbKora6u5syZM8RiMaqrq5mammJ+fh6FQpFkubcxQqEQZ86ckd9XOCloNBpKSkqYmppCr9eTlpbGzp07CQQCMjcK9tDVq1dZW1tjdXWVz33uc3KNj8fjhEIhamtrGRgYwO12y2umVqvlWpt4rkOhEO+88w56vZ7q6mqZx5RKJe+//z5dXV1JdosWi4X8/Hy6urqYnJyU88Pz8/NSRdrv9zM2NsbY2JjU2cjOzpb5QNBv19bWCIVCUlTI6XSye/duwuFwEjNp7969nDlzBr/fz+joKO3t7YTDYfLy8qiuriYvLy9JQDRRfXtoaIhoNEpGRobMC4WFhczMzDA4OCi1HCYmJlCpVDz11FNoNBrGx8fp7+8H1gs6cezXr1+XdO+RkRGysrIkCy8YDEpKtBBEhfX9TyAQYP/+/ZSWlpKWlkZubi6rq6uUlJSQmpqKVqtlbm4Oq9XKiRMnkvRd4KNcr1AoOH/+PNFolM7OTikSOjk5SWtrK7BehAvqfFdXF7t375YWmMvLy6SmpibRtufn5yWLTTQYUlNTJRPCYrFQV1eHRqMhEAjIn7tcLk6cOMHa2lpSN35ubo6ZmRkaGho20auj0Sgej4f09PQtg89er5fz588D68+v+N73E0qlUo7GVVZW8t5771FRUUEgEMBsNjM0NERaWloSWL4VT+OPGxtHCO41tkrJftBz/U9NwSyQZrPZTFZWliwK7idisRijo6O3RZpFJHaY7ze0ez8qFhMp2BvtqZRKJcGcHAzWJXCvEXznXQB0P/tlPL/xm4QvXCDt9/8LkSvX5GuC/+f/oPvic6R+7V8C6+fE9TNfJnLlKq5//ovYfD7EpJIiEmG5uprp3V002u2IXpnX6+X69etkZGTQ2tq6idr2yCOPUFhYmGT83tjYiE6nY2FhQXoaX758WV4PsQj7fD4yMjKYnJykvLyceDzOSy+9hNfr5ciRIzz++OP4fD45f5ufny/nU0tLS/H5fMzNzeF2u/H5fExPT1NTU0NjYyNpaWm8/fbbuN3uJI/H6elp2aWtqamho6OD0dFROb968+ZNamtrpRUErM9Fh8NhLBaLpKzt2rWLyclJSYfyer243W7cbjd1dXVJM8OwjiqPjIygVCpRq9Vyhra4uJjz58+j0Wg4ceKEnNPZiC66XC7MZrMUt5qampKdCmGjAcnIntFoxGazEYlEWFhYoKioCK/XSyDwEZshGAxy8OBBioqKuH79OgcOHCAcDssFHtYLOrfbLUcShLrok08+yfT0NFarlbKyMoxGo7SNePHFFzlx4kQSVbCyshKfz0csFmNychKn00ljYyMul4tgMCh1AYShvfg+AvnX6XRMT08TiUSIx+N0dXUxODhIJBJhZWWF1NRU0tPTGRwclB6QNTU1TExMMD4+TnFxMQUFBZJKqNfrZRGdGEIoDtYp0S0tLfLfYrEYNpuNs2fP0tLSIu1B7jdEclAqlUkMha2GKErFzLzw5hQzUT9KT8i7xccR/bpf1BngC1/4AjabjV//9V/HarWyfft2XnvtNTneMDs7u+l4xsbGuHDhAm+88cam91OpVPT39/PXf/3XrK6uUlRUxCOPPMJv/dZvfebF/IBELBbDarVKf96t3NcWi4Xh4WFpcXi7e3YrBTN8pAUBmynYG2nAifeVKBYyMjIIhUL87d/+raQui7BaraSnp3P69GlUKhVVVVUMDg7S3d1NTk4Oc3NzSdRrUYAvLCzIvC7GhILBILt27drUsWppaWHHjh2yaBegsEqlwufz0dPTQ3Z2NuFwGLvdjs1mk8XG2toapaWl3Lx5k8LCQtLS0rhw4QJTU1Ns27aNRx99VFpDinN88uRJVlZWqKioIBqNMjExQTgclnl2dHSUzs5OnnnmGb797W8DMDQ0JPdpa2trcjxKAAgejwej0ShHXLKzs0lNTZUsq/HxcQmkPvXUU6hUKhobG4lEImRlZZGSksLa2pocGVteXqajoyPpPImC2+l0UlBQwKuvvorH48FkMtHX14fP5+Ohhx6S33Wj+rbX62V5eZnu7m4ikQixWEzeD2L/IP4srmkisDg9PS3HtRJVooWuy/Hjx5mampK0erEXUSqVssiE9UJybW2NqqoqKebpdDrJysqSTDCFQsHZs2fZvXt3kkhmXl6eZIeJ5oigYHs8HqkUrlAokvKfeObUajVWq5VAIEAgEODAgQMMDg7i8/lwu92kpaWh0WhYW1uTz0dHRwfd3d3Y7XYGBwfZsWMHRqORXbt2yX2ZVqvdVBRfuXKFcDiM3++XntwiBHsrOzt707/da2g0GqmQ/knN6cbjcXk/wvp64nQ6cTqdjI2NEQwGpa5AVlbWjw0s/zhssk9jrv+pKJgTkeaxsTF27Nhx35tSr9crUa/bIc0iFArFHWlasdVVPL/52yizMkn91X+PYgPycysK9saEr1QqCebnw+AQ8TU3kfPrtgnRsTEiV64CEPzhi+g/9yzBl14CpRLCYcLnLxCPxVAolRAKEbl6DeJxVN032P7X/wdVWyvxYBDN/v30mYyE1Gq6nU5ZMI+MjEiEsqKiApPJRHFxMY888oic3b5586ZUHK6rq6OgoICRkREWFxdpa2uTQluhUIgdO3bw+uuvEwwGKSsrk/PEKysrNDQ0JKk6t7e3b6JYiSRjs9no7++XaKfX60Wj0cjfz8/PlzSyoaEhamtr0Wg0FBUVJXVGhXKheKjEJiQej7Nt2zZWV1dZXV2VMyNjY2NMTU3R2tpKdnY2fX19bN++neLiYiYnJwmHw1y5coWWlpYk+6b5+XkMBgM7duwgGAzKe0UoIScqRgPS/1D4TWdmZspugpg3NplMWK1WqXadn59PZWWl7Mp3dnZK+4j+/n4KCgrweDxyw5eZmUlubq4ssJaXl1lcXGTPnj20trYSi8Wor68nHo9z48YNlEqlNJgXyfXKlSvAOp354MGDjIyMMDAwkITMiu8vnqcdO3aQkpIiZ2+rq6sZHx8nNzeXl156CbVazYkTJ1hZWWF1dZXLly9L3860tDRWV1cJhUIUFhaiUqmk4mljYyN6vZ6JiYn1Z2NDoebxeHj55ZcpLi6mpaWF8+fPYzab2b9/f9L6kJ6eTmpqKn6/f9MMeeJoh2BNbCXy8/N5/PHHUalU9007vlVs7OIKVdaUlBSKi4vv6gmZlZX1Iyv+tpJEBctiKx1mgK997Wu3pWUJwbvEEPf5rcJgMMhRkM/iwQrheCHmH1NTUzd1u+4WkUiE4eFhbDabtDy8U9ypYI7H4/T19eFyuejs7LzlJtDhcNDX15dEwd4Yic+iKHoEaArrRZEQOIpEIkSjUdxut7RpBCQwbLfbefzxx1Gr1djtdsrKyrDZbKyurko2jsglYn3PysqiqakJrVbLqVOnsNvtGI1GRkdHSU9PZ2hoiKKiIioqKlhbW2N4eJjKykqqq6vp7+8nEolQV1dHT08PFosFjUaD1+uVtOFnnnlG2kMtLCzQ2dkpO+8ixPiJKMZhvfjIyMhgbW1N5mq1Wk11dTWTk5MsLCxgs9nIzc1N6oyWlpai1+uTVI0T9T06OzuZmJhArVYzPz+PUqlkZWWFnp4eiouLqayslJZi1dXVlJaWsrKywuzsLIFAgL1798o929LSknSFECNVsF7UCO0XIf4mYnFxEa/XS1VVlSyqRJ5JT0+X9PlQKEQ4HKa2tlbSoQFKS0ul+8PIyAhNTU0EAgHS09Ox2+2kpqaSnZ0tBbhsNhsLCwvodDr27dvH0tISDQ0NGAwGhoaGZDPCbDbjcDjYuXMn77zzDvF4nEAgIL24z507ByCbC7DO4nv//ffltcnKyiISiVBUVCS7xTk5Obz++uuEw2H2799PQ0MDo6OjvPfee/JeTSwuQ6EQhw4d4vnn1/V0iouLyc/Pl2wG4Q4i1NjVajWvv/46arWahx56iKGhId544w06Ozs3zbcWFxczMzOzqcmReA3cH7I2txJarZbHH3+cQCDwiVjRiWZg4t5Gq9WSn58v9yuicSEKfiF6K8Dy27ltfNzYKjju8/mSAMD7iQc51z/wBbOgYIsLl0jtudcQndGSkhLq6+vv6Qa4UxINPv8CoQ+9YbVHjiR1lW9HwRYRuXkT73/5r2h2d2F7+CiFWi365mYUxcUE/uIv0ezYQTwcIXrjBpEbPWj/8i/IHhog8PqbeH/pl4jNzxP87vfQf/E5rA4Hlq/8HIVTUxT9+3+PVq/H19zM3NwcpX4/+qwsQmtrSYmrqKgoCaUVAk6rq6tcvXp103e1Wq0oFAoqKyvZs2ePtFkyGo3S8kKj0UhfQhFzc3M0NDTQ2dkpLYfefPPNTfPiYjZrenqabdu2STT7ueeeS+p+a7VaysvLGRgYwOfz4XK5WFpaIiMjg6effprJyUncbvdtN1cKhYLW1lbC4TAjIyMANDU18fzzz0vxDFHADg8Pc/DgQU6cOMEPf/hDgsEgw8PDsmAW82jxeJzR0VEOHDggrR5SUlLIzc1Fp9Ml0XInJye5fv06gKQ8iQ6tRqORc0nCO1pQunp7e2WSysrKoqqqisnJSaqqqrhw4QIWi4WioiICgQAOh4Pc3FyUSqU8R7CuCJooiHHu3DmJ/otZL4PBkFQEjYyM4Pf76erqIhqNMjs7K0W6tFqtLAoVCgUFBQUyccO6D2lbW5u0JRNenoJK5XA45Mx7ZWWlnG0SFhsCrBId/FOnTsmOuKB0qdVqRkZG8Hg8jI2NkZmZKcUiLBaLvAZ6vZ5IJMKBAwduScNSKBTk5+eTk5NzSz/r+4mtFoO3irupZt7NE3JkZEQqmYsi+pOidP04Z5g/i388sZGCrVar77vzK7Qu9Ho9+/btu6fZRmGhc6twuVwSGExLS0vqPgov8ampqU0UbECCrWI8pqSkBIPBQHV1NTdu3ECv12M0GllZWZEg6+c//3n8fj8vvvgi4XCY7u5uDh8+jNvtRqPRkJ6eLoubaDTK8vIyTqdTqjlnZGTIwkTMQYZCIcbHx2lsbEShUBCJRPjggw/kd9bpdFL08caNG+Tk5LBr1y5yc3MJBAKkpqZSVVVFU1OTFFTUaDRyfRKiX/v27WNychKj0cjZs2dpbm7e5JcsgPHCwkJKS0u5dOkSTzzxxKbZ0pqaGiYnJ6XdpcfjIRQKcfz4cebm5mShersoLS1Nopg3NjbS09Mju3a5ubmsrKzgcDiora1l//790hlidnZW2jHBupK1y+ViYGCAbdu2sXv3bpaWlvB6vZJRlZj/3G633NhHIhEaGhpIS0ujq6uL1dVVtm3bhk6nk37OgjU0PT3NxMSELISKi4ulB7LZbOb69etSU2RychKVSiWBYYvFIkecnnzySXneR0ZGGBoaQq/XS8tLkevVajXhcJi1tTXOnDlDc3Mze/bsYWRkRNqHZmdno1ar5T1iMpmSrJxSU1N59tlncblcciZ5bW1Nunn4/X5mZ2eZmpoiPz+fjIwM2WAQ97Pb7WZhYQGLxcJDDz1ES0sLoVBIssrC4TCLi4tS32R+fl7OYAvBtHA4jNFolMBOZ2fnLYEro9FIRkbGJjDnfkOn031igPTtnDoSQzRaBFju8XhwOp3Y7XYmJydRq9VJYPm9znTfLX7cHeYHPR7YgjkRaU4U+7gf+lQkEmFkZITl5WXZGb3XuFMS1XTtgtRUlEYj6vqPRIYEBTstLW0TBVuE/8/+nPDb7xB++x34g/+O6v/5HVJMJkJvv0N0aAj/0BCaAweIAuh0oFCg0GrRtrXgVakgGiUWCjH/5Z8l6PVS9hv/Gf03/zfBv/wmmt/6Bm+//TZ2u52bN2+SmZnJwYMHZZc2FAoxOjoqi6RENTqBDoswmUyy4IrH49TU1KDX63nllVdwOp0UFhZKka6TJ0/KIfqqqireeOMNiT7v2rWL1dVVXnzxRWCdYiVmgLRaLT09PXg8Hrq6ujAajczOzsqieaNKZFVVFW63W1LSxIxPbW0tN2/eRKlU8vTTT+P3+1laWpIodGIMDQ3JglkoUk5OTpKfny/R0kSRjW3bttHd3Y3P52N8fJy6ujoUCgW1tbWYzWaqq6tRqVS0tLQwOzuLy+VKovyKSKRghUIhXnvtNXQ6HTt27ODq1as4HA727Nkj73PhWXz48GHC4bCcbbZYLJLeJBKIz+eTGwjxM+GFLJKTmCkRGxDxu48//jjhcFgCDY8++ig+n08iymazGZPJhMfjwePxyM66wWDg1KlTBAKB24peVFdXEw6HMRgMZGVlUVlZyfz8PNXV1bLDYLfbyczMZGVlhfPnz3P69GmefPJJ3nrrLekVmtgZHhoakuyDxsZGRkdH0Wg0mM1mDAbDOnMjGOTVV19FrVZz7Ngx3nzzTSKRiJzhSox4PC5n0u81FhYWuHr1KkVFRfekzLmVuF9kd6MnZDgclj6iiZ6QiTNRW6V0CVGX+42tzjB/Fp/+uJXjxf0UzImsLtEZvdeOy53YZGlpaZhMJtxud1LH5G4UbFgHjYWIVnl5OZWVlVRVVREOh+UcbeJ7Clp0amoqer1eCm+eP39eAtDZ2dlMT0+Tm5vL9PS0nM9ubm6mq6uL2tpa+b1FnoP1vYnIuTabLem8pqenJylnZ2dnk5uby/Xr1xkaGiInJ0d263bt2kVpaakspH7wgx8QDAbp7u7m6aefpri4mO9+97vSirCoqEgykyYnJ+Wsa1FRkRznWVpakt6/InJycmTnyGQy8dZbbwHrxWiia0VWVhbT09NJa5+IpaUl2QTIy8ujsrKS5eVlsrOzKSoqwuFwJBVO1dXVzM3NEQqFuH79uhSyrK6uxul0SkCksrKS3Nxcuru7b2k5qFKp5B5Lq9Vy4cIFXC4Xe/bsYXFxkffee4+9e/eSlpaGVqtlfHyc5eVl9uzZg8lkwuFwSJsq0QEWIzjBYFB6I7vdbpknCgoKmJ+fx2QyJbmOCKurQCDAI488gs/nIzs7G6VSycmTJ+U8bjAYZGhoiMOHD0tQZHx8nJqaGuLxOCdPnsTtdku7p43PlslkYvfu3Xg8Hurq6lhdXcVisdDS0iJZazabTY5UXb16lby8PE6cOEFfX58E1y0WC10fWrI6HA65B62rq8Pv9xONRpmensZkMuH3+8nKyuLll18mGo1y4MAB2fiorq7elJsFKNPc3HzPBaXX6+W9995DrVZz6NChH4kQV6JGw72EQqGQSvpiFEGA5YluG4lg+b0Ik90qftx6JQ96PJAF853EPlQq1SZVyluF2+2mt7dX+h/eL+Jyp8JcvW0b2T3doFSi+HB+yGw2c/PmzVtSsGNuN6Gzr6HZtRPt0aMEX3oZdWcH+hU7kedfIP6lLxJ6/72PPiDDROpv/gbaw0dQCGElux39z3+FWFMTk+YZCj+4hB7QffvvCLxyhrDBgPbhoxKtCofDUk1chMVikbQuYSmwtLTE7OwstbW1spMp0FfREYV1oY8TJ05IYSa/3y83GQaDAa1Wy8TEBJWVleTl5ckEAx9RkOx2O2NjY0xOThKJRMjJycHhcBCPx2lubsZoNEq1YTHPJNQR/X4/r776KuFwmOrqarxeL4AUjIL1joRSqeS9996TitLxeJzS0lI5myo6XFqtFrVazbZt25icnGR4eJj29vZN9iAVFRXyPAj7H5vNxrZt2yguLsbhcMgZqTtt0DQajdzICTVNWO9mC2XU+vp6cnJyWF5elrSvxcVFamtryczMlArYkUgEi8WCTqcjNTVVzr54PB6pVio6v3Nzc0xPT+PxeHj44YeTNoaJ9kXi+wlvw+LiYlwul1Qbz8jIkL7NYiaqs7OT7u7uTarVItRqtTzvguYnjk1EWloa6enpcmZZXDvhK6lQKJidnZViDpmZmdhsNjIzM9m2bRvbtm1LoicLpB6QtE7xDHg8HkZHR4nH45JpciubibuFKEAnJydpb2//kYhxfFxfRo1GIy3YgCRPyKGhoTt6Qt4totHofaPrgmXwaUyin8XWI9HxQmxoE3O9KA7uFImsro6Ojk2F093ijrlereb06dNJHVBBwc7MzNxEwRaFu06nIzc3V+Ymg8EgBasSRz/C4TAdHR3k5+fLNc7n81FZWSk7gAMDA8BH85ewDhyK7qJwfxAFNnwkqAjra2xbWxvhcJj+/n5yc3Opr69HpVLJMZi3335brpPCwkrQY10ulyzsVSoVmZmZzMzMUFpaKh0qEn2ea2pqpO7E888/j8/nIzMzE5/PRzAYZGVlhaKiIhQKhXQ+KCwsTJopffPNN6Uzg6CbCnBThFarZWBgQILlOTk5aLVa9uzZg1qtljo38Xgcg8FAXl4eN2/elGrVn//855OudXZ2tqQ8O51O3G43k5OTlJaWcuzYMcxmM2traxiNxjuulSDCemkAAQAASURBVNFolMrKSql4LArGkZERWfjOzMzQ3NxMKBSSM7uTk5McOHBA5kTRRbXZbHIkx2g0yoK3pKRE3nt5eXl4vV6sVitLS0s888wzctZW3MdCRwXW88Hk5CS5ubk0NjYyNjZGfX09BoOB8vJybDYboVBIAhX19fXMz8/j9Xppa2uTGjKJIWae4/E4Fy9elIKsojsthK5gPT9NTU0xMzMjQZ54PM7q6qqkYIvf1Wq1VFZWyr1NopaH1WqVz67FYpFUa4/Hg8ViwWaz0dDQgF6vl3vj+8n3i4uLsmhfXl6WAnefZHwcAWPxOlEYw0duG2IvNDg4SHp6uiyg78dtY6sdZuEE82mLB65gvpu38t06zPF4nLm5OcbGxqioqKCmpmZL3H6BOse9XriFmI6YWxbJWsw43crHzfPr/5nQiy+hyM4m6+plskeGiHs8VO3sIh6J4LPbiYyOyd8Pv/QyrNgxfCiRHvf7cX3pyxAMsnLgAOpf+Kcoq6ogHEb3uc9xRa3GUl9Ho0GPhvVFYW1tjbW1NZaXl3n66afRaDQUFBRgMpmIx+McPHiQ1NRU/v7v/55QKITD4eD48eMyqXo8Hk6dOsX169flPI7b7Wb//v0sLS3hcrm4du0aKpWK7OxsXnvtNSlwceJDhXARN2/eTKJQJdqBicVidHSUnJwcOc8B64tVU1MTCoUCv98vaT6C1pSdnU1KSgoGg4HCwkKMRiMajUYWMH6/Xy7aDQ0NrH1IT8/Ozpb3VzgclsezsrIiVSNFqNVq2tra8Hg8NDQ08Oqrr8oCbW5uTiLAwrPxVhGJRHjvvffkgt3c3MzU1BQKhYKSkhJZLIp7p7i4WAIMfX19slNeVlbG7OwsbrdbzhC1tLRI+nYwGGRwcFCi7dFoFIPBQDAYJDU1lbGxMSnO4fF4ZPexuroaWKdqC7/FRBXusbExfD4fdXV1Et2HdVBKfCev1ysL5ng8zsTEBMFgUKrQJ17/lZUVTp06xejoqPT8Pn78OJFIRM5QKZVK8vLyWF5eZmxsjLa2Nmw2G/X19dTW1krxELEpSk1N5caNG3g8Hnbt2sXs7CyxWCyJ5i02QLBOJSsrK7utzdidoq6ujrW1NYqLi39kypUft2DeGPfjCZmZmSnF6m4VW0miAgD6pERSPouf/ojFYnJeFzarYN8Lm8zpdNLX10d6evptWV13C5VKlQTQ32psQ2zoBQW7vr6e0tLSTc/I1NQUFy6s65GcOnVKFmU/+MEP8Hq9OJ3OJDElm82G3W7nS1/6kvzZ+fPnsVqtqNVqqqqqKCkpYWlpierqapnXBZAK6+vt0NAQ8Xic3Nxc8vLy5AjT4uIiXV1dlJSUcP78eZl3fuZnfgalUinHoQ4cOCBHgEQDYPfu3UnUV5VKRWtrK++88w52u52JiQlOnTolBanE95mfn5fXTqz7gUBA5u+pqSlZJIlc73Q6CYVC8vqJGVqn00lGRgZPPfUUkUiEzMxMObOakZEhGwAKhUJ27ZeWljAajXLW1Ov1yuJLgL1erxe73b5JVXfbtm2YzWZqamq4cuUKNpuN6elpUlJScDgczMzM8Pjjj9/xfhKvs1gsnD59mtLSUhwOhxTO8vl8kumk0+moq6tjfHwci8WCxWKhuLgYk8lEaWmptBwyGAw8+uijslCMxWJMT09L0S4B2sM6OONwOLh06RLp6elyPvvy5ct0dXWhUCi4evWqLNRPnz4ti9GVlRWWl5cldVqE1+uVStYb53+XlpakvWZqaqoUqIR1kabHH3+cmZkZent7GR0d5dixY6SlpfHyyy8TiUSki0l/f7/srgsK+enTp/H7/YRCoSTwaWpqiomJCclWcDqdqFQqjEYjoVCIjIwMyZILhULs2rXrnqjPG0PMQ6vV6k36J59UJIrufRKR6LYBJNH+R0ZGCIfDmEwmCZanp6d/orke+Fh6JQ9yPDAF8716K9+JppWINLe3t29aDO8nVCoV8Rd+iP33/1/Uu3Zh+rtvbTqe1dVV+vr6SEtLY+/evbdN1ooPuzEK7fqCplCpiKtUoFZDJILCYCDtP/1H/H/xTcKDg8Smp4mazcRW7Chzsom43cTUapTBIJnVVeTv2wdvfaQI55ieAr8fq8tFXV0dy8vLGI1GXC4XgUBAJuWcnBxOnDjBxMQEfr9fFmlLS0tkZmZKSnl6erpEzvft28f3v/99wuEwQ0NDHDhwgOrqav7mb/6GeDxOT08PjzzyiETDNRpNEv336tWrjI2NEY/H0ev1kkqTm5vLrl276OvrY3h4WNLMTCYTOTk5rKysYLFYmJ+fp7S0lKysLPbu3YvX66WhoQGFQpHU0SwsLMTtdnPp0iUyMjLIzc2VvsMlJSUMDw8zNDREeno6xcXFskA/duwYhw8fZmxsjNnZWRYWFjh9+rS8lgMDA1Liv6Ojg5SUFJmAl5aWCAaDSah3LBbj8uXL2O12du/eLdHg1NRUqeiZlpZGVVUVPT09XL58mdOnTyd17ITFh91uJxwO4/V6GR8fR6/Xc/ToUUZGRojFYrS0tKBSqTapbzscDubm5vB6vcRiMfLy8qipqeHSpUtyVi0ajRIMBhkdHZUFs4hAIJC0UI6PjxMKhSQCPjk5SXZ2NvX19aSnp0uLLhGJ7AQxq5XY9dFoNKSlpclOy9zcnLTkKi4uxuv1Ul5eTnZ2Nn6/n4qKCsbGxuQ8d319PUNDQ+h0Oqki63K55FiB1WqVs/mwnuwXFhaSOjuzs7OyM3O/kZ+fz2OPPXbfr7uf+KQL5sS4myfk+Pg4Op1OJtSNnpBbEQIRjJBPI+r8WdxfJHorC3rnrXL93cS4RPFaW1tLeXn5lkVvVCoVTqeT73znO6hUKk6dOrXpPhWq/36//7YUbPFeIjZ2ywHpFe/xeHC73SwuLqJQKKR1o5hlhvXOWldXV9KzJtYxj8dDbm6uBIhFgTI3NyeLzQMHDkj3hXg8LsduxKyn0AMRuiIlJSVSC6S3t5cvfvGL7N+/X/rh9vT00NjYKNcCrVbL2toaaWlpsvi+du2aPP78/HwCgQApKSns2rULj8fDu+++i8vl4uLFizz00EOkp6fjdDoJBAL09PRIOu6RI0eYnZ2VlOfEzbcoEHt7e6WwVmZmJmNjY9Lz+pVXXkGpVNLZ2cnVq1dRq9U89thjPPTQQ4yNjTE+Ps4bb7zB4cOHZQG+vLzM+++/j1KpZNu2bdKVIj09HZ1Oh8PhSMr1AhgeHh6mqalJdtlNJhM2mw2j0SgpwGfPnpWuFRvFqCorKxkfHwfWi9GpqSnW1tbYtWsX8/Pz2Gw2Wlpa0Ol0Sa4JXq8Xh8MhO+J+v5/MzEzq6+sxm834/X78fj8lJSX4/X4pLGcwGJKeK7vdLr9X4usOHToki0Uherq8vExd3UdjiPF4nPfee0+K1B04cAClUilnk5VKJVqtlmg0SjQalaN6lZWVbNu2jYmJCRobG8nOzpasOZVKxdmzZ4GPlLJh3cFF7OmHh4eJRCKMj4/z6KOPyuMJh8PMzc0RDAalYJjT6ZSzznB/HWaDwcDDDz98z7+/lfhR5npg032TKCAmGA+J88+JYPnHccT4NOqVPBAF80Zv5dslULh9El1dXZXF3laR5o2fo7hyFeJxIlevQjAIHyJciRTsmpoaKioq7vgQpn3jN9AePox6e9tHVhBpaZh/93coi4PhiVMolErS/8f/n+C5c6z9wj8naLcTfOUVFM99AdvP/TwGrxdqasj51/8aWEd8JycnaWtrY//+/UxOTkrfOTFD8sorrxCPx7l8+TJut1vO30xNTaFSqfjiF7/IsWPH8Hg8rK2tcfXqVUkpF0hfZWUlpaWlLC4uJs37ZGdns7Kygt1uZ35+nieeeIK1tTWuXLnCjRs32LlzJ0VFRRKhFkb3aWlpHDhwAK1WSyQSkXOowmpBUI9EKBQKmfz27NnDzZs3WVlZ4eDBg0lUOKvVysDAAKWlpRgMBmw2m6QAq1QqOa/t8/nkhkJQbfLz81laWsJisRCJRHA4HDKJis6YQFdPnDghC2ZhV5XIKgiHw5ISLKwePB4Pjz76KKurq7IjKe7haDTK3NwcFRUVSd3K8vJy3G43ubm52O122dldW1uTHovl5eVJn53YJayurub111+XHYn+/n7UajVarVYqi09PT0tkGdZVRi9cuCBtqMQMV0tLCyMjI9TX11NUVJQ0d3croayUlBT5nHo8Hr773e+iUCgoLS3FarWysLCAw+Ggra2NgYEBrFYrY2NjLCwsSPQ+Fotx/fp1AoEAOTk58voldi1CoRB2ux2LxUJFRQXFxcWsrKwkPYvxeJy3334bj8dDU1MTp0+f5sKFC3JWTViyiM686K4mXk+Xy5WkvP7jiK3ODm0lNnpCRqNR6Rt7K0/ISCRy38fm9Xo3Cct9Fv/4YuO41Z1yvdjwbox7LV7vNYQ1jgDsnU7nplEVQcHevn37HecBy8vLeeSRR9BqtUkClI2NjaysrEh7pz179hCNRvnWt75FNBplYGCAvLw83nnnHZxOJwqFgqNHj0p15+7ubkpKSmhtbSUej0s/3+eee45wOMwPf/hDAoEAo6Oj8py5XC6ZA48fP05zczPl5eVEIhEuXbqEyWRiz549UuulpKSExsZGuru7kyjWhYWFUvfiypUrHD58mKWlJebm5njhhRcoKiri2LFj0sJKoVCQlZWFSqVi37595OTkSDvJ9PR0SdNVKBRoNBpJ2TUYDJw/fx6bzca+ffsIBoO8++67PPTQQ0l5zuPxcOPGDVJSUqirq5PWOz6fj8LCQtk5Fb7MsM7y8vv9ZGdnU1paKgvUhYUFmesFqBeLxQgEAnR2dlJbWytVyh0Oxya6//DwMF6vVzK37HY727dvp7q6WhaJiftVIVSaeH+ZTCYaGxtRKpXk5+fz2muvAeu5RzhEGI3GpFwthOTS0tIoKyujv79f7hFGRkZQqVTodDqMRiNFRUW4XC7y8vJkl3b37t2cO3cOt9vN1atXKSgoQKPRUFNTg91uJyMjg4KCgiTrVVF0bQyj0YjT6USv1/ODH/yAUChEVVUVwWBQfoeqqiqcTidWq5XZ2VlmZ2f53Oc+J6ndQ0NDOJ1OOWIlQuy7YB1MmJ+fJycnh+bmZilsKSjcAH19fdy8eVOyEgYGBhgdHSUUCslrNzAwIFl4iaNI8Xhcqsf/KGaVbxc/6oI5MRLdNkpKSiRb0uFwbHLbyMrKIhgMbskR47MZ5h9RiAQqaAl3Q382zjDH43Gmp6eZnJy8p+L1XkOlUhH4+Z8jMz0d7YGHUHy40IiZorW1tdtSsDeGQqdDd3yz51usoIBoaem6RdSHoenspOerX2GxrIzavDwCH3xAg/i+ExOs7n+IjNfOcuXKFaLRKL29vZw4cSLJPml5eZk33nhDLjzi4dfpdElzT8PDw4yPj5Oenk4oFJL/RSIRzp49K5V3jxw5sunYCwoKkrwLq6qq0Ol0kq7jcDior68nPz8fp9NJSkoKoVBIWmpYLBb8fj+FhYUcOnQIvV5Pbm6u7H7W1tZKCppQrx4aGpKJe2lpST7w4+PjTE9P09zcTH5+vuyeCgqYkOD3+/2kpaWRlZWFVqulqqpKfh9BxfJ4PFy6dElSktvb2zEajeTl5aFSqWThL87nxllOjUZDeXm5tPt49dVXCQaDNDc3c/PmTYLBIDt37pSWD/39/Vy7do3l5WVptRSLxXjjjTcIBAIYDAaZpIQSovhz4lz+2toa77//PgaDgYMHD6JWq5MoVdu3b0ev10v6tkj+fr+fxcVFsrKyKCgoIDU1ldXVVbxeLy6Xi9HRUUpLS9m7dy8TExPS4uNOEY1GKSkpIS8vT3bDYT35hcNhiQILsOcf/uEfAJI6TkK4Dda7JsK6KiMjA5PJhNFoJCUlhffff59wOMzS0hLFxcVYLBYGBwcpKyvDZDJJ0TD4qGgTmygh3rawsEBqauomwYysrCyuXbuGy+WipqYmSR30Rx1bRXY/iRBjFgLN3+gJGQgEmJmZkR0N0Um5U4iZph+HT/Rn8eCGKEpvxyBLjFuB4ysrK/T395OVlcWOHTs+kZEIlUpFeno69fX1qNXqpFx6Nwr2xlAoFElFhgiNRrNpI65SqcjNzcVms7G2tsbly5dlgRCPx3n55Zc5ePAg09PTWK1WrFYr9fX1STobgUCAV199VVKNBcgghIFEmM1mrl27JqmfgUAAtVot55etVisjIyM8/fTTSYUZrAPKQm17aWlJMqCE6KYQmqytrWVoaAiTySTB0uvXr6PVaqUgVXNzMykpKeTn50th17KyMnJzcyksLOQHP/gBsF70CcutmzdvSgEnq9VKX18fhYWF0lUjPT1ddiHD4bCc0xTCcQJYFgVTXl4eFRUVzMzMMDY2Rk1NjXQbCIfDqNVq8vLyUCgUSfu7W+W9xsZG2WG+dOkSc3Nz5ObmotVqJb36wIEDHDp0iNHRUcbGxpiZmeHJJ5+Ua+bVq1eZmZkhMzOThoYGCSBkZWXJ65l4LaPRKOfPn5cjcpmZmUkjTwUFBTQ3N8s8v7i4SFpaGjqdjvn5eal5UlpayvDwsLTHGhgYwGAwcOjQIYaHh5mamtrEPtsY0WhUamUIQVNYH6cT+Vw0lvbu3SvFX+Gj2V1Yn9+OxWJMTk7S3NzM/v375b0htG1EswTg4MGDBINBLBYLExMTUqU8scGhVqslq8zr9XL06FEuX75MTk7OplGkrKwsFhcXGR8fJzU1lVOnTv3YctWPs2DeGIluG8IfXQiIzc3NSaG38fFxsrKyyMjIuKc19zOV7B9RiCL5XoplSE6iQtjiTkqVWw2lUkmkpATjH/6B/NndKNjBl14m8IPnMfyLX0S7Zw93i40bgngshvd3fpeV2vVFasbp5KGHHiL/W3+D7/f+C8GXXibu9RKdXVdnnpiYoLy8nKGhITIzMyksLOTs2bOyqIR1xHv//v1cunSJ2dlZ2b2NxWIMDg4SCoVkx9TtdnPjxg2qq6ulSrhGo8HlckmUtaenB5vNRlZWllSIFgrDKpWK9vZ2vF4vzc3NKJVKGhsbGRkZSVLkFqgpfKTOLQQ/otGoRIjj8Tjt7e1yMW5sbMRut6PVasnLyyMUCtHX1yeppHa7nVOnTqHVaiksLCQvL494PE5rays6nU52zux2O36/n9HRURYWFsjKyiI7O5u8vDyp6Dk1NUVvby/V1dWkp6dz6dIl6urqNm0mEkOhUMi5cZGkRQIRgieA9E6uqqpK2nQEg0F0Oh2xWEy+LhAIkJeXx5NPPolKpZL+fAKZFzE/P4/b7ZYWDULUDD4SOBM0XJPJJJUf8/LymJ+fZ2RkhLS0NHJyckhLS6O5uZnu7m4pCpeRkcHKygpms5mnn376jvd1b28vFouF2dlZdu7cSU9PDzqdjuLiYpkcBFihVqvZsWMHvb29BAIB6TmZkpIir3ddXR1qtTppZq+wsJDLly9LUMRkMskNkU6nw+l08u6771JaWio7IkLPYM+ePczNzdHU1ITP55OiIpWVlUmCGYIaB+uzeU6n82OpS99P/CST6MbY6An5wQcfkJ2djdfrvWdPyE8rReuzuL8QBdv95vpYLMbExARms5nGxkbp0PBJhOig7N69W/4ssYstHBwSw+l00t3dTVFR0S0FkDZGol6HiPHxcQneCUCps7OTsbExbty4AazTZcvLy5mfn6ekpITZ2VkikQg1NTUMDAxINwVY1wc4efIkZrOZGzduyFnU1dVVxsfH5ecXFxdjs9lwu91J+UxQrA0Gg3QeEP7M+fn56HS6pM5z84cWluJnFRUVrK6uylElWAdyRUfe5XLxwQcf8OUvf1nuLwQgPjc3x+c//3lqamqw2Ww0NjbKDnFVVZUsvKamprDb7VitVoxGIwUFBXLsZ2lpidbWVnJzc2lubsbtdmO324lGo1itVskUys7OprCwUNKNA4EA7777LqmpqbS1tXH58mUsFgv79u277Ros7LlGR0fR6/WyAId17ZTEXA/rXXpBfw2Hw9IKTPw+rOd64ZMdDodlFzAcDidpPySOH01PTyeNMsL6bLfQrMnNzeX999/H5XKRn58vbYg0Gg0pKSkUFBRQVVWFxWKRStWJWh85OTl33FdPT0/Lbv3OnTsl3buhoYGZmRlisZgU/gTYu3cv77//PqFQiPPnz3P06FEAduzYwejoqKTgJ4545efnMzY2Jotlg8Eg9WoikQh6vZ5XX30VrVbLzp07ycnJkaBXW1sbarVarheC6bZxFGlxcVFeH7/fz/LyMllZWVtWl76f+EmC4xsj0W2jurpadufF8ye8wBMFxG517D6f71OpV/ITL5jhzrSsjSHmdex2O/39/bdUqrzfiC4sEL56Fe3Royg/RPISrSbulYLt+fVfJ77mJra6ivbFF+7+XTweYno9fLg4xObmCH7/+7TV1jLz8FGaP/85uXCk/d7voiwpwWsyYSkoYFdZGXv27OHGjRtSDfPpp5+Wi0pmZiY6nU7aN5jNZqLRKFNTU5SVlTE/Py8LftHtvHr1KuFwmNdee41wOCzpwP39/dTU1LB9+3b5WdFolOrq6iRbhQ8++EBaNOn1egYGBrDb7bS3t3Pu3Dkp3FBVVUV6erqcoVpdXZXqk8IfMBKJYDKZMBgMnDx5Un7G6dOngfVE3NPTQ3p6OkVFRVitViKRiCwYU1NTOXDgAOPj41itVsrLy2V3eHZ2Fq1WS0tLCy6XC7vdzuzsLGtra3I2d2hoiGAwyNjYGGlpafh8PoaHh5M2GCKhZ2RkyE2XEC+5efMm7e3tHD58mKGhIaLRKLt378br9Sads/379/Pmm29Kuwyhunz06FFsNptEeBNpwrdaiMQ1VSqVXLx4Uf5cJPKzZ89y8uRJjEYjY2NjMpGLjnc4HGZmZkbOHvt8PnmPCzXllZWVTZQ04Q9ZVlYmO7C5ublYLBays7OpqqqS32FqaoqKigqJBnu9XnQ6HVVVVXLjJzolCoWC7du3y0Te0NAgN60TExNcv35dLtSZmZl0dXXJLnNdXR2jo6P4fD7GxsbYvn17UnegrKxMKrh7PJ6kBX+jYEZFRQVTU1MYDAZ5He9WHH4S8SAVzBtDUEKFgOCdPCEFxd3r9d6XEndi/M//+T/5/d//faxWK21tbfzRH/3Rbe28/uqv/oqvfvWrST/T6XTyvhLH/5//83/mL/7iL1hdXWXfvn38yZ/8ycf24f4s7h73k+sFm8zv99PX10ckEpHztluNSCTC7OwsOTk5cj3ZCFwnUrBv18UeGBiQIk01NTX3ROFMvAcB+Z0UCgVNTU20tbUB6yMwer0eu91Oeno6BQUF/OzP/ixWq5XXX38dWF+nRNGkUqkoLi7GYDDg9/uZn5+Xo0EdHR309PRIhldWVhatra0sLS1Jarbdbkej0VBaWsoLL7xAWloaTz75JN3d3RKEFSwjEVNTU5w/fx6NRkN7eztms1naLkYiEQnaZmVl0dTURH9/vxyXmZ2dlXsooX0iXBgSu+cCoBN+1D6fj9bWVt58801gvbDzer34/X7a2tqYm5uTYL4QgBJqzzt27JD2jGNjY6yursoRFKH34fV6uXnzpvzOLpcrqcO8urqKXq+XzK5AICDz6MrKCnv27KG/v59gMEhlZSVra2tJFpXt7e0sLi7i9/u5dOmSHD/avXs3MzMzcrZZo9HI/eytWGwZGRmUlZWxtrbG9PS0LHRzc3NxOp1cuXKFWCwm6dVC7XxmZoYTJ04QjUZxOp28/fbbErQQrDmNRkN2djaTk5PodLpNLLZ3330XnU7H4cOH0Wq1ZGZmolQqJTNDgCcCdBb3TCgUkt1ooUSe+DyUlpZiMpkYHR2V9zOsgwNnz56VbEmVSiVnigsLC8nKyiIQCMjxOtGsSTxX4p7yer1JOXXjKFJDQwPDw8OoVCpmZmYYHh6+p+Lw48aDnuuF5g6s3/Ni/nlhYUG6bSTuhz6OI8aDnusfmIL5XkOpVLK6uorVaqWhoYGSkpKPvWF1feGLxCwWtCdPYPzjPwI+SqL3Q8HWPvYYwe98F91jJ2/7OyIig4MU/+K/AKWS6KtnUFVV4kpLw7Wzk+zZWaqOHMaQsNgq9Hr0//bf8NL3vkfo/fdpbGxk165dsmujUCikaIJWq6WpqYnr16+ztLSU5JuXmppKcXExkUiE5uZmOZ+UqOIskoAQnIL1QlCoUa+srGAwGJibm6O0tFQeg+jGud1uLl++TDweZ2Vlhffff59HHnlEzjaJyMrK4uzZs/j9fineIhQk6+vrb9uRWlhYYGhoiKqqKqqqqvB4PFKl2W63y7ktp9Mpu9mCOmqxWORcdVZWFhUVFRQVFXHz5k0WFhbweDzS/zBRWTwSiSSJXQCya5+fny9p69nZ2Wi1WsrKylAqlWg0GtldNxqNSYs5rC/oer2eQCCA0WjkwoULWK1Wdu/eLZP73r177+ohPjQ0hMvloqysLIlhICIejzMzMyMp3uK8CK9jIZYioqioiIyMDJaWlvB4PPj9fqmCmUi3mZr6/9j77/i47/Q8FH2mV8xgMAAGwACDOiB6JUCCAJvEKlLV2tW6ZO09N5vr5Ow9n2RPrsu5jtdZO+7H3mPfnGyuN3bsJNuLdlUosYiUWAAQvXcMynRM733uH7PfVzMg2CmJ2uj9RyKAmfnNr3zf7/u8z/s864jFYlhdXSULsMbGRlRVVZHoXPYYALsPNzY2MDg4CLFYjHPnzqGjowORSITeg/39jRs3iFbN6Inr6+sAMonm8OHDKCkpAZfLxfDwMMLhMILBIDo6OhAIBKBSqUg4bq91Yi9PyezI7qxmC60whXFmxcZoXQ9rt3S3YNfkaYxsRPxenpBmsxnf/va38V/+y3+BVqulZPswtj/f+9738NWvfhXf/OY3ceDAAXzjG9/A6dOnsbS0dNdngoFCLHZf3z//8z/H3/zN3+Af//EfUV1djX/37/4dTp8+jfn5+Ye2H/wsHi4eJlezYurWrVvQaDSkuP84MTo6iqWlJQiFQrz22mvgcrmU6x+Ggl1RUYGNjQ2a/bxXJJNJ3L59m/QY6urqaEMZjUbR2tpKxTILvV4Po9GIwcFBKBQKvPzyyzn3psPhQDQahVgsRltbG5aXl2E0GrG0tERrELO2Ki0tRXl5ORWzV65cobWeFRrxeDyHvsq62NPT05Tzs8dxsvcIs7Oz8Pv9iMfjuHHjBgYGBtDe3g61Wk3Xq6Kigua15+bmoNVq4Xa7IZfLMTAwAKFQuOda7Pf7MTExAZlMhr6+PnA4HLS2toLD4aC4uJjmfRlIDWTum/r6esRiMfJh5nA4OHjwIIqKihAIBPDGG28AyIz7MOaWVColq0tWSLEwGAwYGhqCQCDA888/DwCk5CwSiWhky2w209hRtk0W8KHVH2NsraysYHJyEnq9HjKZDFeuXEFDQ8N9GQtMnLS0tJT0WFiwTrPT6UQ0GkVlZSWxG+LxOMLhMCQSCfLy8ggkkkql2LdvH1QqFTweD7a3t6HX6yGVSuHz+VBYWAgOhwOz2UzAAhOWVavVePnll+H3+xGLxWjPln0tA4EA3n77baRSKZw4cQKtra3kK54dExMTMJvNMBgM+PznP097OXavtra2oqamBlKpFLdv36ZZ6DNnzpC4KrsP93om75frZTJZzthVNBqlXG82mz8ysPxpLph3q2SLxWLSsWH7oWwF7t/8zd+kPZzT6XwoG65PQ65/KgrmB41wOExiPY+LNOcEO8e7LC0CgQBu3rxJqtH3Q5Hz/sMfQf71f0/eyfeKxOoqAioV/MXFkK+vwcrJdM70f/h1KG7eAs/n3/N12UUNE6dgP5+bmyO7HYPBkDPDyihQwWAQ29vbOTSztbU1KowrKytRX18Pq9WKmpoa6jzW1dWBy+Xi1KlTSKfT+O///b8jlUqRCAiQ6ZYycIHRWRi1x+v15swMA5nisqysDMFgEMXFxfjJT36CZDIJtVqNS5cuIZlM4tSpUzQTxjyajUYj2tvbUVxcjGg0ijfeeAPxeJxmLACQcAH7f7aJUKlU1ME2GAxU2KpUKqILdnV1Ea2XqVAqFApEIhFsbW2hoKCACkcgkxA8Hg9WVlYgEonQ19eHtbU16hDIZDKEQiHYbDYIhcKcwjsSiaCsrAwFBQXQ6XQYGRkBkClEGTXdYDCQTQLrVMfjcajVaqKGsSLS6/VS59xqtSKVSmH//v0IhUIkCtLX14e2tjZMT09je3sbJpMJFRUVOfe3SqVCeXk5UZeYf7bf78fMzAx0Oh0KCgqoENJoNHjjjTeQTqdx4sQJ2Gw2TE9PQygU4sUXXwSfz89JWCzRRyIRrK6uYmpqir73/v37odPpCGBxOBxQqVS4ePEizbNLpVJEIhH4fD5alEtKSmAwGEis5ODBg7h06RK2trZw6NChHLQ/+xliwl9ra2uIx+Pk0bw7dgutZKuSm0wmLCwskC+2SqV64HmfveLTlESzI1t4jrELKioq8Hd/93ewWq0oKipCZ2cnTpw4gRdffBF99xld+au/+it8+ctfJiT5m9/8Jt566y38/d//PX7nd35nz9cwD/K9Ip1O4xvf+AZ+7/d+j9gq//RP/wSNRoPXX38dX/jCFx70NHwWH2Ekk0kYDAZyA9hrLvhxIntjxXLj6OjoXSnYu6O6upqKkftFLBajPM0cKVghygq7vZ53luvZf30+H823rq6u0jiKy+XKKZzY3/P5fExMTKC5uZmYalarleyXCgsL0draStZEhYWFkEqlKCoqgkgkQltbG9ra2vDuu+/C7Xbj4sWL+JVf+RXqiCcSCezs7CCVSqGrq4vmU7e3tzEwMHDHeWhtbcXy8jIaGxtx4cIFEooaHh6Gz+dDa2trjj0jE/LMtgd99913YbVaodPpsG/fPggEAppbZsAHY2Dx+XyipFutVnLvYJ3TSCSC+vp66HQ6WsedTicVwQaDAQUFBVAqlZTr4/E4QqEQVldXEYlEcOrUKSwuLmJrawvV1dU51OvR0VF0dHTkCH3KZDLU19ejo6MDly5dQiKRwOrqKtk/Li0tUbPDYrGgu7sbAoGAaNYAMDs7S3ZMfX19sFgs5Khx8OBBmkdmlONTp07hnXfeQTAYxOzsLHp6enL2kUzgi6kos6YCAyDYeJtMJqN7Y3JyEn6/n/ZhrOt/4sQJFBUV3VEws+LcZrNhZmaG/MqrqqrI0aKwsJBG5CYnJ8ldRSQSIR6Pw263E5hQXFyMtbU10jQ5ceIEfvzjH9PoVPZ4BYvsZ8xms8FqtRIwsFeIRKIcK8aPCiz/tOb67P1QRUUFmpqa8K1vfQs//vGPAWQo+uXl5Thx4gSeffZZfP7zn78nwPBpyPWfmoLZbrdjZmaGFrwnqcCm/P73kBgZheD4MQCZE81ma+rr6++gYKfTaSCZJC/m7HiQYhkAOCdO4IbbjRSXC1MsBsnmJnp6eiD8zncR+ou/BACorr0H3s+po0CmiD937hzNNW1sbFChweFwUFdXh9XVVWi1WpSUlJDAVk1NDXQ6Hebm5pBIJGju8OTJkwAyaLbVakVhYSH6+/vpJkylUuDz+XuKXYhEIhLRGhoaIqVni8WCdDpNcxAmkwlutxs3b95EIBCgeWcgQ2tzu93o7u6GWCymRTVbRXVtbQ3FxcVIJpOYmJiAw+GAVqslymwikaCNQygUQk1NDc0xs1nnbFpTXl4eampqiKrNPI2lUileeuklEjkQCAQoLi6mOWjmW8tmW5mIi1gsRlNTE0ZGRuBwOAhoYTTvl156CefPn8ft27dhMBhgt9uh0+kI3ZqcnMT29jYMBgNqamrQ0tJC/tMymQx2ux11dXWw2WzUOb506RLi8ThaWlrIh5kFE1ZhSXxrawsVFRUkwJVOpyGVSqFUKjE7O0ud54WFBfT29qKlpQVra2sYHx8nVXNmN0b3LoeDqqoqOBwOLC4uEqLLRhh8Ph+BNYyeFwwGyct0fHwcYrEYDQ0NyM/Pp3ltALQZZJTpZ599ljqT2R7QiUSCREJqamqwtbWF1tZWdHR00Dx49kJ/t8KViQ3u7OwQWCEUCu8rdgLkFofsvmXiWGzeZ7ff4YMmxo9TJfthIpVKIZ1OP/CxqVQqvPbaa3A6nSgqKsLf/d3f4b333sPly5dx6dKlexbMsVgMY2Nj+N3f/V36GZfLxYkTJzA4OHjX1wUCAVRWVtJG/o//+I8J9WYCStlWIUqlEgcOHMDg4OBnBfNTEMFgMGe9eZL+p/v374dGo0FhYSE9i4xBo1Qq96Rg321D+6DPskQiIYDVbDYjFAoRg+qtt94CkFlTs0d1gAwAvb29jZKSEoRCIVy9epV+x5wsuFwuGhoaYDAYkEwmUVBQgN7eXszMzJBIl8fjwcsvv5xjL5NIJHD8+HFIpVLodDpaw7u7u+84flZQyGQyGAwGmt12Op2kfp2fn4+Ojg5sbm5iY2MDwWAQJ0+epHNkMpmwvLwMrVaLmpoaDA8P07llxajRaKTxsOXlZayurkKpVOawCJkoWjAYhFgsxvnz55FKpSCVSlFWVpYjkMXlctHe3o7333+fqOpsJvj555+H1+uFUCi8w10iFotRrmdjOGzet6KiAmazmRhak5OTOfO+hw4dQllZGVlLFhYWkrsIy7NAhsHV2tqK2dlZ1NbWgs/nY25uDvv27UM8HqdidWRkBKFQCAUFBTh9+jSAXE/7qqoqqFQqvP322wAyWhvd3d1YWVlBKBSCVCqFQqGg+y8ej+Ptt98mYa3Z2Vlsbm7Sd+NwOBgeHs7JyZWVlcQMYDR1dgwejydHDZ7NsLPu/OLiIsLhMNra2pBKpVBaWkq6Lex7dnV1kZVXdXU1+Hw+ib8BmXwcjUZhs9mo8aBQKPDqq6/C7XbD7/cjLy+P/NTvxvhgRXwqlcK1a9eQSqUQCARyxgDuFh8lWP605nrg4XyYBQIBnn32WZSXl+OHP/whrFYrbt68iStXruA73/kOXnvttbu+9tOS65+KgvleqAPrbplMJjQ3N5Pf35MMXkkJeM9n5kkYBZstBNXV1Tl/mw6H4Xn5l5Dc2oLi778F4R5I1r2Ceb9yhMKMF3M6jTRAHewI2xxIJOBIP1SZs9vtGBoaglarpaTGZgI5HA7Onz8PlUpF1C62oAGZImR5eRnNzc2YnZ0FABIbATKd3mPHjpFKtEQiwRtvvAG/349nnnnmDlpFIBBAfn4+CgsL0dHRgW9/+9sAMjcoE7BYWFjAsWPHcPToUfzgBz+g7jCzxZicnKSFc2FhAefPn8fRo0fhdDrh9Xqh1+sxNjaGtbU1CIVChEIhsthwOBxQKBSoqamBTCbDiRMn4PF4aMMhlUopUe9lyl5bW0uLusPhwO3bt8Hj8dDe3o7x8XES3mAd1718a1dXV0mZk/kWAyArB2bNAGQe/LKyMhgMBnA4HKysrKC1tRVAJslub28jPz8fXC4Xra2tOb9jkZeXh6KiIhIuAzKMC7PZjK2tLVLKZEkgm8Jy8+ZN6PV62lyw2S6mZM3mlg0GAzQaDd0jjMrMNhWpVAolJSVoa2uDWq2GWCymawhkOrxMCCo/Px91dXUoLCykmWpGnWZAztmzZ5Gfn0+WYna7HQ6HI4eq5XQ6CWQoKipCPB5HT08PAoEAlpaWsG/fPvzsZz9DMpnE1NQUKisrsba2RkqXZ86cQSKRuKuydzqdBpfLhUQioe/4qGBcNsjCrg+b99ne3gZwd7/D3fG0os4MFHkUWym5XI7S0lL86q/+Kn71V3/1vq9xOBxIJpN3FEwajYbGKnbHvn378Pd///doa2uD1+vFX/7lX+LQoUOYm5tDeXk5zfPt9Z7sd5/FJxcmkwnz8/OoqKhATU0N3nvvPSQSiSdm88Ln8ymnMwr22toaFVe7n8ehoSHSQdhNm36QYM+xUCgkqjMTKGU+talUKkejIhKJkB8ws2CMx+PUFT148OAdxbVQKCSxqfn5ecoVOzs7iEajiEQiNK51/PhxLC0twev1QiqVYnBwkPYH2f71QAaYZODwuXPncOnSJeqwMkr51NQUWlpa0N7ejlAoRPZBzFpmc3MTQ0NDiEQiWFlZQU9PD06dOgWj0Qiz2YzGxkYMDw/D7Xbj6tWrKC4uRigUgtPpJE0W1rF+5plnsLm5SdeQ5SYgQxfdff2Ki4tRUlJC89tvvfUWsa7Gx8eRSqVyvJjZe2Z3XF0uFy5fvoxUKoVQKERgd7aKNgPlORwOioqKiMW2urqKiooK0k/hcrnkUyyXy3M8mbNtO+vr62E2m8Hn8xEKhRAOh+H3+7GwsEAUeblcDovFgqKiIro31tbW4HA4cObMGfj9fqjVamKA5eXlYXFxEdFoFLOzszh9+jRu3LgBIMPsYjmJzbszKyt2rhmIFQwGCTBnbhZsXGtpaYkKWIVCgYmJCQAZUS9WyDzzzDOwWq0wmUzE8AMyYMj6+jrKyspQX19Pe361Wo2RkREUFRVhaGiIGgcdHR2YnJwEh8PBc889h9OnT8Ptdt+148ieRVb8+ny+R871TxIsf1pzPfBoxTwTMMzLy8PZs2dx9uzZ+77m05Lrn4qC+W4RDAapg9rX1weZTEYn9mEjnUwi9Dd/i7TPB9m//d/B2UPyPNvLuba2NqdzxyK5tY3kz1UB49dv3LdgTkejiHzv++BVVwEHDuCtt95CKBRCe2sr1Go1oTLsphS/8jL4ej04hWpwC9X0PouLi/RAtrS0EOr48ssvIxQK3aFkKJfLUV5eDrfbjXQ6TfPXbBZldwftvffeI5+7w4cP0zyT1WrNKZhdLheuX78Oj8dD9hQKhQKhUAiNjY3wer1YX1/H1tYWIbpdXV24desWgsEglpeXUVJSQoUWE98CMglDqVRifHwcdXV1mJycJNXs9vZ2qFQqbG5uIp1OQygU4s0330QymcThw4cxPT2NjY0NslRKJpO4cuUKPB4Pjhw5QotoMpnE+Pg44vE4mpqaSDglmUySJVYsFkM8HqdNWjwex+LiIllPsNlkFmwueWNjgyjxdXV1KCkpoZkhnU6H+fl5uN1uLC4uorm5GTs7O+RzHQqFaHOyVwiFQpw4cYLUCkOhEJqamvD666/TQuP1erGxsYF4PI4jR46QzRLwIdWZxc2bN0k8r6SkBD6fj6yYysvLEYvFsL6+jomJCXR0dODkyZO4dOkSrFYrqqqqaFabhUgkwuHDh5FKpYidEQwGsbq6Sp3lVCpFdDmxWEydCy6Xi8LCQkxPT5NKI7smV69eJWEShhTGYjHagDFVTgA56uKMdcASWjgcxuzsLFQqVY7SK+sw5+Xl4YUXXsih9D1uSCQSaLVaaLXaO/wOGX2fJVSVSpVzPp8m5czsYOf6YY+NFcwfdfT19eV0rQ8dOoTGxkb85//8n/GHf/iHH/nnfxb3jrsBRIlEAvPz89jZ2SGRPkYbfZR8bzAYYDQa0dramtMBY5Gtgt3R0YGJiYk9j40pH29ubj5Qwby5uYloNIq6ujoSwWxuboZEIkE6ncYzzzxDm/S8vDy8/PLLOR6xQAaoZHnJbDZDrVaDz+fjpZdegsvlInXl7Ghubsbc3BzEYjGNQXi9XsRiMRQVFeXsDyYmJrC4uAgOh4MvfOELMBqN9LnZOSIcDmNkZAQGgwFAJvczL/Xy8nJotVoMDw8jkUhgdHQU+/fvR2NjI7a2thCJRDA6Oorjx49jZGQEkUiEnC6YsJRarSZmGxt5CgQCKC0tRV9fH5xOJ/x+PxQKBW7dugWj0Yi+vj4Eg0Fip7D1fXJykvIq208AGZ9kl8tF1GgG+AUCAfp/1uEGQKM5sVgM+/btA4/Hg0Qiob9l39tkMmFnZwdGoxHV1dUoLCxEJBKBQCCAXC5HfX093c8ejwccDgdCoZDmfe+3fnZ3d6O7uxsWi4WE5SYnJ2E0GokBaLFYsLOzg8997nNobGzE9PQ02QKxeXkgw+RjI1uMjaDX68nhZHt7GwKBAD/72c9QXFyMEydO4OLFi/D5fDSaB4Do76lUCgcPHsxh3tlsNlgslpzONJsNZ5R5FkVFRVhYWEA4HM4Bsm/fvk3WTq+88go1hm7dugWn04nq6mqyGgM+zPHMnoxZTTIHmHg8jtbWVur0ZlvXnj59GoFA4Ik56zwOWP605nrg4TrMLD4uS6lPItc/tQUzE3YqLy/PmSnc7cP8oBG/NYjw3/5/M+9RWwvJr33Y4WC01NXVVVLBZkP+u4NXr4fkK/8rkmtrEP/a/bsk4W/9F4T+z78COBwk3/gpFaK+v/4G9H19iPYdBI/HoxmUkpIS8Ftb7nif2tpaWK1WlJWVYXp6GvPz8ygoKEBpaSnm5uag0Whw5swZ+nvWYVar1Th06BBEIhEWFxcxPDwMiURyB5IslUrh9/sRDofB5/PR3d0Nt9sNDoeD119/Hd3d3VCr1XjzzTdz/J2HhoZI5Xh8fJzmd4GMZVR5eTnKysoo4Xi9XtTW1pIXXmNjI3w+H+LxOLhcLq5du0YLdXNzM8xmM3p6elBcXEyFfl1dHRV7QAZMYHNZZrMZOp2OEGoAJM7CPj/b37e5uRl8Ph9yuRxFRUWQSCRQKpU5D/zCwgLRgdVqNVGhmDDTbg/s2tpaOJ1OMoIXi8VQq9WoqKggMZXx8XGsrKxAJpOhtLQUq6uryM/PJxVLv99PXpLZsbCwgKmpKQgEAjQ3N6OwsBA2mw1qtZpUQLO9mjUaDWw2G9GXa2trkU6nc+bb2Qw6i4GBAVKiBj4Ub8imXN+6dQupVAparRZ2ux3pdJrAgfz8fExPT8NkMqGmpgYulwvpdJo2cEz51e12k9+lzWajjYvdbodaraZZM0bnZuHxeAjcWFlZQV9fHzY3N9Hc3Iy8vDwUFxdDo9HkvGZhYYFodKWlpXR9WYcZyFUif9Kxl9+hx+OB2+0m+5a8vDxKqE9rEk0mkzTr/zDxKEm0sLAQPB4vx5IOyMyf3a2LsDsEAgE6Ozvp2rPX2Wy2nLlYm82Gjo6Ohzq+z+LJhM/nw9TUFEQiEfr7+3M6eHt5Md8vUqkUrl+/jnQ6jXg8ToKMLLIdNjo7O5FIJAjQ231f9/X1YWVlJUeM8G7hcDhw7do1Ona2uWf5mYnjBYNBOJ1OaLXaPUGk0tJSUo1Op9P48Y9/DD6fjwMHDuDmzZsQCoV46aWXaL1KJBK0+T9w4ADy8/PhdrtJ2Go3OM6eQw6HA6fTiUOHDmFlZQWFhYX46U9/Cp1Oh87OTly6dCnHs352dhZKpRJCoRCbm5uQyWS0PrNiO1vEkgmKVVdXY25ujoo05ogxMjICq9WKyclJNDU1kX5EfX09AoEAtFotCgoKUFlZie985zsAQBom7P8PHDgAAASkMx9ftvYvLy8T9ffMmTMYGBhAJBJBTU0NlEol4vF4DovQ4XDkjObU1dVBKpXi+PHj8Pl8qKmpIYtGp9OJgwcPwul0wu12U7ezoKAAcrkc+fn51Ey4ceMGOBwOuru7yeHh/PnzJKwlk8nuoPC6XC66n8rLy1FYWAij0ZjjG8zuEw6Hg/Ly8px7jomksesAZMD9zs5O+ndzczOKi4tx69Yt+kxm1wRkCr/JyUl4PB6Ul5fDYDAgLy8PDocDhYWFkMlksFgsWFlZofs7Go3C7/dDIBDQWFw4HEYikSCXGwYIbW1tQalUgs/nE4DOxruYtgj7TjMzMzh69ChmZ2dRWlqKuro65OXlEfDMgs1JAxlRKHb/Z+d6Nt/+UcXDgOVs7/s0xqPsQ1iufxhBtE9Lrn8qCubsE5tIJLCwsAC73U6CAtnBuocPG7x6PTgqFdKhEARZSHEsFsPs7Cx8Ph96enroIbpbouZwOJB99d88+Aer1Vh85jjSIhFaJBKoxGKIR8egGx2DcHIKfoMB7t8qx5tvvgkgU7zosuaWgcyGYnx8HEVFRejr66NF1OfzUVcqm2JtsVgwOTmJVCpFM7zs7wHkLF4suru78fbbbyMYDGJpaYkW1f/23/4bIXbHjh2jJM661VKpNEdAwul0oqOjAz6fjwQahEIhurq6EIvF0NLSQrPYfr+fBAKYTRU7xqmpKajVapqzSqVSZIMQjUYxMDCAsrIyhMNhQtNZAQeApPDX19exsbGB+vp6EgWrqqqC3+9HdXU1eDxejgjXXhsjJgDD5ravXLkCuVyOjo4ODA4OYmNjAwMDA+BwOIjH43jvvfdIEVIqlRJFbWlpiTqwjFYdi8VoLov998qVK4Sosrkz9sAzpJghvUePHsXVq1exsLCAnp4eaDSanMKks7MTV65coU1DZWUl7HY7pFIpbbKy7wWTyYTp6Wk6vqKiInR0dEAqlaKtrQ0cDgcbGxuUhNn8m8lkgkQiIZVJxs5g6urBYJCo6kyMZGVlhVSoWREtEAjgcDhw8+ZNaDQaDAwM4N1334XBYIBWq0VFRQUKCwsJ7bbb7RgYGLiDzrY7CgsLsbS0BJlMhkAggOvXr6O0tBQikegTmR/i8XjUZQFAc3NutxsLCwuIRqPUrWIbsI/Cvuph41EQZyCTRB9GHRvIrBvd3d24cuUKXnrpJQCZYujKlSv4yle+8kDvkUwmMTMzQ9Z01dXVKCkpwZUrVyhp+nw+DA8P41/+y3/5UMf3WTxeMOGf5eVlVFdXo7a29o57/FEKZqagvHujxAoqg8GQo4LN8tdeBXNlZeWeYoF7RTZDJJFIoLS0lLpLOzs7EAqFiMVieOutt8h1YPcMP1PU5nK5OHr0KI2vJBIJAoBZzpBIJPD7/RgbGyPLHLZ/CQaD9L2CwWBOJ6+5uRnT09Nk13T+/HlotVpiZHk8HlrrgUwnnM/nE6Wbga12ux0dHR00e8yio6MDFouF1uHu7m50dXXhJz/5Cfx+P0wmE86fP0+da9aRPnjwIO33hoeHYTKZwOfzUVdXh9bWVpq1lUgksFqtOet8R0cHhoaGEA6HyYYQANra2nIcHLL9fXeLkAKgDjqbW758+TJCoRAGBgZgNBqxurqKw4cPk6vE0NAQbDYbDh48iObmZvj9fjgcDszNzRF9mxX4zIIPyNxr0WgUBoMBMzMzyMvLQ3V1NQQCAfR6fQ7gwq55Y2Mj4vE45ubmoFAoqOBm763RaOiZ2tzcRHd3N9GOHQ4HxGJxzoyv3+/HyMgIAd5SqZQAiM7OTjgcDqTTaZq7drlckMlkcLlcuHnzJgkpsVzv9/tRVFQEh8MBqVSKaDSKYDCIQCAAo9EIhUIBrVZLgpA+nw8qlQo/+clPIBKJcPr0aXIqGRsbQ09PD3XTrVYrIpEIeDwejhw5Qudl98gkAPJoZiJr165dA5fLJeG4jzvuB5YHAgEIBAKsrq6SyNzTMtP8cXWYPy25/qkomFn4/X5MTk5CKBTmIM3ZkW0B8TA3P0+jQcGtGxmxrp8vMtkU7N0q2FwuF4KVFSTLysB7wIS5V9gPHsBaNKOQ6ZqeRmNnJ7RuDyIyGdJ2O5Tf+z4S/+rDi5dIJBAMBmmmEsgUSUyEwuVyEYpcXl4OsViMxcVFGnxn895s5iUQCFAR097eDqFQiMLCQjq3brebNuUM/c5GdBoaGrCwsACHwwG/34+TJ09iZmYGdrsdiUTiDtr68vIyCgsLce7cOfrZ+++/TxZU2UqCTJgrFotBLpfnoEusgGC0G7bouN1uqFQqCAQCVFZWYnBwENeuXcMrr7wCmUxGVmAcDgdarRbr6+uUqOx2O1KpFHp7e7G+vg6r1fpAhUg6nUZdXR2ampqwvr6OUCiEUCiU49mYrfrM5rjNZjMaGhrIyoJ9F+b1y+bSGGrPEjjrnlosFkQiESwvL+PVV18Fj8cjyhNDVplSKQAqQHd/n+xNw61bt2AymUgV1Ww24/r169RlnpycJNACyGyu5HI5JicnsbCwAJFIlENjYjYcgUAAQqEQr7/+OiKRCPbt2weLxQK/34/Ozk4olUq6Z7LBncrKSnA4HEraAoGAaOQulyvnu0QiEaJis/tSLpdTZ/teodPpoNFowOfzMTQ0ROMNra2tT8wK6nFi99zc0NAQlEol0ezZzBQT0/uk7I8eVaDkUSnZX/3qV/Hrv/7r2L9/P3p7e/GNb3wDwWCQlDS/+MUvQqvV4k/+5E8AAF//+tdx8OBB1NXVwePx4C/+4i+wubmJf/7P/zmAzDryr//1v8Yf/dEfQa/Xk9VEWVkZJerP4qML9jwzOyKPx4Pu7u67gimPwihjlMvssZpsCvZuFWy2p7Db7cQWepTIfibn5+eh0+lw7NgxTExMEE02m7mWTCYRiUTA5/MJsGRikUCGVt7S0kJ5orKyEgKBgMSFGAuPw+HQrC9bC7VaLQ4cOIB0Ok0AfDgchsPhQFlZGXQ6HdbW1nIKSL1eD4vFgmQyiYWFBTzzzDMYHx8ncUy2bjNqs8PhgNvtxi/90i/R+ru0tIShoSGIRKIcATE2N8rmW5l/Mvud1+slwBjI0FdNJhN1UOvq6jA7O4vR0VEcOXIEhw4dyhnBYUrGQCZ/ms1m2Gw2NDQ0kGZHdvPgbhGNRlFVVYWKigrw+fyc3JrNTKupqUE6nc7xOGYjZUKhMMfOSqlUoqCggI6vurqaxnDYfGYgEKAxNYVCgZKSkhwWGJvDZMewubmJ2tranBlcDoeD+vp6+Hw+AmtGRkbA5XJRW1uLtbU1vP3223jhhRcgFAqxurqas+fS6XRUnDLdkexZebVaDYlEAo/HQ64VLpeLAP2dnR1wOBw8++yziMViWFpayqG7azQaqNVquFwuuk8ZmMDm7NmzEY1Gsbi4iO3tbeh0OrjdbhoBvB+NWiaT4aWXXkIqlcoZb2Ce0Z907AbLFxcXEYlEEI/HsbCwgHg8TvfMJw2WP+oM8y9qrn8qCmaGii0tLaGqqgq1tbV3vbF5PN6HwlkPeRNxfr5YZlOw9Xo9bdqzg3v1Gqr+4OtwCwRQXbkE3kP4iWUHE3pIp9NoaWnJ0EPq6xGpqsR7y8sAn4/zajVOnTqFWCwGu92O69evQ6vV0sxmVVUVDAYD5HI5CgoKwOPxcpLRgQMHEIlEcPv2bSSTSRw6dAg3b96E3+9HMpmkDiKjuE5MTCCVSiE/P5+sgA4fPoyXX3455wHZ2trCxsYGne/V1VVEo1EUFRXRIgRkEihDuwGQJx/brGT7M2eHSCTCSy+9hEgkApVKlaOMyorStbU1NDU1IRqN4ty5czRHBXw4w5JKpWCxWFBdXU3HCmQEPxobGwk1ZgIUkUiEvNvEYnHOpmF3ME9pdrw1NTVUaO/btw8ulwsKhQL5+fmwWq2QyWREg56enoZOp4NUKoVWq0VpaSk4HA5aWlogFApz5n0Zcry5uYmamhpEo1EIBAIsLy9DLpfD4XDg1q1bkMvl5Jc4ODiIgwcPYv/+/ZiamoLb7cabb76JF198kWbmQqEQFhcXIRQKcwQU4vE4bdKyNyo1NTWYnp4mwQ/WoWEbsmg0ikOHDsHpdGJ2dhYTExPUGRgfH6dN0M7ODnw+H1Gqjh49irW1NdTV1aG0tBRLS0sk3MZQ5Nu3byMWi9GMmEAggMFgQEVFBeRyOYLBIHUluFwudV2YVcb9gm2Wqqurc6g+T0PnNjvY8Wg0GqhUKurIu1wuWCwWLC0tQSKR5Mw/P6p91cPG43SYH0Vg5bXXXsPOzg5+//d/H1arFR0dHXjnnXdoA7m1tZWTK9xuN7785S/DarVCpVKhu7sbt27dyvE2/a3f+i0Eg0H8i3/xL+DxeDAwMIB33nnnMw/mjyncbjempqaQl5eH/v7+ewp6PSqjjM2MAh9SsAsKCvZUwWaF5KVLlzAwMPBACvl7BY/HQ15eHvx+PzQaDfbv308U3Z/+9Kf0PZ577jnY7XYIhUJ8//vfh0gkwosvvkijO8xqsaqqCjweL2cmt6urC6lUCgsLC7BYLOjo6IDD4SCQkXWeORwO1Go1hoeHEYlE0NnZiQsXLsDv96O2thYDAwM4ePAgnQu/34+pqSkau1lfX0cgEACXy4VUKs3JERqNhj6PdctYTma5PhqN3qHJ8eyzz5KFldPppO5+IpFALBbDzMwMKioq4PF40NHRQUUpm1FleX1nZwelpaU59w2fz0dnZyfC4TD0ej3ta8LhMLa2tpBOpxGJRO6bJ27cuEFzuSdPnqTxrsbGRoTDYUQiEQIgmEjn7OwsLBYLNQUkEgkaGhpgt9vR1taGgoICNDY20vs6nU6YzWbs7OwgLy8PlZWVNMbE5XLB5/Nx4cIFJBIJaLVaeDweXLt2DUeOHEFHRweGh4fh9/tx5coV9Pb20phVKpXCzMwMIpEIysvLqRjO3tPF43ES0SsvLyd7pKqqKnIwyaZwq1QqPPvss9jY2KCRrueffx4Wi4VGtiwWC0pLS5FIJLC2tobu7m7at/T392NjYwPRaBRNTU0QCATQarUYGxuDz+cjnZdkMonV1VWUl5cjmUyisrISH3zwAR2PTCaDx+PB0NAQdbbvFey+LikpIcEtxnB72oJpqLDryITzXC7XJwqWs+fu45ph/jTk+qeiYPZ4PFhbW0NXV9eeghbZwS7eoypnsoXZ7/fnULB3B9frRQoA4nGkg6E9/+Z+EQqFMD8/j5qaGrS1teVsGJ01NQj/fEF7/fXXce7cOZSWlmJ+fh5Ahu7k8/mwubmJyspKnDx5kqhLu29Gp9OJqakpFBUV0SxQdlG5vr5O9CUmeDU9PY3+/n5KQsxfUCaTIZ1OY35+HvPz85Qo1Wo10awrKioQj8fpWDs6OtDU1EQFWzQaxfj4OA4ePIitrS34fD5IJBIcPnz4jnPEPA/n5+fhdDqp+ysUCmGz2TA3N4f5+Xkkk0n09fVhbGwMsVgMx48fR2NjI0QiEcbHx3Hz5k3s7OxQQkyn07h48SL8fj+am5tJoTmdTuecv+zOZCwWw40bN5BKpTAwMACxWEzql9FolGyWmB0XAKJ/sGCK2DabDclkEuFwGAaDAQKBAIcPH8bKygoJhTAKXX5+PtlZuN1uOJ1OsqZSqVTQ6/VYW1sjQTGdTodIJIKNjQ20tbVBp9NR8kqn07DZbERRNplMCAaDNDfX39+Pra0toq5vbm7mjAA0NjbCbrfDbDbj9u3bBCZlexXyeDwUFRVRx4GpUut0OhiNRggEArS2tsLj8WBjYwONjY24efMmzGYzHA4HLBYLjEYjNBoNCXCtra0RCHPq1Cna/IyPj2N7e5uURVmoVCp4vV4EAoE7ulPT09NYWVlBe3t7jsAXi7KyMrzyyisAMp6W2YtwKBT6xGja2ZE9O8TlcqFUKqFUKlFdXY1EIgGPx0N+kOFwGHl5eZRQFQrFR4akP2rBzCxOHiW+8pWv3JWWxcZTWPz1X/81/vqv//qe78fhcPD1r38dX//61x/peD6LR49EIoGpqSlUVVXtCVTvjkehZLPIpmA3NDTk2BPtPiYWzC/5YYPZ7iiVShw8eDCnU83hcOg7vP/++zh8+DD0ej2mp6epkPN6vVhbW0NBQQGOHz+OtbW1nA4jCzZTmk6n0dfXB4lEQmAmkFn7GFuI5VSn04nm5mb6nvF4nFhsQCZHTExMEFtMqVRCIBBAKpWiubkZLpcLFy5cQDqdRmlpKU6cOIFoNIq33noLfr8fN2/exKuvvopgMIj19XXweDz09PTcwfrh8XgoLCwkJfSenh6aYV1fX4fb7caPfvQjhMNh1NXVIRAIwGq1oqGhAQcOHMCpU6cwMzODhYUFbG1t4eWXX6b3npiYwPLyMlQqFdra2qibrVAoiKWwe5M8MTGRo5ECZBocoVCIfJ2zLYeOHTtG/8+ujVarpXnZQCCAzc1NeDweNDc3U2MhLy+PmAHMaYOJc7Fu69bWFvLy8lBeXg6Hw0GMNY1GQ/nbbDajpqYm53kwmUwE8DDFaiDT8e7s7IRQKIRCoYBarSY7SbYOFxUVoa2tDWNjY1hYWKA56d1ARHFxMTmCMFq8RqOBUChEIpFAY2MjNBoNjcetr6/TPLdSqcTExAQEAgEaGxsBZPar2XOmZ8+ezREZBZDjK56Xl0d+2rvrA7PZjKGhIZSUlNDMdnZIpVKcP3+e/jY7L0aj0Rxg7ZOKZDK5pyML0435pMDyR3XEYHXEo8TTnuufioK5oKAAhw8ffqALzy7eoyRRhmwrFIo7KNi7g/+5V7FqMqLl6DHw9905E3m/YMIDZWVlaGho2HM2am5ujgSvLBYLKRQz6uqVK1fg8/moq+Z2u7G+vk4LALPFWF9fR2NjI8rLy+H1ejE+Pk60LoZws6irq8Pi4iICgQD4fD5OnTqFcDiMxcVFDA0NobOzE6WlpVSACQQCMmXv6OggcYXs92TdfqVSCZFIROrFQ0NDMBgMhPTeuHED/f39OYteNBrF5OQkEokEzXMtLCzk0HNYuN1uomBtb2+jvLwctbW1dKw7Ozv0GobUASABrRdffJFUpvcKq9VKCcdkMqGsrAzJZBLPP/88AoHAHQk3HA7D6/WiuLiY7ArS6TQqKytpZtPj8RDVKhgMUodXLpffMZ/PusAajYY6HkCGmuf3+8HhcJCfn0/Fqkwmw5tvvomCggKyJwGA0dFR6gyzji+QSTxSqZTmu9LpNJqbm+9IMvn5+TCbzVAqldjZ2cHNmzehVCpRUlICl8uFsbExHDx4EF1dXVhbW4Pdbsfly5dx/Phx8rYLBAIYHR0Fn8+HWq0m0bREIkHXhQm3RaNRlJSUYHFxETweD+FwmIr0bAGg3t5ebG9vIxgMYmdnB0VFRaipqUF+fn5OIceEXlZXV1FbW3tPWhFTzgQytLvR0VEoFAqcPXv2E6Vv3ctqglH6mQpqJBIhRHpmZobYI6yAlkqlT6yL/qhiZIFA4JEtPD6LX5zg8/k4fPjwA2/CHrVgZnZHkUjkDgr27lAqlSgqKqJc/bARCAQwOTkJgUCw5yiZTCZDQ0MDrf0bGxuoqalBeXk5dXWnp6dhNpvJj5mpWH/+85+n93M4HJiamoJGo6F51unp6RxmVnZOYf70QKYLeObMGVgsFgSDQfzwhz9EUVERnnvuOVy7dg2JRAI8Hg8KhQJisRgNDQ00461UKsHlcnO6vCKRCGq1Gn6/H1KpFOvr6xgdHSXAgTke7HYkWFpagtlsJiX07e1tmEwmArNZvvJ6vcRIY/OrpaWllLsjkQiCwSDt4djfsq74mTNnyI6JFbTZWivM+QLI5IuCggL4/X4MDAzA5/MRk5Gtm2z0abc7hEKhQGtrK9LpNLRaLflqx2IxKgqTySR1b1kwN4iCggLU1dXhBz/4ARKJBLa2tsDn88HhcCASiVBQUED6LFNTU5iamoJcLqccajKZaM49G+yRSqXg8XjQ6/X0s4aGhjvyAHsu+Hw+eDweLly4QB1em82G2dlZFBYWoqurC3Nzc7DZbLh58yZqa2vxS7/0S3RdP/jgA7KvYgKs2XuweDwOn8+HYDCI4uJiKBQKBINBxGIxcj3JpvE2NTUhEonA4XAgHo/TDLdGo0E0GiW2mMFgIL2P/fv3g8fjPVCud7vduHjxIo1vPCm17EeJe+X6TxIsf9odMT6JeCoKZgAPjJI8inLmg1Cw7zgekQg7hw5B+Mzxe/4dC7vdjhs3bqCoqIjUDFtbW++q8CYSiXDw4EEMDg6ioKAA1dXVWFpawvj4OB0zW5glEgmhw0zRM5FIYHp6mrpyPB4PdrsdFy5cyPkMnU6X4+dbWlpKokJGoxGNjY1Ip9M0s2I2m1FQUEBUOLaQ9PT0QCwW45133oHP56PCTa/XE8IZCoWg1+uhUCig0WhI0EsikSAcDsPtdmNpaQk9PT0YHBxEPB5HOp1Gfn4+LXarq6uU/MRiMfLz81FaWgqLxQKxWIyDBw9ibGwMq6ur4PF4OHjwIAYGBnDlyhV6f71eDy6Xi2PHjsFms1HSttvtiEajKC4uxsLCAi30586dg0gkIoEW5jv5s5/9jCwURkZGkEql8Oyzz5LH5YULFxCNRtHc3EwJMZVK4d133yW7ksLCQlIVZmwG5sUcCoVQVVWFaDRKfogDAwMQiUSQyWQkbKXT6QjhFYvFVCyHQiGaJTt58iRWV1dhMBgIgInFYnTuJBIJbDYbqRd6PB5cuXIFQqEQp06dypntksvlJLQyPT2d09mOxWLY2NhAe3s79u3bB4/HQxQuh8NB97vFYiGBE4fDgf7+fgwPD6O8vBylpaXY3NxEfn4+Ll68CCCjRqvVarG5uUkdC+aNrVQqoVarae4a+ND30OVyYWlpiRgAKpUK+/btg9FoRHNzM65cuQKHw4GDBw/mCIOxyFbOZHQtn8/3RL1fHyUexptRLBajtLSU5viCwSBR/xjljiVUlUr1WDPbj0PJ/jisJj6Lpz/4fH5O8XK/v33YGWbGuFKr1ejq6nqgvQVjyDzIvR2NRnHlyhUCHFdWVqDT6Sjv7A4Oh4Oenh4SRmxtbYXb7SZPYPY3QCb3sOeTw+EglUpRp3xpaQmJRILEnV5//fWcLrRKpcqhI2a7U6ysrODEiRNQKBS4cuUKgMy6HAgEaJyqoKCAOoYVFRUYHx8nTRJGM2Y6G4lEgtbk2tpaXLx4EeFwGDweD1wuF6FQiOwhGRjAxoQOHjxIFFtWEAGZjqdWq4XT6YRIJKLup8fjwVtvvYVXXnkFBw4cgMlkQiwWw61bt6jr29PTQx6+QKbgZpaYjFI+Pz9PvsyMUs7hcFBZWYmLFy/C6/WisbERFosFHo8Hra2tZBk5NDSE7e1tqFSqHDeS4eFhbG5uQqPRoKGhgRTC8/PzSZ/F7XZjenqa1LvHx8dhs9nQ29tL+Sw/Px8OhwMVFRVYXV1FOp0Gj8eD1+ulvRi71i0tLdDpdNSNdTgciEQikMvlEIlENBvPBL6SySQuXboEn8+HY8eO5YAqPB4PtbW1qKmpQSAQoM5ucXEx5X2LxYKamhrweDwC8bO1a4LBYI7qdUdHB0KhEOLxONra2iCVSqFQKHD9+nVEIhFUVVWR9/bi4iLNQGu1WvT395PiN3smUqkUdeONRiNplzCXGL/fT2DK9PQ0qqurcXAPu9fsXO/z+XJcP57Wgnl3fJxg+aMWzI86w/xpiKemYH6YeJiC+UEp2LuDIZ4PejOzQo/NDR86dOieG0RGN2IUonfeeSdnY9Df34+Kigq89957CAaD1Hn2er3Y3NzE5uYm5HI5PB4PkskkJiYmcpLl/v37IRaLsbOzQ8ju7m5z9qalo6ODFnL2GrFYDJfLRQi4Xq+nDixLjtkI5gcffED0MD6fj4qKCrhcLvT395P1U3V1Nba3t6lrzkSeVCoVdDod2RvweDx0dXVBr9djdXUVVqsVVqsVzz77LH0eSyBqtZo6rDabDS6XCz6fDwcPHkQ4HMbNmzdRX19PoEBvby9aWlowPT1NSo4ikYgEPNimiS2oW1tbdL8ZjUZC3Nn1YmJi7JwypDcQCKCxsREvvPACuFwuxGIxCgsLMTU1ha2tLWxtbaGsrAxms5lQWYvFgpKSEiSTSbzwwgt0nldXVxEMBqkYFIvF0Gq1WF5eBofDwfz8PPLy8lBWVgaJRILBwUEAGcXo/fv3Y2RkBLdv3ybbJavVilgsRgmdFbput5sES2QyGfR6PVwuF6RSKXQ6HTweD9lvARk1TafTCa/XS+MHUqkUFRUVMBqNZG3FOs0SiQRyuRzNzc05s1IAKGnJ5XIsLi5ifn4eCoWCABa5XI6BgQHweLwc30PWmWC2DQzZZ/cykAGC9iqYs1HntrY2oqB9ksXyw6w7u4OJ68jlcuh0upzNxvb2Nubn50k0iPlCPkwB/CgFM+s0fNZh/iwA5ChT3y8eJtc/KAX7cT+H+d8CGTeHvr6+O9hC2ZFIJLCxsQGhUIiBgQEMDQ3lbNjr6urQ29uLsbExGmkBMmvT4uIiUqkUQqEQhEIhHA4HxsbGUF1dTWyr2tpa6PV6jI+Pk56Hw+FAQ0MDAQ7ss4BMwWWz2RCPx/Huu+8iEAiAw+EgFAohGAxiaGgIFRUVWFhYQCKRoOJSo9HQuj87O4upqSkAmTEvNlLU1NQELpeLyclJNDQ0IBKJUGHHCkgej4fDhw8TaM7OwaFDhxAKhahjLhQKoVQq4fF46LsyMDkWi8Hn82FpaQnr6+tobm6GVCrF6OgompqaMDQ0RAKTAwMDuHjxItLpNJxOJ0pKSggcT6fTKCgoIHCX5TIgk9fZ5p99fiAQQDgcprWZvY7ZKJ0/fx7RaJTW37W1NUxNTcFsNkOlUqGoqAjLy8sAMiBGfn4+AoEAjh8/TkrnjJ5cV1cHLpdL8+ypVAqRSIQK94qKCggEAgL/q6urcerUKbzxxhtYWloCn89HW1sbAoEAjU+Zzeace/X9999HPB6H1+vFsWPHUFZWhmg0SoVoKpUiEKKwsJCcR9xuN7a2tqDT6SCXy6HX6+F2u1FXVwcej4fS0lK4XC7w+Xw0NDTc8bwrFAqyw4rH49RcOXbsGKanpzEzM4PDhw/T/DHLVdmjay6XixoPUqmUrhu7X3dHdq6vqKggAIONp31S8ai5HvhowXKW6x+24A6FQjlNul+keCoK5oe9IA+qnJlNwe7v788RoHiQzwAe/GYuKiqCwWCAUqnEwMDAfVFtlqgkEgnW1tYI2auuroZOp0NVVRUcDgcVUqzQ5XK5WFhYQH19PWpqasguiHkdAhm69/b2Nmw2G9GeWBHEbAOAD1U9R0dHaR4ZyBUdstlsiEQi1FWurq4m9eZ0Og2Xy0XHlj2jmEgkUFlZSR6YjCKcSqUwOTmZUSEXCKjoNZlMqKqqQl5eHnw+H/R6PYkOZIMcc3NzlFgZ2h2Px8kmidGTgExSZ4mRUVVSqRSpiLIE9cEHH5BqNTsvhYWF2L9/PzY3N+k9mSK50WjE+fPnceDAAdy6dYuKtLy8PPB4PBw9ehROp5PAhOzzwuyTtre3kZ+fDz6fj5KSEqK65+Xl4Wc/+xnNbI+MjCCZTOL48eMoLi7G4uIiFYQAcP78eaTTaXg8Hly9ejWHrgSArhu7rmazGRaLBXq9Hna7HW63GzMzM1AqlZBIJDmbxlgsRol5enoadrsdL730Us69LRQKUVtbi/HxcZrZZlTqY8eOwWAwwGAwkKAFh8Mhpe7e3l6cPHkS0WgUZWVlNI/V0NBA1DaWFH0+H9lxZVP6w+EwWWIwNJVR7WKxGIqKiuDz+ZBMJrGysnJHkZj9fEul0jv8yT+JYJuLJzFHvXuzkd2ZX15eRjQaJUVOlUpFG5m7xeOoZD/qDPNn8T9vPGghm03BPnjw4EODMw9TMDOvYQA4fPjwfe3SRkdHCbC2Wq2UT8rKylBcXIzW1lZwuVysra2RcBIrLpmgUl9fH0wmE2w2G8rLy6kLKZfLkZeXh3feeQdCoRDhcBjvvfce0uk0otEozZmyQtdoNFKHGfiwiyQWi1FcXAyDwYBkMolQKITOzk7Mz8+T0rHNZqON8O5nOZ1O4/Of/zz9m4H329vbdAx8Pp++UzKZRGFhIex2O1QqFdRqNelHsO++tbVF1qJMMDMej0Mmk8HtdiMcDmN6eprErhgAPD09TV1zqVQKlUqFlpYWhEIhslzKBkRZrlpcXITNZkM6nQafz4fNZsNbb72F5557Dn19fXjzzTcRj8dx+/ZtGh87cOAANjc3SThUIBDQPlMkEkGr1WJ2dpbGqUQiEaqqqqh5cOnSJXg8HjQ2NhLY39raitdeew1er5cYg06nk2a2Q6EQhoeHYbVaybOY/ZzN5MZiMcTjcYyOjqK+vh6NjY3Y3t6G0WhEaWkpsRTYa2OxGAQCAZqbm3Hp0iXcuHEDzz777B1AUGNjI1lbMiYgh8PB/v37Ybfbsb29DbFYTLl+bW2NAJ6TJ0/C4XBAq9XS/q2iogJTU1O0D1xdXc3pVmfbfDIHGcZgLCwsJHAlHA7THk4ul2N+fv6OIjE71zPBtqchHqdgzo4nDZY/Tq7/RWWTPRUFM/BkUedHoWDv9RlAJqHcq/hl6tEbGxs4evQoyh9QTTubbsJo5kVFRdBoNDAYDFAoFDnCB3a7HSUlJeBwOOjq6iJLIK/Xi0OHDqG6uppmeROJBBXagUAgx0RcKpWis7MT+fn50Gg0uHTpEqHljO4hEAhQXV2NyspKmM1mXLlyBTabDevr6zhy5AgikQi+973vIZVKYW5uDv39/YjH4zhy5AhsNhup2VVWVsJkMsHtdmPfvn1IJpPkD/3qq69CLBZjfn4eU1NTMBgMUKlUOHv2LC5duoTl5WUSPOjq6qL7g80zvfjii5QQmCAW8GFhzPz/WLCuQ2VlJeRyOXlOM5XG7e1t6PV6GI1GEk7zer10boBMx5XRlLxeL9GkgUxyXFpagtvtJpXrGzduoLe3947NW11dHcrLyyEUCsHlcqmD3dbWhlQqRfe2y+UiYMjn80Gj0eSAB6wQ5PF4JEwGZJDg/Px8WCwWOJ1O2Gw21NTUEBrN7oPa2lp88MEHCIVCMBqN0Ov1OQskSzQMSEgkErBarSgtLc35u+rqagQCAeTn5+cUszabDcPDwwBAid1isZC/5ObmJnkqRqNRXL9+nV6rUqngdruRl5cHrVYLl8sFuVye8/29Xi/eeecdpNNpnDhxAoWFhdBoNCgvL0c8HkdnZyckEsmeRSKzbUsmk0+dSjbbxHwUM9TZnXkA1Jl3uVw078iSaUFBASnusvi4VbI/i/+540EK2UehYD/K5wCZPDwzM4PW1tY9tUn2iuznh41a8fl81NfXY21tDRsbGygqKqLnPhKJEHDV0NCA6upqhEIhrK6uor6+Hj09Pbh8+TKAzPPLmFGxWIyYTOFwGDKZDM3NzUS7HRkZIWYXkBFcSqVSaG5uJjr51tYWotEohoeHcfz4cTQ1NeH111+H1+vF1NQUmpubEYlEUFdXB7VaDZPJBK/Xi/b2dtJbYcD34uIiLBYLTp48SWJft2/fhs/nw8WLF2nO2OVyYXh4GMvLy3jhhRdobxMIBHDz5k18/vOfh0QiweLiIlZWVogOLBAIoNFoYLVawefzaQ/AbJUY5fn27dswGAwoKSmhPZVeryfmHofDQTAYzOlMKpVKOJ1OpFIphMNhTE1N5YALBoMBDocDLpcLeXl5GBkZISp7diiVSip0BQIBdnZ24Ha7yeaQFZ1er5eOjdkpSqVSAvmZ9zYDhrP3hkwoVSAQYHh4GFqtFlKplDrPoVAI/f39lPuXlpZIeTjbc5qN+rHY2dmhmXYWeXl56OjoQDwez7GcSiaTuHr1KlKpFAKBACm9b2xsIJlMYn19HT09PUTVHRwchNvtJrq32+2GQCBAUVERzZ5ni5GmUilcuHABgUAA7e3taGpqIgV5o9GIzs5OFBcX71kkMnBHKBQ+lU4Ij1qY3i8eFyx/VL2SX+Rc/9QUzA8T97KaYBRs5j/8oBTs3cFEnO6VRLO9HR8W1S4sLITf70c0GqXOMPOIZZEtVMKUElnyADJUKKaCWVtbi6NHj9Ls5vr6Os2fSqVSvPLKK0ilUoSSNjY2IpFIENpdWFhIRTtD3hKJBJmoJ5NJWuxEIhEZ1JeXl+ONN96Ax+NBX18flpeX4XK5MDAwgHg8Tond6/UiFotBrVZTEh8cHCR6EvsbJj7BEsXs7Cz4fD7a29sxOzuLRCKBaDQKj8dDPpTZ5+vcuXNUBCWTSfz4xz9GKpUiehtLDgw153K5kMlkkEgkaG9vR21tLdxuN65evUqJmcvloqKiArW1tXA6ndBoNDCbzVSgtra2QqVSEZ18dHQ0x7+xq6uLjjGVSuUodrKOO/uuDEnXaDRoa2sj+hnrprNuw+DgIFwuFxYXF9Hc3JzjbVxYWIimpiZ4vV4SJLHZbCQclk6n4Xa7SW2RASwLCwvo7e1Ff38/bt++jcnJSchkMrS0tEAul2NpaQnXr19HZWUlDh06RJ93/fp12O121NbW5liyiMVi+jxmHcdEQIRCIfx+P7xeL5RKJfh8Ps2a5efno6enBxsbGxgaGsKNGzdw7ty5O56vYDBIm0wmYicUCu9QY99N3w6FQrhw4QLi8ThEIhFisRh2dnY+cY9jFh9lwbw7GNtCq9UinU6TIqfdbsfKygpEIlGOpcWjJFHW7fhFTaKfxcPFwwBUPB7vrsrV2WD1w1Kw9/qce+X6VCqFlZUV6no9jF9zUVERFhcXkU6nMTc3h1gshkQigYWFBdhsNpjNZjz77LP03IfDYYTDYQwMDNC6v7y8DJPJRCycnp4ezM/Po6KiAkKhEJcuXUIymYTZbMZLL72EYDCIsbExmEwmKBQKVFZWEotMoVAQC6irqwsymYxsDPPy8uDxeHJmEPV6PUZHR1FZWYmRkRHMz89TUTwzM4O6ujrS/HC73VScMpaUVCrF5uYmrl27ljNDyrqhrCPrdrvxzjvvoKWlBS6XC5FIBFwuFxaLBSqVisBXILM2Pvfcczlr9dWrV3NGm3g8Hnw+H3n9+nw+FBYWIhwOo7q6Gi0tLTAajZicnCSbSSDDrGPUX5FIBIFAQKNmGo0GPT09eP3115FMJqmQZp3t3QUz6/Kz+3JqagperxderxdqtZrYUd3d3eQfzQpRoVCIc+fO4d1330UsFsPNmzdx8uRJmlEGQA4bzD2lpKQERqOR/L1Z191isaCqqoqsL19//XXU19fjxIkTuHXrFqxWK0ZGRtDT04PDhw9jY2MD09PTBGKwgm5xcTFnX8CCw+FALBYjFApBLBZjbW2NgByhUAgej0de1ey43W438vPz0draCp1Oh3feeQdDQ0Po6em5w90ilUrRno15dsfjcbS0tOQcx15F4o0bN2C1WsHlclFYWIhoNAq1Wg2VSvWJehyzeFId5vvFw4LlTAjwYeOzDvNTFndLbrtVsB+Ggv0wn8M+a3JyEiqVak9vx/sFu6G4XC60Wi2pPieTSVgsFpSXl0On0yEYDMJmsxHdZmdnh5C3mpoauFwuKlJ0Oh39jiUStgnWaDQ5KpfBYJDoQ4waLRaLUVdXh0gkgjfeeAOJRAJyuRydnZ0oLy+nGVOGxCqVSojFYkI7rVYrCScZjUZK5rFYDFarFZWVlYQMTk1NYW1tjY5Vr9ejsbGRBLLOnj2LN954A0CGhv0rv/IrqKurww9/+EOEw2Hcvn07Z6FsaGhAR0cHeDwe5ubmMD09DbVajb6+PmxtbcHhcKCurg75+fnY2Nig1zHAIBgMYmpqCuvr6zky/2q1GvF4HJubm3C5XNDpdFhcXMyZD9va2kJTUxMKCgrgdruxs7NDforZCTSVSuHixYtwu904cOAAampqYDQaaaOk0WjI9zoYDILP5+eguCxYhzeZTEIkEmFmZgYmk4k2A0ajkWaS0+k0rl69ikgkgv379+Pll1+G2+1GIBDA8vIyKYizBXNtbQ1tbW3UVXa5XFAqlaipqSFwwuVy7emzzf7LIj8/nyjjg4ODOV6eLJGvrq6is7MToVAIZ8+eRSQSgUAgIMEb9h3Y8WRHSUkJgS8AcOHCBfB4PDz//PN3WJqwYMg9n88nURSmPmk2m8m2IXvu5+O2mGJrzsedyDkcDhQKBRQKBaqqqshj1eVyYXNzE3NzcxAIBJBIJHRfPMi5YRudX9Qk+ll8dHE3cPxxKdi7I9tlYHdEIhFMTU0hHo+jr6/voQVtstciNiLCxDhtNhsqKipQUlKCtrY2bGxswO/3I51Ow+FwUG4vLy8nsSMGMDLQ0uv15rCS6urqiL0EZBhCOzs7JB7K4/EQCoXQ0NAAuVyON998Ey6XCzKZDKWlpTlOFn6/HzabDVKpFBqNhopum81GM6Ns7IlRpaPRKHkeS6VSGI1GKnZTqRTq6+upIOJyuWhra8OtW7cQjUZhs9lw9OhRvPbaa/jxj38Mv99P3rtsL1FSUkLK5yaTCdeuXYNQKER7ezvy8/NhMpmQn5+P+vp67OzsUO4IhUKUgwYHB0njJdvSp7q6Guvr67DZbOjp6YHBYMC+ffuI8WSz2RCNRqHX6zE3N0eq3jwej8ANFpOTk1hYWIBOp0N/fz+i0SgB6QqFAhaLhTrAXC6XZlGzQy6XQ6FQwOFwQCQSwWQyYWZmBqWlpfD5fDTvzI5/bGyMtFFeeuklOJ1OhMNhAluEQiHZk87Pz6OpqYnms51OJ4LBIDQaDdGio9EovF4vjR2wHB8Khe6wPjx79iwV/axYBkAaIzMzM+Qg0t3djcbGRvD5fOqwZtPDdwefz8fBgwfhcDhQXV2NN998E8lkEocPH74nq5PZo7FjLCkpgUKhgMvlgsFgAI/HywGEH0cQ81Hj4yqYd8f9wHJW09hsNhQUFDxwPfWZSvbHEA9Lyc6mjjwJCvbdPmd3ss7+rPr6euh0ukf6rM7OThQWFmJubg7t7e0wm80YHR3F+fPnIZfLweVysbq6img0ip6eHrz//vtIp9PY3t6GUqmEz+cj64dAIJBjgQCAxJocDgchSkxxeX19nUSngMxixATLZmdnodPpKMn4/X7Mz8/nzJKMjIzQwnnx4kW0tLQgEomgvb0darUak5OTMBgM0Ol0aGhogMVigcvlwtzcHDjpNFrq62n2hAk5MYqQ3W6Hy+WC1WoldW12/BKJBGq1Gk6nk94TyMxLOZ1OfO9730NfXx8lcKfTicnJSbzwwgsAMiAHo/7sFSaTia53ZWUlFAoFKioqMDY2Bp/Pl8MGkMvl5LMoEomQSCTQ0tKC8fFxBAIBiEQivPTSS/TeS0tL2Nraok6w3W5HYWEhAQwMbW9ra8P6+joaGhpw48YNOJ1OdHV15RTeHA4HTU1NkMlk0Gq1+NGPfgQA5OEYDAaxsLBAFCuGRns8Huj1eiqmFxcXyaZArVbD6/UiGAzCYDBAr9cjlUrB5/Ph7bffhk6nw9GjR/Huu+/C7/djbGyM5riOHDmCra2tPT2PuVwuhEIh8vPz4XQ6kZeXh4GBAUxOTtLn/vCHP0QymURDQwM8Hg+sViuam5tJlIPZa+yO+fl5zM3NIT8/H5WVlQAyxWa2D/leweFwcOrUKTgcDmxvb5PiJtMEYPfJbtpSQUEB8vLyPvJCliXQTxr55vF4UKvVtHlmXZR0Oo2FhQXE43FSJi8oKLgrWs9GIz4rmD+Lh429crDD4SBA9FEp2A/yOcCHdO/CwkJ0d3c/0meVlpbi+eefx+TkJPR6PXZ2drCxsYHy8nL82q/9Gng8Hmw2G5xOJxoaGrC0tASv14uNjQ10dHTAYrGgrKwMr776Kux2+x37JKVSib6+PkxPT1OBnUqlUFpaiu3tbYTDYdy6dYs6ttFolOZgtVot5aRgMIjV1VVad4GMxSPLp8xOiK2VPB4P169fRzAYxO3btwlsTyQS2NzchM/nw5kzZzAxMUFCWb29vQQCR6NRmEwm+P1+lJWVwWAw5NBma2trMTk5iXg8jgsXLiAWi5Ey8k9/+lPU1tZCLBaTGNbw8DDOnz+P7u5uRCIRGI3Gu+omRKNRokOLRCK0t7cT4L2+vk5q1kyXo6amBmNjY3T9q6ursbW1RfugM2fOECOQ0fbZumez2chdghX9BQUFqKioIIEko9GI+fl56HS6HEZaOp1GTU0NysrKsG/fPnID4fP5VPiNjY2Rx3E2eM3lcmnv5HQ6EY/HEY/HUVZWBrvdDrFYTPPFzLP6jTfegFgsxunTp8kP+tq1a3j55ZfB4XDQ1tYGsViMoqKiPfdRMpmMWJ1cLhcDAwPwer1YWFhAbW0teXcrFArU1tZiYmICBQUFOHXqFI4fP45AIIDq6uo73tdut2NwcJAExdizmg3C3y26u7tRWloKr9cLkUiEiooKVFRU7Km+zWZ8CwoKkJ+f/7GA5Y9KfX6SsRdYvra2hp2dHQLL8/LyKNffDSxnzZ5f1Fz/1BTMDxPZqHM2Bbu3t/eJysOzGUcW8XgcMzMz8Pl8j0X3Zu9dVlaGhYUFuFyuHIRYIpFgfHw8Bz1nSK9er8cbb7yBZDKJ9vZ2zM3NIZFIYP/+/TlFLZ/PR2trK0ZGRij5MYsdFmzxbmtrw+rqKlwuF0pLS1FWVob29nbYbDaaGTaZTNBqtYjFYpBKpTndxOLiYiroKioqaJZ6enoaRUVFOHLkCH76058CAHYuvIOpv/4GJM+dRfzn9gErKyuQSCRQKBS4evUq4vE40YMKCgpoNiVbQRT4UCU7FAqRevfMzAy6urowPDxMtCSj0YjCwkJcvHgxB81j3UWVSoX19fWcuSC/308WTnV1ddje3kYsFiNEtKioCM3NzdjZ2UE6ncaPf/xj8Hg8aLVatLS05IhlpFIpsgtTKpVQqVQkrsFsrrxeL2ZmZqDT6XDixAlsb2/nbFRee+01uo5jY2PY2NiAQCCATqdDZWUlLBYLJRqLxYKKigpsbGxAJBLhyJEjmJ6exurqKtl1AB8iucxaKp1OIxAIwOl0wuVywe/30/3icDggk8mIdpV9HdRqNaLRKEZHR6HX6wnxNRgMGBoaglQqxXPPPYd4PI7a2lpSGNfpdDn3/s7ODnUtWJeeofZMBKakpITQS7bRYyJxjF5/L89VFkz122g05iSr3bQlNmPndruxublJlK+Pkr79SSHO9wuhUAihUIiCggISbmHnZmNj467nhiXQR/lO//E//kf8xV/8BaxWK9rb2/G3f/u36O3t3fNv/+7v/g7/9E//hNnZWQCZjdIf//Ef5/z9b/zGb+Af//Efc153+vRpvPPOOw99bJ/Fo8XDUrIZOJ5NwW5sbIRWq31ioNLugvlxFLf3CvY8RKNRyp02mw1VVVUEpra0tKC0tBQKhQLz8/PQ6/W4cuUKdnZ2UFJSQqM1paWlOHXqVM7719fXY3t7m9blmZmZHH9moVCISCQCrVYLpVKJ2dlZlJeXg8/n48iRI1hfX4fZbEYymcTq6iq6u7sJhM9uZggEghzhUPZzg8EAv99Pto8ejwc+nw/f+c53IBaLweVySexKLpdDq9VicHCQgPqysjKcPn0aKpUKHA4HLpcLHo+HWFysMAoEAjlsqFOnTsFsNsPtdoPL5WJnZwd8Ph+3bt2C3W7PuWa1tbVEOWcdVBZM5ZpZ8TDLRiAjzlZXVweVSgU+n0+2kUqlEv39/WSbxGJmZoao4TqdjortjY0N8Pl8lJWVYWNjA2azmeabv/e97wHIAOvZVqAbGxsk2FpSUoLa2lr4/X7U1dXRLHN2gXno0CFMTEzAYrHg0qVLOHHiBLhcLnXCgYxQGbO/Yrk+mUwS8y4SiVBR7/F4cnK9RCJBbW0txsbG4HA40NraCg6HA7/fjwsXLiCVSuHkyZNob29HMpkk1lxhYSHkcjmBFH6/n7rtbrcbqVQqhxW3ubkJiURCeZg9M0xTqL+/H+FwOGcE7G7B5/OJGZidg+424+t0OrG4uIh4PJ4Dln9U9O2nMd/zeDxIpVLk5eWhra0NsViM6Nv3A8sfdYb505DrP5UFM0tujIKtVCqfCAV7r89hi6bX68Xk5CTkcjkOHTr0WLYziUQCly5dQjAYhFgsRnl5OVpaWrC1tYUPPviAOmaM6j00NITV1VXs378fCoWCklQymaQkv5uyurKygp2dnTs68UBGuIGpR66urmJiYgLnz5+HRCIhBLWjowPBYBA//OEPkUqlsLm5Ca1Wi6mpKaLbyGQydHd3Q6vVknVXV1cXmpubCUFvb29HKpVCe3s7JsbHYavUwVapA5JJVFVVkaKx1+tFR0dHjq/k9PQ0vvCFLyCdTuOtt97K6cZWVlZCo9FgZ2cH7e3tiEQisFqt8Pv9WFlZwQsvvAC73Y6hoSFcv34d1dXVdD3ZNY3H46isrMTY2Bh1q/Pz81FXV4fi4mK4XC6YzeYcVWqZTIZUKoX3338f7e3tCAQCRC1PJBJIJpOUwMLhMNbW1lBaWgqdToft7W14vV4IBALIZDJC6Bjay45pc3MzR7CMqasyuha7zwUCAbhcbs48cTY9aWNjg2wTGCXObDajrq4OFouFZtfYBoEtkJFIBLOzs6QUvr6+Tt2EvLw8FBUVoa6ujmaTbTYbRkdHEQwG4fP5UF5eju3tberGh0IhonBzuVy6N3d2djAwMIDNzU2yPKurq8POzs4dVPTh4WEYjUZIJBLq3LP5u9LSUggEAjQ0NOBhI9tqYq9gIivl5eUkQscYDrvp20z1/HHjaUygLBgazuFwIJPJIJPJCK33+XxwuVx0bqLRKH7wgx+gurqa5tkfJr73ve/hq1/9Kr75zW/iwIED+MY3voHTp09jaWlpTxufa9eu4Zd/+Zdx6NAhiMVi/Nmf/RlOnTqFubm5HOuQM2fO4B/+4R/o358EDe+zeLBguT4SiZAN4JOgYO+ObHA8FothamoK4XCYqL+PE6Ojo1hdXUVBQQFRqVdXV7GysgKTyYSSkhKiem9sbODmzZvQarWorKykDWEqlaIcvzvX2+12rK+v59hHsVzP4XBQUlJCnVaj0Yiamhr8yq/8CuWRqqoqVFVV4Sc/+Ql8Ph/W19fR3d0Ns9lMFGyZTIbq6mq0tbVhe3sb6+vraGpqIjsstgcTi8Wor6+nXABkCjCRSASfz0esnv379+fMppvNZnR3d0MkEmFiYgLT09P0O6Zyvb29jdraWng8HtoLXLt2DefOnUMgEMDCwgKGh4dzCtjsbjyzcGKFoUQiIf9sr9dLjDRWnEskEgiFQszNzWFnZwe1tbUYGhqi90wkEigrKyMQnQHSlZWVVAxarVZ0dHRQXkgkEjnFq8FguONeZuNVAHL2tHw+H3V1dTlMrvr6egAgJW42JgdkusqRSCSHdi4QCKgZwDrF8/PzSKVS6O7uxvLyMtLpNCYmJuje2bdvH9GmmW6K2WyG2WxGdXU1UqkURkdH6fnxeDzEumMisEBGW6WgoAB+v5+aLCKR6A4R0bW1NYyMjAAAzp07B4VCgerqakQiEQiFQhQXFz9S4Xq/XL+X1sluQJjl+idJ335a831251soFKKkpISAu73OzXe+8x00NjbC7/c/dIf505LrP5UFM5fLpbm6J0nB3h0M3d7a2sLS0hJqa2tRXV392J/F5gRYMOVrlpwSiQTa29vpc9bW1khpsKGhAc899xy8Xi+qqqpQUVEBj8eTg7T5fD4SoMq+cZ955hlMT0/D4/HQ7AorWJ1O5x0+tTKZDO3t7bDb7WQTkT2bwITIPB4PdVDj8ThisRh6e3tRUVEBDoeDy//1v8KaVUiI43FEBQKUl5dTAeJwOHD58mX09vZifHwciUSCisfy8nIqaIHM9TebzTS/arVa0dbWRoW83W4Hj8dDSUkJdVHNZjMaGxsJCWexvr5O783n8xEKheB0OqkgLC8vh81mg8/nA5/Pz/EOZt194EMrKovFgh/+8Ifo7+/H7OwsHA4HFhYW8Oqrr2JwcBCbm5twOBxIJpPo7u4mZeiKigoUFBRgdHQUFosFarUaeXl5NCs0MjKCF154AalUCp2dnSgrKyM0/m6RvVk4cOAADAYDxGIxdfulUimKi4tht9tx+fJloq6PjIwQ8r9v3z7yvl5YWKCuBbMAicVidL7Z9xgaGiI1VsZiGBoaIhRy93zLyy+/jNdffx0rKysoKirCiRMn7vgu7P15PB6h0xUVFTn0tUeJdDr9wMmKy+VCqVQSiyUej9OM78rKCiKRyBOhbz+tCRS4u0o2l8tFfn4+sW6YqBGHw8E//MM/wOl0or+/HydOnMDJkydx8ODB+wKcf/VXf4Uvf/nL+NKXvgQA+OY3v4m33noLf//3f4/f+Z3fuePv/8f/+B85//7Wt76FH/3oR7hy5Qq++MUv0s9FIhF1Mz6LpzuYcNGtW7dQWFj4xCjYu4PH45G/6+TkJPLz89HX1/dEQHgmNunxeJBKpaDX62l9DIVC6OnpoSJnY2ODKM2JRALPPvssjEYjAXbM+zY73n//ffJpZgVza2sreDweTCYTSktLUVVVRV63FouFRliyo7u7G3Nzc0TvZQr5jGZpsVjQ3d2NGzduIBaLwePxQKFQoK6u7q5Cnmw2vKKiAhKJBA6HA/F4HIODg+QRzArUlZUVHDhwgNhi7PVutxuxWAz79u2D3W4nICEajSIWiyEQCKCwsJDeJxQKobm5mbr5rJCzWCykWcJEQW02G9l6FRQU0LgJex/2nna7HU6nk3IqcwD50Y9+hJaWFkSjURIOO3XqFHp7ezE8PEz3VGdnJwHv6XQa/f39WFpawu3bt6l5EQwGEYvFMD8/Tx1krVaLkydPgs/n35M9mZ3rm5ubkUqlIJVK8bOf/Yx+V1dXh9XVVVy+fBnnz58nJXPGIjMajTh27BiADwXYAJC+jUAgoOKXrfebm5uU+9jPmQe3QCAgu0wg0xQ5ffo0bt++jbW1NVgsFrzyyit3PGMsv7BrtL6+juLi4hzNmkeJh8n1ewHCXq8XbrcbJpPpidK3PyqV7MeNu+X6u50buVyOb3/72/D7/Xj11Vdx7tw5nDx5EseOHbsv8/fTkuufmoL5QTeWTNE2Go0+cQr2Xse0sbGBSCSC7u7u+/otPmio1WpUV1cjGAwinU4jFothaWkJSqWSBJmyO4o9PT1YW1tDe3s7vZ7NFWbTR1kw9JBRkpmf8eLiIjY3N8Hj8ZCXl4e8vDyaF37//ffh9/tzvOmmpqYwPz9PNlRARlxLpVLh4sWL5P9bX18PmUxGqFP2MV25fBk2ZmkVCmH/mTNE345GoygqKsLrr7+ek4i2t7dJEOP69evo7u4my6eqqirMz88jmUxiYWGBBC9aW1vR3t4Oq9VKNF5m4RGJREjRHMh02JnCMpur5XK51Ak1GAyQyWSYnZ2FTCYjb2jmJckUIVnhzboTJpOJzvXQ0BAlEYbut7S0kIDVW2+9lZMAotEozUsDIAS9srISm5ubUCqVePfdd+FyuVBZWYnS0lK88cYb0Ol0OHjw4H3vOSbukO3ByePxCHlOpVI0N84o4kAGaGBJj23qOBwOenp6kE6n6XiTP2cMsPPHQiqVUlHNNkzZKB9jFMhkMrJC2Sv27dsHqVQKvV6Pd999F9FoFHa7/YG++73ifqjzvYLZYBQVFQHIbLCYbcPW1hY4HM4j0bef1gQKPLitFBsJ+da3voW33noLX/va1/DlL38Zly5dwje/+U10dHTg4sWLd319LBbD2NgYfvd3f5d+xuVyceLECQwODj7QsTIl1d3r9rVr11BcXAyVSoVnnnkGf/RHf5Rjh/ZZfLTxoM9bOp2GxWJBJBJBS0vLE6Vg7w4ulwufz0ce9U8ShO/q6sLq6ioUCgVRX+PxOHXP5+fnCfhjeiDl5eUkyKnX6+m9WDGbHdkexqlUirROVlZWEIvFUFdXh7y8PBw4cAAbGxvka3/q1Cn6jmazGbdu3YJGo6FiuqCgAK+88gree+89uN1uoikzSnEsFqNZaSa2mV0s9/T0oLq6GgKBgMZ9bDYbNQtUKhVqampo3nlxcRHRaBR1dXXw+/2oqKig91tbW6OC1Wg04sCBA1haWqK1FcjkEAZ+sw4l+xy32w2z2YzS0lKyKHQ6ncQmWFlZAZfLzWE2SaVSRCIRohJn20ptbW3RnmVubi5HqFEkEtG4USgUwsjICHQ6HWQyGTUZdDodFdCsMK+ursbGxgZkMhlGR0dhs9kgkUjQ19eHq1evQigU4uTJk/dlN+bl5eHQoUOkY5L9fVj4fD6EQiEUFxcTEywYDNIehyl7p9Np1NXVobS0FCsrKzn3XHFxMWZmZnI+1+/3IxaLkais0+kk0JzdmyzHi0SiPXNJSUkJGhsbaWRxc3MTIpGI5qgfNR4n12fTt7O1TljH/VHp2+ycPI0A+YPmenZu/vzP/5z29F/72tcwNjaG3/7t3ybB3Lvpynyacv1TUzA/SDD0VyAQQK1Wf6TFMuuwiUQiHDp06InS9ng8HvnPXrp0CRMTE5BIJOjq6qKCxu/3U8HM/HGZeub9HkSXy4WamhqUl5djamoKfr8f09PTJI4BZKhAXV1d6O3txXe/+10AmaSUXTCzhWBpaYkSNaPpHDx4EIODg0Q5Li0tRSqVwvr6esYywu+HfnoWRk0RwOOhwGRCf2sbCn5OV97Z2cHbb78NIJOYXS4XWlpayHuwubkZCwsLSCaTGB8fh1KphEwmI4RTIpGQoiWQoSSxhaeurg4//elPIRAIEIlE7hCUY57AQObBZAX/6uoqzQ0zJXCW4ICMsmV3dzeMRiNqa2sxPT1NFGTWqWfBzrNMJsPBgwcxMjICrVaL9vZ2Uv82GAzQarUwmUzY3t4mJWu3242lpSVKXE1NTVhfX6f33NzcRDQapc1Xb28vLbjpdBoul4uS4+57paOjA3Nzc5DJZKRYrtVqEYlEcPXqVXC5XDz//POIRCLY3t7G9PQ0qqurIZVKUVVVBYlEApFIRM/ekSNHYDAYIBKJEIlESPETyFD98vPzaaMyMzNDHswNDQ1YXFzEyMgIiouLcfz4cXg8nj1BqUgkgsuXLyOVSuVYdDyJDe2TTFaMvq3Vaom+nU1RflD69tMgAnK3eBQf5mAwCJVKhS996Uv40pe+hFQqlcMY2SsYC4OJAbLQaDR3PGt3i9/+7d9GWVlZDmPhzJkzeOWVV1BdXY21tTX8H//H/4GzZ8+SoMxn8XQEo2CHw2Hw+fx7KuE+bsTjcVitVoRCIfT29j6WNsle0dTUhKamJoyPj8NoNCIWi6Gvr4/yX7YeCOui22w2RCKR+4JsgUAACoUCR44cgclkQjwex9TUFNxuNyKRCOLxOHUsGxoaSHPDarVS5xDI5KJoNEoKymxzK5fL8cwzz+AnP/kJuVOoVCrE43EEAgEYjUa4XC7o9foca6aqqipipTF7x3A4THZcBQUFqKqqgtvtRmVlJXUpDQYD3G43xGIxfD4frc+tra24fv06EokEjfMAGUD54sWLSCQSOcwxFjweL8dCsr6+nvYEDJRmBXwqlaICncvlkoCoRqOBz+fD8vIy6urqcopE9v1YHD9+HCsrKxCLxejo6MA777yDSCSC5eVldHR0YGpqColEAj/96U/Jnmx6eppmc5ljA9vnBAIByv2RSAQulyunY5ZdyO/OhzU1NaSg3tjYSF676XQa169fRzqdRl9fH3p6ejAyMgKr1YqtrS3U1NRAJpPhzJkzCIfDKCkpAYfDQXt7O9lQMmadSCRCNBqFRqMhNh6j37Nr1NjYiMXFRWxvb2N1dRVNTU0oKSmhRsXu+OCDD+ByueB0OnPcZB43nmSu303fzrZoehj69sdpIfmwkUqlHprNw0YJX3nlFfzGb/wGAFCz5G7xacr1n4qCOZ1Ow2AwYG1tjWY2ssWrnnSYTCbMz8/TfPFHNeNmtVqRTCZpRoeJdwHImVOxWq24ceMGgAzFdS8VQRapVAqXL19GMpmkRMySXF1dHc0aZlsgdHd3Y3BwEF6vF5ubm4Qwd3V1YXFxMaeIZpE91zU7O4u6ujrU19fDZrMhGAzCPzaGyR0HeCol5EVFyK+pwQdOJ/psNhQXF+PatWv0epFIhNdee40EpRwOB+x2O3k9q9VqUgdlSSEcDsPn8xHNSCKREH0q2+83+zsyIavu7m5cvXoVsVgMMpmMRDXOnz8Pp9OJUCiESCSCpqYmRCIRKsrr6+tx8+ZNolnp9XoEg0HU1dUhFotRF5qJh4nFYiiVShI3WV9fz6EoMeGa7373u0in07Db7dQ1PX/+PEwmEyYmJgBkmATZM19NTU0knBWPx+FwOKDRaGAwGDA6Okqg0u5Qq9UE1rCoqamhzQ6b8WYz13l5eYjFYrh48SIEAgEOHTqEmzdvgs/n4/jx46Q6yYToent78bnPfQ7BYBAulwtTU1PUuc+ep89GyRmqXVhYiHQ6jeXlZaLV7UWJPH36NJxO5x0WHA8b6XT6sVDne0U2fZttghgifT/69tNMyX6U7vdu1Uzmh/lRxp/+6Z/iu9/9Lq5du5ZTdHzhC1+g/29tbUVbWxtqa2tx7do1Gj34LD7ZYCrYhYWFaGxspPGijyJ8Ph8mJibA4/FyRgqedAQCAbhcLggEAvT399Mss9frzelqJpNJXLx4kfJ3f3//Pd+XaTswYSMGtDY2NqK4uBhLS0s5+bu1tRUmkwnRaBQTExPkdMAcCjQazR2b2+xn12g0QqvVYmBgAKOjo/B6vUgkEpiamgKQyXlVVVUwm82Ym5tDc3MzRkZGaG7X6XTilVdegVwuRyqVgtlsJmp3MpmkrjortoDMmrO4uIhDhw7hgw8+gEAgoDluj8dD4o/Z3zGRSMBqtaKpqQkbGxswmUwoKirC+++/DyDT/a6trcXa2hq8Xi+ampqQTCapYK6qqiLf7ZWVFRw/fhxVVVWorKzMsWZiRbpQKEReXh7m5+dpNMxoNNLvKysr0djYCKPRCIfDQZ3nyspKvPDCC/D5fNQs2U0h1Wg0CIfDEIlEUKvVMJvNyM/PJ/XwdDqNysrKO+5dkUh0BwOroqICXq83Zw67pKSEmghKpRKXL1+G1+vFwMAAlpeXMTQ0hIGBARQVFaGyspKYbuXl5Xj55ZcRiUTg8XiwuLhIPs/ZWjSM5cg+j8Ph0N7EarXCaDSivr5+z7nz/fv3o6ysDIWFhY+dpz+qXM+sKrO1Tpiex/3o209zwcxsSx8mgsEgnQ8We80gP8n4OHP9U1Mw3+1GZlYmwWCQKNgmkyln8/2kgtF8bTYb2TnczZvxcSKVSmFpaYl88Zj/8uuvv45wOIzDhw/nPEBMMCedTucks3g8jps3byKVSmFgYIC6b0wJki08TBVzYWEBL58/D84//Tdwdn6M9P/yJXA4HELJgEwCYgWzXq/PoSNlb5SZtHw6nUZHRwcqKyvhdbtRxudjBYC1vBz4eVeAqVADoEI522tvZ2eHbvTJyUlabJlHZUdHB3UnGxoaaMZoZmYGsViMZl2ATJLQ6/WwWq2UVI8ePYrS0lJcvHgRTqcT8/Pz1EVlIiRcLhc8Hg+tra2Yn58Hh8MhZFculyMvL48KUSDTTcymi/h8PtpwFBUVER2upqYG6+vrxA5gnTWlUomysjJwOBzs27cvB52PRCLIy8vLmeVis2ILCwskeHby5EkAwFtvvUXenkxAhFlIMFAglUphZWUFPB4PtbW19LwtLy/D5XKhubkZQqEQMpkMcrmc1MGbmppgMpkQDodJxIxtAnZ2dujeZeef2Vnk5eWBz+cTus/n8yGXy3NExpjyaDaI4Ha7ieYtEonQ2NgIsViMU6dOwe/3o7y8HFwu9652IQ8T7J7/OJIVn8/PoW9nI9Ksm8ASajwefyoTKPBo3e9HsZkoLCwku53ssNls951J+su//Ev86Z/+KS5fvkyK8HeLmpoaFBYWYnV19bOC+WOKu+X6VCqFtbW1HBXsWCxGwNaTfCYYbXlpaQk1NTUQi8UwGo1P7P2zgxWPUqkURUVFEAqFuHr1Kra2tlBbW5uzlrFxn2AweMcaNzU1BbPZjN7eXio4lEol2SeFQiHk5eVhbW0Na2trOHbsGDo6OuB0OlFWVgaRSIT8/Hw6j9mFplqtxuHDh2E0GkkAMvuYSktL4ff7UVlZSUKeAoGA6LYsUqkUdnZ24PP5MD4+junp6Zw9C/NozsvLIz0PIMOKy24cOBwOVFRUwGKxIB6Pw2KxUN7Jz8/P6TBn/06v16OlpQWzs7Nwu90YHR3F888/j0AgAB6Ph7fffhvpdJqo7i6XC6lUChsbG8SOqqysxPr6Op0nuVyOmzdvIhqNwul0krWlVCrFgQMHMDIyglgsBq1Wi2QySQUz+248Ho/Gr5qamnDjxg3aVzLh12zV7kQigWeeeQYzMzOQSCQoLy+nPdnExAQWFxchEonQ399POSwWi+UA6iaTCW63G/X19QRO22w2rK6uora2Fs888wzC4XBm3+b1orKyksYA2Lk1GAw08725uUm5i11vNlIokUggkUjIHYXRch0OB4mM7du3D3w+/w5V6xs3biAej8Pr9dL6e+zYMbJSY0DQk4iPC4jO1vPYTd9mYpj5+fkoKCh4oh30Jx2PyiZjLNEHjU9Trn9qCua9IluAI1sF+26eiY8TwWAQk5OT4PF4OHToECQSCex2+xP/nEgkgomJCfh8PkI/U6kUotEoobC7EVOVSoWXX36ZEEAWJpOJKK6bm5sk2nXy5EmMjY0hmUwikUjQeUsmk7C+/TYU3/i/wAHAa2iAsP8Q8vLy0NPTg2g0SjQqIIOKsznDaDSKlpYWmM1mcDgcUnbu7u6mhfTqj34Er0AApFIAl4tigQAhgQAVFRUQCAQwGAy0qFdWVoLL5WJrawuJRAKDg4M0H81CLBZje3sbDocDn//856nDbLPZ4HK5EI/H70DoWFEnEAjA4/GgVCoxOTlJlCYgQ2N6++23icrmcrnIm3J5eRlcLjdH3CuRSFBiSqfTOHXqFKRSKSVz5ncNfIiwAZkFOhwOkwiH1WqFQCBAVVUVgsEgbt68iXA4DKfTSXNWQGbeOBgM5qC0q6urKC8vx5kzZ+hnrHhh4FEikUBTUxOEQiGSySSmp6fx7rvv4sSJEwgEAiTMxpSlQ6EQFad8Pp/YDbFYjBgN6XSaZsMFAgEaGxtJAM3hcGBychJdXV0YGBjA4OAgFhcXoVarodPpIJFIqBvAbCqam5shFoupWGRqmyqVCmq1GjKZjDZhDLFXKBQoLy/PuTeeRHycBfPukEgkNFe+m77t9XrB5XKxvLz8RNW3HzfYfP6jJNHdQm/3C6FQiO7ubly5coVU0VOpFK5cuYKvfOUrd33dn//5n+M//If/gHfffZfu53uF0Wh8ImyFz+LxIhKJYGpqCrFYLEcFm91rT3JMIZFIYG5ujjzu1Wo1sb2eZLDOqMFggE6ny3HdYMDp7tEENhLj8/lyWBixWIwEF2dnZ3H48GHE43F0dXWBx+PBbrdDJpNBpVLRZ7BRECBT9HZ3dwPIWA+ZzWZi67G4fPky/H4/tra2cObMGbjdbmJLJRIJ1NXVkUfzjRs3SG0ayAC6iUQC1dXVyM/PpyKSuSM0NDQQ82t4eBjd3d056tAikQhutxvXr1/HSy+9hH/2z/4ZOBwOxsbGSCmc0T2zmyWMgcV0W1wuV878ciwWw5UrVxCLxXD8+HH09PRga2sLEokEs7OzOUw8ds1YgZ9KpXDgwAHodDpcu3YNOzs74HA4WFlZodye7brB6MudnZ10XHq9HuFwGOPj4yRWmm2vxEChbEtLh8MBs9mcQy9ln8G+ezKZhFqtxqFDhxAOhzE1NQWLxYJwOAy9Xo8PPvgAQAY47+zsBPChmKfT6SSBTyDDQHQ6nTCZTHjxxRexb98+Eobl8/lwOp1QKBR48803UVVVhWPHjuHq1atwu90YGRkhmzG5XI5AIIBEIoHCwkLodDrodDoqFl0uF27evAmlUgm1Wo2CggKoVCrY7Xao1WrSC6qvr78ni/JR40HGGT+KuBd9m+m9zM/PP3H17ceNR1lzA4EAZDLZQ53nT1Ou/+R3YXvEbgq2TqfLuQBPumC2Wq2YnZ2FVqvFvn376CbZ7cP8uOF0OjE1NUUzRDabDTqdDqlUCnK5HAMDA/B4PHuqAe5lo6HRaJCXl4dUKgWZTIbvf//7SKfTKCwshMPhIFpoXV0d+G435s1m3IjHse/wAOpGx8CryHSAL168CJvNhoZrHyBaqYPgD74GIHOe2bkWiUTY3t7G1atXAWSQ7UgkAi6XSwuRJByBVyCAemsbnUVFiP3Xf8T13/wXuH79OkpKSnLmXjo6OqBQKEjtbnl5GSsrK9i3bx8KCwtRV1eHtbU1RCIRSKVS2Gw2zMzMoLq6mgqxzs5O+Hw+mvVi8w4MRJBKpfB6vYhEIrh9+zbOnDkDs9mMQCCA1dVVhMNhWCwWErMIBoM5YAVDRKuqqiAUCrG8vIzNzU1cvHgRhw8fRnd3N6anp2E0GsHhcJCfn4+8vDzqGMrlcipIGWLPClNWJDFAwufzQSAQQCKR4P3330cgEKDuP5uxyqYnb21t4datWygoKMDx48fpXuLz+WhoaKA5q3Q6jcXFRaL9cblciEQiuqZMqMNqtSIQCEAul1M3OBAIID8/n7ycWTzzzDNIpVI53pFdXV30rAQCAZhMJjidTuoGsMKedVDKyspQVlaGdDqdY9Xk8XiomLRYLCSMwlQ9n2RkW698krGbvm0wGOByuZBOp5+o+vbjBtu0fRwFMwB89atfxa//+q9j//796O3txTe+8Q0Eg0FS0vziF78IrVaLP/mTPwEA/Nmf/Rl+//d/H9/+9rdRVVVFnR65XE7387//9/8ev/RLv4SSkhKsra3ht37rt1BXV4fTp08/9PF9Fk8msinY3d3dOeBQdsH8JBSrA4EAJiYmIBQKyZKEfc6TZJMxYDwajcLhcMDhcKCmpoY6w0ePHsXa2lqOoBcLkUhEIDQLgUAAnU5HCtdvvPEGPB4PysrK4HQ6EY1GodVqIZPJcOjQIczPz2NpaYlUqhnYODMzg/HxcQKez5w5Q+dVJBKRbkskEsGbb75JasvpdJo2mul0OucaMT0KICOApVKpyEEByIxDVVVVkdCU0+nExYsXodfrUVxcTFTi5eVl2m+8//77kMvlEIvFNMPOxMZKS0sxOTmJZDKZM5pXWFhIm+Jjx44RxZcBxUajEYuLi4hEIggEAjnWjUCmA1VaWoqysjIIBAKYTCYMDw/D7Xaju7sbw8PD1AXLy8sDj8cj5hyHwyGrsGygo76+ntwumCWV3+8ni8XNzU1MT0/T+d3tDw1k7tl3330XQCb3qlQqFBYWgs/no7KyksYKgIzSeFNTE80Wy+VyxONxCAQCYgnE43GYTCay31GpVJSrmWMLC1aIvPfee/D7/ZidnUVzczPler/fD6/Xi42NDSgUCgLWmYDnbmYVE4ZlxSKbfxaLxcTY4/F4ez4XjxtPg7jWbvo2u3YSieSJq28/bjwqOP6wbDLg05Prn5qCmW0A96Jg7w4+n/9ECtlsanRLS8sd7X9mNfG4kQ0ANDQ0IBgMEv0ru/gvKysj2kxTU9N9LYOWlpagVqvR09MDm81GBSl7T9ZhTi0soug3/xUiv/VvAT4f/s9/DgX/1zfAzc9HOp0mCo6rrASR7/8A8p8XzBKJBM/39MC/toay6mrMZ9GGWQd28fp11P+7r4FTU4Pj3/y/YbvwDopefBHx//FtGBUKpH/+wFmtVojFYsSjUXQaTcgLBsFRKslegc0oRyIRyGQy8sEsLi7GiRMncOnSJezs7OR8z52dHWxsbOTMvACZAkQgEGDfvn1Eq2aCZMw7mdGMl5eXSeF794asvLw8J3lkC5s4HA6sr69TF1ggEKCwsBBbW1vkZZwddXV1JCj2xhtvQCqVoqysDAcOHMDq6iqpdCcSCaIxs/PBgnW6ORwOLBYL0uk0qVDq9XokEgncunULgUCAbMpSqRQcDgei0SjOnj2LRCKBq1evIpVK4dSpUzhw4AB1FgwGA1lsnD17luamsiMSiZBVyb59+7C1tQW9Xg+lUonu7m4SI2MId3l5Ofh8Pqkk7r6nORwOFAoFeS0ODw/DbrfD6/WSABiXy4XNZiM7gydVLD7N80MSiYRAjnvRt1Uq1T0FNZ5kPE7B/ChJ9LXXXsPOzg5+//d/n/xM33nnHRIH2drayrl2/+k//SfEYjG8+uqrOe/zta99DX/wB38AHo+H6elp/OM//iMVG6dOncIf/uEfPjWo/v9MwbxrNzc30djYuKewF4fDIXvHxw1Gja6srERdXV3OvfMkQXjm56vRaNDQ0EAAbjYAr1arYTQasby8jK6urvsqH29tbSGVSuGZZ55Bfn4+zeKGQiHKQcFgkEQys21+XnrpJQIbWcHHxoPcbjfNGB47dgzLy8vQ6/WIRCKUV9l4z9LSEtbX1xEOh3H69GnIZDICr7PFeRjozIBAkUiEdDqNzs5OCIVC6kwza0C73Q6bzQY+n48XXngB6+vrdM4kEgkSiQTsdjtcLhd8Ph/RhFkwgCF7jZmfn8ehQ4cgFAqxvb2NnZ0dzM/Po7i4GEajkTyZWYjFYvT09NA90dzcTGCtzWYjWi0LpnItEonA5/Mhk8loT8TsHtPpNK5evUqbeDZaxuwpmYo0i+y5beBDCjFT8wZAlpcAiL3Q2NhICtx8Ph8XLlygEb2RkRGMjo6it7cX3d3dWF9fRywWowYRkCmKmQ1Udhc2lUqRjoler4fP5yP1+EOHDpFfNBOv4/F4VPSvr6/vqVORXSxubm7i1q1b8Hq9OWAVs29SKpVPNDc/rdogPB4PNTU196VvP4z69pOIR9UrkUqlD32Mn5Zc/9QUzABIJGg3BXt3PInkFg6HMTk5iVQqhb6+vj03dE8CdY7H45iZmYHP5yMAgEnrM2Vm9hkLCwvU7dRqtfcUIPF4PCS0IZfLSXSiuLgYvb299N38Xi9SoSB48TgaL17C/HNnYXY4YA2FoPF4EPrG3+BQTzfMMhmqjCbIfu//Q5+RDoeR+NxrEAcCsPzar8I80I+Ojg4UFxdjdHQULpcL6tV13PjVX4G/uAj9w7exYLPBPT6Gvs9/DunKCnQUqDHn9yEej0MkFOLZ3/8DIB6H02jC5d79iMfjZGhfWFiIAwcO4MaNG/RwsAevsrISOzs7KC4uJvXMysrKHAsjHo9HiWJ5eRnhcBi9vb0YGhqC3+/H4uIitFotCgsLaZNht9tx4sQJJJNJRCIRWK1W8Pl8EggAMqqNJpMJDQ0N6O7uhtfrRUNDA6l6FhcXIxAI0LVj781mqLu7u1FfX4+SkhLqKAcCAdjtdrz88stQKpWUdEpLSxGJROj+5vF4kMlk4PF4eP/998HhcMj6g6HbFosF1dXVsFgstNG4fv06ioqKUFBQgIWFBYTDYUQiESQSiZzkq9PpUFRURJsHi8VCNiG3b9+G3W5HV1cXFW83b96E3W5Hfn4+zp49S4DC8vIyxsbGoFQqc+bf5HI5pFIpzTZnL6R2ux2zs7OorKykc826AlKpFM8++ywJpPj9foyNjYHH4+WoT95vo3mveFo6zLtjd2K/F337YdS3HzfYPfkoM8y7FTAfNL7yla/clZaVLRwIIIciuldIJBLq1HwWn1xwOJy7UrD3isfN99naJO3t7XuK0DyJPUU6ncb6+jrW19dzAIDz588jHA4jGo3SOmuz2Sh/KxSKnFGovWJwcBDRaBTBYBBdXV3E/Onv74fFYoHFYiHmEAMXOBwOEokElpaW0NHRgfHxcYjFYupKFhYW5hQ1g4ODMJlM1C1samqCWq2Gw+Gg0RhWcN++fZscJKqrq1FbW4tUKkUiXFwuF0VFRbDZbHjvvfegUqmws7NDnc5UKoUjR45gY2Mjx/UgnU6jrKwMs7OzEIvFZJXV3t5O54vFwYMHIZfLYTKZSHzT6/XCarXCbrdjeXkZbW1tOXO+FRUVqKioQEFBASwWC5LJJPlIc7lcLC4uYnJyEkqlEgcOHIDBYIBer0cgEIDBYIBEIoFarSYrJpbrWbFcUVGBrq4ucLlc/OAHP0AikUAoFILdbodGo8GxY8fw4x//GNFoFDKZDGKxGNFolLr2rCO8vr6OpaUlKBQK7N+/n5gCNpuNREZZV3lwcBB6vR5SqZTOkdlsRktLC3XgbTYbamtrodfrsba2hqKiIqyvr6OqqgpcLhfb29uYmppCaWkpeTEvLi5iamoKHA4HL774ItFl3W43rl27RmAWC4lEAoVCAYvFQvabLMLhMEZGRiCVSun8ZBd/3d3d4HK5BO4zqy5WLKrV6j0B94eJT4qSfa/YTXt+UPVtZlf5oFaVj3psHxebDPh05PqnpmB2Op0YGxvbk4K9Ox4Xcd7Z2cH09DQ0Gg0aGxvvelM8bhL1+/2YmJiAVColtBPIJAbmRZyNOms0GvL+zS7gHQ4Hrl69CqVSiWeffRY8Hg9yuRxKpRJ+v59orGfPnqVu0/6mJnhfegUxoxHp//xN5P3/vokSfwDzvszCHovFMPr9HyAWCkL/B1+H6rvfhvPf/GuUtbZmEkwsBqRSSCcyRZ/P4cCBAwcyIiNra5CtG1Cyto783/gifD+n/27v2OEsy9C2xpaWEMnLg5oDKORyON1uhMNhcOtqkVpYRKBxHxWUDocDzzzzDJmgB4NBmu+22Wx49913cf78eTQ2NuInP/kJAoEA8vLyUFlZSbZMAHD27FmoVCpMTU1R4VhQUIADBw6QjyGzuGAgBVOFBDIWSWyWeGpqCjU1NQiHw/T+q6ur+NznPkfXpby8HAaDAXa7fc/CjYlTud1uWCwWxGIxKJVKSq6s4GNINpDxGz527Bi8Xi98Ph8VSZOTkzRrZTabc5gPsVgMw8PDCAaDlFgZw4Ah+OFwGB988AFqa2vR0NBAStherxd8Ph/FxcU0K/bcc88hLy+PEG+bzUYFM3suE4lEju0Jo417vV4cOHCABGYaGhrQ3NwMj8eDhYWFnOd6ZmYGdrsdOzs7VDA3NDSgtLQUUqkUfD4/h/WRSqXg9Xqp0zo/P4+8vDwqFh8WkWaqmU9bEr0XEv4g6tsKhYI2GU+Svs0S6MO+36N2mD+LX8yIx+MYHByEWq2+g4K9VzxOHg6FQpicnKSu2N3YGI+b6+PxOKanpxEIBHDgwIEcFwlGw2Z6JUAm74jFYsRisRz6dSwWw6VLlxCNRnHixAl6n8rKSiwvL0MikWBpaQn9/f1U7LK1mnWkzp49C6vViomJCbIAGh0dJXZUS0sLJBIJFYls086+fygUwv79+1FRUQG/34+5uTmIxWLyFo7H4zQKBWRGoNia1dDQALfbTWNiAKhYZudJoVCQFaLf70deXh7y8/OxuLiIn/3sZ3jllVfwy7/8y7h9+zYdMxPUYo4WHR0dqK+vh9VqJRFQgUCAvr4+XLp0CaFQCAUFBXj33XdzOt6jo6OIx+PYt28f9Ho9FhcXsbq6ioqKCkilUrKn9Hg8kMvlpCIul8uJapw9b8yCFY88Hg+rq6tQq9XQaDQkHMtcIBh9HsioYff29iIajRJQLRAIYDQacfPmTQCZfDo0NAQ+n08Cp7Ozs7BarZBIJKR7EwwGUVJSAp1OB4fDgeXlZdhsNvT29sJms6GlpYUAl9LSUjqviUSC3E2ATK5nhWV2DvL5fPTssOvL7r36+nqkUil0dHSAx+OhvLwcFosl5/UGg4H2UZWVlSgqKoJarcbzzz8P4EMldsYoTafT5LThcDiwtrYGoVCYA5Y/LDD8NHaY73VM91LfNpvNWFxc/Ejp249SMLMZ5l/UeGoK5oKCgvsizSyYTP3DPgDZFLCmpiaipNwtHieJMmsqhr7ebZOZ3cXWarX4whe+AD6fn/O9mIJjKBSCz+eDSqWCQCDAwMAAxsbGUFBQgLa2tpybO7m2juT6OngAUkNDEP32b6EwHEbv+joES8tIb29jUVMMaIrBKSrC2s+LJalUipK/+VvE3r4Awf/738Lwe78HmdGImt/8f0L88+R948YNRPOVyNcUQ7+xiVZ/ABY+H7rODojeeBNeTTHiVVWI/FzQpOXdd3GjowMxAMP/6l9CkE6js68P+TduwO/3o6WlhQCE2dlZKqLYhoAlBS6XC61Wi6WlJYhEIty8eZMW4eLiYqJwNDQ0UOF469YtCIVCnDt3DpubmzlIFevesgJ2bW2NkmsymcT169fJZiMcDkOhUBBlLRaL4fr16/ReLCGFQiHk5+fD7Xajra0NQ0NDRDHbfS/V19fD7/dTIczukXQ6DaVSiby8PLJYEolEKC0tpXngyspK5OXlwe1204wWkKH1m81m8smUSqU4efIkeW2vrKzkyO1PT0/T/Ac7x+z+6+vrI1/M73//+6ioqEB/fz+uXbsGl8uFK1eu4Ny5cwCQg3SyjQsLoVCI4uLiOwpmxhqoqqoixdSmpqa7Miu4XC6patfW1iIWixH6yhBphrwWFBTcV0n7o7KZeNx4GCrUvdS32QhA9jl5HPr2owovPQ7q/Fn84oVAIMD+/fsfWJPgUQFypntRVlZGOeFuwfLFo3Sh2ByiXC6/JzMuuyiVSCR49dVXSW2aBZt3BoDt7W00NzcDADo7OxGPx5FOp9Hb23vHc8wAYofDQeChSCSCy+VCQUEBiThyOBzMzc1R96qsrAyDg4MoLS2FWq1GLBbD/v37aV55dHSUaMPb29uor6/H2toadDoddZM1Gg2NmGWfY9vPLSSbmppgNBqxvr6O4uJioj47HA6icjObS9Yh53K5VNiJxWLMz89jfn4eQKYjzwrdI0eO0MwiUwc/evQoeDwerl27lsMQLCkpoVzndrtz5p/n5uawubmJkpISbG9vQyKRYGVlBS0tLRAIBLh8+TIB/CqViijbjY2N2NzcRF1dHYnUsq559qgYU6Bm1wnI7LWYlkhVVRVMJhOsViuEQiFqa2vJ/quqqgqpVAp2uz1H6JW5WgSDQeo89/f342c/+xmSySRcLheUSiWB0YuLizTSw46P3XsdHR2Ym5uD1+vFD37wA8hkMjz77LPw+/1YXV3F1atX8fzzz0Mmk+Xk1VgsRmJyLIqLi2mEikVpaSkWFhYgFouRTqcxMjKC6urqu9oLcjgcorLrdDokk0l4PB64XC6sr69jbm6OgOGCggIoFIr7PrdPY75/mBrmQdS3mdaJWq1+bPr2ozpi/CLn+qemYGZWNA8Sj6KcGY1GMTU1hWg0+sCF+aMUzMlkkvzoOjs77+s3yhI1i706lXq9Hna7nTpL6XQaGxsbmJmZoQeGdcpD//d/QmJqGtLf/W1I/sWXYR2fgPLFFxCLxfD6668jFouh5c23ULi5Cf7/9v9COpWC9ugRbO7sUMERey8j7LXz5lswffn/AV5jAyo4HHAHB5H2eFGsVmPb6US+2YxURQWkP3kdji/+Gq4vLgL6Omg0Gpw4ehSmzU2U6XQI/7f/Tt/F/vMkFfh5Mbp//37Y7XZCdLOp2GxhZmrYTLxCo9HAZrPlJDzmB2kymZBKpXLo2rFYDF6v9w7Z+mQyCbPZDLFYDB6PR8U36zrabDbYbDY8//zzMBgMmJ2dpSSUPVsvEAhQX18Pp9NJc+qsyC0sLITdbodCoaBivLS0FGKxGCqVinwUdTodjEYjrl27hgMHDqCmpgZGo5FoV0DGGzK7ww1kEv8777yTcx6Y4AeXy8XNmzfR0NCAoqIiQvkXFxfR0NCAeDxOm6GCggJ0dXVBJBIRQlhZWQmz2Uye1hsbG9i/fz/NgCSTSezs7GB5eZl+xufzYbVaczosLLI3o+l0GvF4HNXV1di3bx8uXLhAP38QxUMg86yUlJSgpKQE6XSavE7tdjtWVlYgFotzZn13I9JPgwjIXrF7E/0wkU3fTqfThEhbrVYsLy/f95zcKx4FcQYyHatfZNT5s3j4UCgUd2hP3C0eNg+nUiksLy9je3sbra2t97UmYZ+RTqcfumA2Go1YWFigGcT7MeOycz3rSGYHG7eJRCLkesHYdzabDalUCnV1ddBqtSRi1dDQgIMHD2Jqaopo4O+9917OrC8rrGpqamh2Wa1WU85jDKhYLEYdZFbwsiJLoVAQFXl5eRkcDgdCoZDylUKhyLHmYpRtj8dDWiQ2mw12ux0FBQU55yobcGXAQDAYRGVlJTY3N6lYBjJ7OdalvXbtGqqqqnJ+b7FYyEoxO9j5YMrMLEQiEex2O+x2O3p7e6HX6/Hee+9hcXGRLKGyHSs6OzshkUiwsbEBjUaD4uLinO8iFAopv2k0GnC5XDQ1NeHy5cvw+XwoKipCOBzGzMwMPB4PBgYGEI1GSfeDHdMrr7ySc/zpdBo/+tGP6N/JZJKAE7FYTMrv1dXVxBabnZ3F0aNHweFw6Pvz+XwS7mT7U5VKBa1WSyCrz+fDzs5OTsc3EAjQeRYKhVSwJRKJPXNr9jmJRCIoKSnBvn37MDIyAo/HA4vFkqPWfa/g8XhQq9VQq9U0Y78bGM7uPu9FVX4a8/3jdL3vRd/e3NykBsO9zsm94lHy/S96rn9qCuaHCXYRsy2T7hVsNpoVBQ+6SXxYlewHpX9lx4NsBpRKJZ577jkAme88OztLnr9utxuxWAzRaBQCpwuhv/w/keJwsKWvRcEX/xksA/3IKyhA3O8nGm9EoYDM68PLZeXw/at/BX4shue+8r8iPj0DRUkpbP/7v0HsrQuI/C9fgteZKUrXb99G8Vf+NyQFAvT9+6+hq6kJy1Yr0NmJ1E9+knO8NpsNqQsXkP9bv4NYTw/wH/4Iups3IauuxrbLBa/Xi8LCQvT29uIHP/gBotEopqenIRAIcP78eZjNZlRVVVFBzBbe2dlZSgRAZsFgc7HZ4lihUAgqlQoKhQKBQACpVAo3btzA4cOH4XK57hByi8VilFxFIhHa29uJ+gVkZpgZAs7hcPDee++hpqYG9fX1WF9fJwSadQPm5+dplqi3txcvvPACJBIJPB4PlpeXYTab0dHRQQrj7BqzjUkoFCIv3mykmt336XQaExMT2NjYgFgsRmdnJ4xGI/x+P8LhMJqampBIJLC4uIhQKISdnR0cOXIEfr8fkUiE1MiZmAkAQi6Z8Mf6+joVvuwZq6+vh0AgQFtbG6LRKFwuF9HZAZDn9NjYGMrKyu5AGrM3yH6/n2xSspHyR7WOYv7jjKqfTCYJTFpbW0M4HL5DafppRJyBJ0cd43A4d6Vvs3PyMCj9oxbMv+io82fx8LG7A3eveBiRz0gkgsnJSSQSCRw6dOiBN28PC8Ink0nMz89jZ2eHrKnuF7vB8bsdB5shZWKhq6urKCsrIwVlZkk0PDyMQCBA9lgNDQ0AMuvHbgXojo4OjIyMYG1tDdXV1TSepNPpsLOzA41Gg83NTaTTaczPz9O+orq6Gi+88AJGR0ehUCjIg5gdXzQahdlsxtjYGLhcLk6cOAG73Q4+nw8+n4/19XVS7h4dHSXdDSCjFN7c3IxIJJJDS2cuItn2UECGFp1dLAOZ4prD4aCwsBAejweJRALLy8vo7e3NsWrMPr/ZP2tpaSF6MpDZY+j1egKdWee5p6cHt2/fBp/P//+z997hbaXXmfiL3hsBNrCAvXdSLCqjUZel0RSXuGTXXu/GdrJx1olT1knsOGtnk9iJHSfeJE7Z5Bev4zou46mSRppRpShWib2BBEmQBEH03n9/QN8ZXFLSiJLGIztznsfPWCQB3Htx73e+8573vC9ee+01AnUdDgcuXLiAVCqFwsJCPPPMMyQWu7CwgNnZWRiNRmg0Gsq1IpGIQOhQKEQgRSbFOnOdXVpawvDwMFKpFBoaGmCz2eD3++H1epGVlQWTyYTJyUkEAgE4HA7U1dUR0MCsphgIAqSLa5lMRg0Ju92O2dlZKJVKKBQK+j7y8vJIidxiseD8+fN0TFVVVZiZmcHi4iIMBsM2VeutBfO1a9cQDofpmN1uN4l63k9sddpgwDDT9ZDL5duoyo9ivr8fYa3bxZvRt7dqneh0urt+LmPb3A8l+xc51z8yBfNObmQ2X/FmSTRThKO6uhpFRUU7+pydiH6xuej8/Pw3pX9lxr0kURZ+vx8jIyNkicHj8SCRSKBWq9OdZ7kcgsZGLKgUmMjOBs6ehclkQnJsDKFf/w101tUi9ru/g7KcXEg++UmABwhvFY/J734P/M1NuCYnYf2NX0eVSgWxYxOrubkIBYPI0Wpx/lO/gbhEgt3BIAav9SGSkwPhxYuwf/xjKBIK4Q0E4PF40l6Q514DkknEr1/Hy729SAIQrawgOzsbzc3NKCkpIdpNpkgWW+TtdjuJmNXV1RFalhlZWVmw2+3brp/H40FJSQn27NlDHoxs/okVy0xIq6ioCBaLBX6/nxIsS4yMBsjmZo8dO0aiXYuLizCZTDQjFgwGcfPmTchkMk5BbrFYiBKVlZWF5eVlxONxzM7OoqysDAcPHkQwGIRcLkdJSQnkcjmmp6dplkqr1cLr9ZJXN5BOsizJRyIRRKNRdHZ24sUXX6TfNzQ0YGZmhpKE1WqFWCym2bJnn30W8XicrKXMZjNsNhueeOIJbG5ucgCDTEsnn8+Hs2fPbrvmMpkMubm5MJvNNG+1NTKTqEwmI3Xy3NxcKsLfjEZ9ryEQCDiiNluVptm9xzZ9j5JK8sNKolvjQenb93NcrFP0i5xE34m3Nu6Vkr25uYkbN25QztjJvcry9b3YVwWDQQwPD0MgEHCsqd4sdtIpzwTGd+3aBY1GA7FYjHA4TMVJSUkJxsbGEA6HcfXqVfJAZjofZWVlKCwsBJ/PR2FhIRWgzF/ZZrPBYDDQe9fV1WFhYQHV1dVE4Xa5XHj55ZcRi8Vgt9vJT5rZTLJzYuv9pUuXaMSpoKAATU1NNC62ldW3traGxcVFGq3JyspCYWEh9Ho9fD4f53rxeDyIRKJtQEAsFsPm5iYee+wxXLhwgYp5JijHQqfTkTgqm4eNxWIYGxsjoS323U5MTODkyZM4e/YsAoEAMZeYWjiQpqrzeDy43W4CflZWVrB37146VrfbjXA4DLPZjLa2Nhw6dAjr6+vQ6/UEHDidTuoaC4VCAiSi0Sjlyxs3bnBYXsePH8dPfvITAOl9Z21tLRYXF+nYWGdfLBZDqVTi9OnTCIfD4PF4REt//vnncfz4cahUKpw7d47OoaOjg+6vVCqF06dPE0DDgsfjwWg0wmw20/5na2wtmPPy8rC4uIi8vDy0tLSgvr7+oXUitwLDmVTlqakpxGIxaDQaEnb9WSpNv1m8VXPVd6Nvz8zMcOjbt7OqfBBHjIdt//koxSNTMO803gx1jkajGB0dhd/vv6M91ZvFvSS4VCqFubk5LC4uor6+HkajcUefca8FM5vHKioqQmVlJT1kLS0t9Dc8kQjan/wIutlZoLcXfD4/fcPfuAlEItBMTmFuZQUj166h+vkXofraVyH9yIchqKhEeHkJ8X/+v/Dt3YPaa9cRv3QJk7EoYg0NaHjxJeD3P4P4rQ20s7AIkVuL5LJUAvctepPqVrET2diA6OO/giAvBVXHLiCVPr9YLEZofCKRQG9vL0QiER5//HHYbDaIRCK6FqwbBqRRXKVSiXA4jGPHjmFsbAyrq6vIy8sjmnUm1RdIJ8zp6WlKmmq1mtBbIF1oxuNxjI+Po62tDQKBAGq1GufOnQOQRp5ZB5RZO2Sq7iWTSaJ8s26Jy+WCy+WiAp+pWq6srBBVrrGxEWazmbrRMpkMdrsdfX19SKVSyMvL4yR6r9cLpVIJr9cLqVRKM805OTlEsWbd1YaGBszNzdEsl0ajQVlZGVlBXLp0iRB2luSi0SgtiswjM3POisfjEXgRDAZx4cIF+o4MBgO0Wi2SySRWVlao4x0OhzEwMICjR4/S+7Dvhd23jE2QuUF9WMXy7eJ2StNWqxVOpxMvvfQS0erZBvLt8j4EfnbiJFvp28wP+0707QeZYf5FTqLvxFsbb5aHM3Pwneyp3iwYm+fN8v3GxgZu3ryJgoICVFdX7+h5uNdcvxUYZ2NaVVVVnL9rb29HZWUlnnvuORrjyFTi9vv9GBoagt/vR0NDAxoaGhCNRqHX63Hx4kWIxWIUFhZiZGSEZmej0ShsNhs1CyQSCRXA8Xgc8/PzAEA090QiAaVSibKyMgiFQo5NUk5ODhobG8Hj8TA5OYmVlRV0d3fTPGpRURFmZmYAvGFFxQrnUCiEffv2wePxYHh4GCaTiRhYQDp/sALRZrPh3LlzdJxCoRBarZb2BmKxmHJzcXExWltbUVBQgDNnziAajaKwsBBzc3OIx+Pg8XiQyWR48cUX6f0BkLAYC1ZEssKU0cgHBwep+8w0SpivcyqVQjwex/Xr1+FyuThe1ez6KhQKOBwOKBQKWCwWeDwe5ObmIhgM0nfMxpYYpfull16CVqtFXV0dioqKoNPpcP36dWLdsf9m+mezmWifz8dherhcLiQSCfB4PFy9epXOUy6XU56w2WwYGBhAfn4+qWuXl5dzxgm3ske6u7tp5AvAWwqgbqUqM+9nl8uFvr4+xONxlJSUID8/H1lZWQ/F3/1+42eV6zOvCcD1w74dfZvtp3d6bMFgkPQPfhHjkSqYd0LTulsSdbvdGBkZgVqtvqsIx4N8BpAuNphf8L3ORd/uMzIpRlsjlUphdnYWFovlnuaxeDweyisrodZqIZVKMTU1hfjxY1A6HFjOz8NCIAA0NiJ7cAiCv/wKkguLSOn1uPHFL6D8Nz6J4q4upGw2uM+fx+SxdMEzv2c3em7eRJPTiYDbjZp4AuG8XDhWV1HR1YUbY2PQ6XRoMJvxmkyGoEiEM2NjcLW2wlRYgMJbfsEdHR1EXbPb7ZzkGwqF4PP50NHRQf7GmdflhRdeAACiSolEIs6M1u3uG5YomNdvJlKaiYrevHkT8XgcOTk5RAV3uVxQq9Vkh7QV2WZRW1uL0tJSsoUCwLEKA9IFv0qlwsbGBnJyclBYWIjNzU3E43G8/vrrpG6dqc6p1+shEolQVFQEg8EAr9eLCxcukKK2Xq+HRqMhmndjYyMaGxs5fph+vx+lpaWQSCSYm5sjint5eTlWVlagUqmQm5uLUCgEhUKBSCTCoViz57Gvrw9qtRpOp5NzDfPy8tDY2IiBgQFEo1Gsra3BYDAgHA5vexaGh4dht9sxNzcHn8+HgoICFBUVvS0zRUxpOpFIwGq1IhwOIxwOw+FwwG63IxaLQavVQq/Xk3jYzxKRvt/C9EFiqx92PB4nkRVG32adNI/HA5VKdc/H+I5K9jvxIHE3cJyN8zxIDmZxN0ZZZh5uaGi4r03hvRTMdwLG7xRqtRpPPvkkFcper5d0QTILTLPZTF3KoqIiGI1GFBUVIS8vD5OTkzS/zI6hpKQEs7OzZOk0OTmJwsJCWh/Ly8tJQOvy5cuIRqOQy+WorKxEMBhESUkJmpqa6PMHBgZILbqgoAButxsVFRUoKiqC3W7njFRlCnPy+Xzw+XxEIhG6dnw+n1PMAm/YOgFpga3Mc8/8W3ZdpqenUVZWhtXVVTgcDhQUFFDhwKjLAHdPWlhYiLq6Oly9epX2A0tLS5yi1263IxqNYmlpCQqFAgcPHsT6+jr8fj+mpqbIehJI31MymQxarZb+W1FRgdraWkxNTaG3t5eOoaqqCtPT06T3whw6mGK32+1GfX09srKyEAgEqINdWFiISCRCHsmsMRCJRDAwMLDtfpqfn4dcLkdxcTGxjoD0vqujowNWq5X2IIzxxzRgWCwvL1OeZ3Zn9fX1bwuLi8fjkVDZ1NQU7V82NzcRjUYxPj4OlUpFuV6tVv9Mc+/bkesBbKNvM7Cc0bdZrnc6nTuyqmQ+zL+o8UgVzDuJ29G0UqkUlpaWMDMzg4qKCqL9PshnvFlRrtFosHv37vv2Pr1bEmUFeTgcRk9Pzz2jcjwej5AkPp+PpEwG5Rf+F4o2NzFx+jRE0Sj0Xd0Q+n2ILizCrdPAuWqFJxqF+GMfh+ZDH4SkpgYFajXWvF4U6bIg/+hHULRvP5BIYCkvF4tCASAWQySR4D1qDVKRKOI9u8EbGkRKIEDA5QJkMiwtLaG6upp8gpPJJAmaMCRZJBKRrxrrpmaGTCajBMW+80zBqszIzc1FWVkZJRsgfV8wMZLM75RZIgwODgJIL15sjsvv9xNiyj6Tz+cThZsd6+TkJDweDxoaGmi+OhqNQiwWw2AwQKFQoKqqioNYM7q3yWSCTCZDIBCA0WiEXC4nxF2pVMLtdqO8vJw8DTPvRYVCgezsbEJ3BwcHsbq6ioqKCiqaGQVJIpHQHJVAIEBzczM6Ozs51y0Wi+FHP/oR/VssFkOj0VAXm9F4MsVx7HY7gsEgUXfZ7H4kEuEoXa+vrxOFfGpqCtFoFBaLBb/0S7+EaDRKs8s/a5pUMpmETCaDWCwGj8dDU1MT5HI5ddqZiJtIJCLlSaZQ/1Yf19stTsJsUDIp7XNzc/B6vTSffy/q2+9Qst+J28VOR6Nul4eZNolOp0Nra+sD+4/f6XNYUb7TPHyv7w/sHBjPDMaeCwaDSKVSqK+vR1VVFV544QX4/X6aR2XPrcPhQDAYhNVqRW1tLVQqFZRKJSwWC1QqFXp6eohdxUBEIA1A7927F3a7HUajkfJYJp3ZarVi3759WFxcxNzcHMLhMIqLi1FZWQmz2YzS0lJcu3YNwBsODZnXhAl6smB7o7W1NSpe2c8UCgV27dpFHtUs1tfXOXsqpgZdVlaG9fV1hMNhxONxLC8vIxAIAHhDbDXzWNgcMPuslZUV2O127N69G6+9lhZGZeM8crkcGo0GVVVVuHbtGompMYBfIpEQQyBTJ4VZTdpsNuj1evD5fLIbYyGRSFBYWIjFxUWoVCq43W5cunQJRUVFnHtqfX0dxcXFkMvlKCoqgsPhIMHPzGhsbMRrr71GwmcCgYDAd8aKCwQCkEgkJLiaSCRgs9k4wGdhYSEaGhogl8upYGZ+y0yAlUVOTg70ej1cLteOCrCHFUzwS6fTwe12o6amhsAE1mkdHR1FMpmETqejAvpBXCXuJR6FXJ9pVcno22tra5ifn78n+nZm/KLn+p/rgjlzcWMzPy6XCx0dHfctHpQZbE56q7rv8vIypqenH0pRfqeCmVGRNBoNenp6HkpBbjAY8IEPfAA8Hg/JZBI3BwaQqq6GsKMdoZkZICcbrtISSP7pnwEAnfl5SBw6iNDwy4g3NkDyV19F9PJlqJ56CrilligYn4Dvd34XACD7xt+h5/HHEX3+BeD559H/4f+MFNJJ5dKlS6ReCqQfrI6ODjidTqJmxePx21JhWbG8tWisra0l1U4WNpsNRUVFKC8vpw62yWSCRqPBzMwMIdkymYwQ7+7ubszOzm4rwDOTFkvWrChVKpWkGJmpJA2kNzByuRyrq6tQq9Uk6sGCncPy8jKefvppQp3VajUWFhYgk8kIvTebzdjc3MTg4CAhtUzYis/no6qqCrFYDM8++yyA9KalsLCQAAJW2AoEApw4cQJutxuhUIjQ3o2NDVy+fBlKpRJ79+7FyMgIlEolmpub4XA4kEwmt9G02bW12WyYmZmhe5MV0kzMg81aZybO/Px8WCwWGAwGJBIJvPjii4hEImhpaUFtbe227/6tjFQqBYlEgmeeeQbAG/Qj5oPO7Cw8Hg8cDgcWFhYIkc70OX7YCe9RSKJbg82cC4VC1NTUwOfzwel00j1wJ/XtcDiMRCJxX52/v/3bv8Vf/MVfYH19Hc3Nzfj617++DejJjB/84Af43Oc+h8XFRVRWVuJLX/oSiSUC6e/785//PP7pn/4Jbrcbe/bswd///d9vE6x5Jx6t2MrCYmJY8/PzqKqqQnFx8UMB225X0DKroIdRlN8p198vMH639xeJRHj66adpLTGbzdDr9TCZTBwbQiYW6Xa7cfz4cVy7dg2Li4toa2vD2NgYCgsLicbK4/HwyiuvIJlMwuPx4PHHH6e9EAufz0cjUyzXz87O4tChQ2nLyrw8lJaWYmVlBbm5uZzcAIBTLLNiE0gXXIyFxiIQCGBychKdnZ1k8ajValFdXY2JiQn6W7FYTMV9V1cXxsfHYbVaOfn9drl+aWmJGFpsLjgSieDq1auca15ZWYmxsTF4PB5kZWVxzokdfyQSQV5eHhQKBVwuFzQaDRQKBY2ehcNhjI+Pk3d0KpVCVVUVFAoFSkpKIJVKSTX79OnTCAQCmJubQ0dHB/r6+ui4fT4f/H4/9uzZg3A4TJRrJox67tw5ug6MIt7e3o5oNIr5+Xmsra2RYjiQZrIx5sLQ0BB27dpF5xaPxwkYTyaTmJ6ehs1mo3NmBbJIJIJKpUJvby+Wl5eRm5uLgwcP3v4mfouCXYODBw9y1OmZXWd+fj41ShwOx7a8ptfr35JC/1HM9SKRiHQNdu/ejWAwSPPPb6a+fb8F889Lrn+kCub7Vc70+XwYHh6GTCbDnj17bmvNdD+RqUrM4/EQj8cxMTEBh8OB9vb2B1L5y/yMrUmaWVWUl5ejtLT0gQvyzGsqEAjg9/sxPDwMqVSK5k98nOZZeMsrKPvcZxH/1r8j9voFhE+8C6dtNqTedQxtP/gBbhw9gmR9HU6UleFEbi6mh4ehUKkAHg9IpXDZ68X6lSvIMuajKQVoAkF4lArk5uaSZyM/GkVSLIZAICABrRs3bkCpVEKtVqOmpgYLCwucApRF5nnk5ubSjNDy8jLnd2xuGHijm+v3+7Fv3z5cuXKF0NRAIECbgsxiubm5GQsLC5xON3v/WCyG5eVlElxjiZYh1QCwb98+sknyer30PgqFAkVFRfD7/VhZWaE56NHRUQBpahMrrIuLi+FwOFBSUkLdd6baCaSLa0a1LiwsREVFBdbW1lBeXk4LltPpxLVr12g+rKuri5Lr4cOHkZ2djYmJCaK/ezwe8lVmyuI+n2/bc+l0OmmGzGw2Y9++fWQLl7lYjo6OEmjBrldnZyfa29tp7otdv63ft9lshtfrRV1d3UN7nrcGS1Z3S1gCgYASAwBCpB0OB6xWK1Kp1EPzOd56XI9aMNGvTPp2SUnJbenbKpUKzz33HHl07pSS/b3vfQ+f/vSn8Y1vfANdXV342te+hmPHjmF6eprYM5lx9epVfPCDH8Sf/dmf4YknnsC3v/1tPP300xgaGkJDQwMA4Mtf/jL+5m/+Bv/2b/+G0tJSfO5zn8OxY8cwMTGxY8uNd+JnF5lsslgshps3b8Ln82HXrl139Gy/389huTiTrVZZWUk6EA8StyuYHxYwfrv3Z+v2yMgIPB4P9u3bB7VajUAggOXlZVRWVkIul6O/vx+VlZXkNexyuWC1WuH1epGTk4NTp05hfHwcUqkUm5ubCIfD8Pv9ePXVVyESiSCRSMj2MT8/HzKZjDMuJZVKcf78eXg8Hty4cQMajQZKpZIstDLB2MxghZdcLkdzczM8Hg8GBwc5+yWv18uhFmu1WlgsFuzbtw99fX2IRqPIysqCxWLB/Pw8DAYDp6AtKSmBWCym4h54I9eze0AkEnHWh0zwpq6ujor8ZDJJnXkgDSzLZDJinlksFiwvLyMUCmFpaYk0VZjYGrOjZJ/PBNGSySRRsuVyOaqrq3Hjxg26L5ltoN/vp9G1pqYm8uZtbGxEQ0MD1tbWaC8yMjKC48eP07Fev34dVqt1W96JRCIQi8WIRCIErHR3dyMSiZBzCJDes7JzZ4y4hoYGZGdnk5YOy/GZeyUApMJdXl7+UJ/nzMgUsbqTPkmm00ZmXnM4HJidnUU4HH6oPsfsuN5OvZQ7RaYjBqNvZ+q/ZCqSy2Qy9Pb2oqCgAF6v9xc61z9SBfNOgiVRVlyWlpaivLz8odI6M60mQqEQhoeHIRKJ0NPT89A2WJlJLplMYmJiAjab7Z6tKnby/sAboiVFRUWoqqqi69X2Z19CamMDscf3Q/Mv/xcA0p7Gt2Zaffsfo02L02pF8nN/BCWPj+gvvQ+b//LP0EplCK6mE5E/mYT++efwpFyOeDyO8+fPw+VywTQ5hYoXX0Jk716sV1TQMbEkDaTR6EyqfX5+PoqLi6nQA9LdLpvNhkuXLsFkMsFut1PyMRgMJIwBpDfqLEGq1Wo89dRTAIDp6WlMTEygpqaGimu2sLOkvjUEAgFRxpnPYuY5sLBarWhqasL4+Dj4fD51tQUCAWw2G3p6ehAIBOByuUhtNZFI0Hknk0l0dHTg4sWLGBoaQm1tLZaWliCVSmlWKxgM4saNG7DZbJifn8d73vMeAOkkf+XKFWxubiKRSHAK0cxEv7CwgM3NTZSUlJBdidvtJjr50NAQIfTZ2dkoLS2Fx+OhjkRpaSlmZ2cRiUTQ19eHsrIyKoIjkQgSiQRdQ4VCgSNHjqC3t5f8rQcHB2EymfD444/D6XSiIuN+8Pl89H3z+XzOLNyDxPLyMiYnJ1FVVYWSkpL7spnYikiz5MGEsnZi3XCn+HlIoplxO/r20tISxsbG8M//nGarfOQjH8GxY8dw5MgRzkbrTvHVr34VH/vYx/DRj34UAPCNb3wDL774Iv7lX/4Fn/nMZ7b9/V//9V/j+PHj+N3fTbNdvvjFL+Ls2bP4P//n/+Ab3/gGUqkUvva1r+Gzn/0srQHf/OY3kZubi5/85Cf4wAc+cH8X5Z24r9jJc8fAcY/HQwyYTDGshxWMUfZWsNWAN2akGQD/MIFxdvyZuT4QCGB4eHibeFgymUQwGMTY2Bg++MEPoqqqimwIgXR+ZWs/YxdtbGxAq9WipaUFfr8fiUQCq6uriMViOHjwIIqKihCJRDAzM4OhoSESEGPzt0x1O5lMUq5nCt8s9Ho98vLyMDc3R7kqOzsbdrsdr776Kh5//HEoFAoq+mQyGWpqajA8PEyvZ+ByX18fiU7a7XbY7Xbo9XpODlQqlVhcXLxjrmfXKxQKcY4zMzY2NtDa2koeyuzvNBoN1tfXsWvXLmJksY4lwL3/i4uLEY1GMT09jdbWVqhUKk7u9vv9mJubw82bNwEAx48fpzWM+Y0LBAJipQHgKHo7nU6MjIygpKSE9hqpVAoejwcajQYrKyscYHvPnj1wuVzweDywWq2oqKhAIBBAIpHA8PAwqqqqoNfrEQ6HIRQKSZiUx+OBx+Ph8OHDmJ2dhUgkQjgcxoULFwgsX1lZQVFREecaXrlyhewvM4v4Bwmv14v+/n5ihrD94E7Xnds5bbBngs/nc7yf72dGm7EcH7W4U67PpG8zRXK3243vfe97+Id/+Aesrq7ii1/8ImZnZ3HkyBES1L1b/Dzl+kfvm7rH4PP5sFqtiEQiaG1tpZv6YX8G8MYMZmFhIaqqqh5q94cluVAohJGREaRSKY6Hc2JlBdEzZyF+13EIHkBoJFNJlImWpFIpJKxW8I1G8LN0SGxsgJ/RNc/LyyMRp9pDh6BcXkYikYA2mcRL707TWPVOBxyxdJcwPz8fUqkUXV1d1GkUi8VwOp0AgHBPN/RVVUgdOYzLGZ5+mcfKkgKLtbU1EqtiwYpjpVKJ4eFhzibB6/XS36vVao4YSCYtlFGCGaXLZrMhmUzSe2VnZyMQCHCK94qKCtq4AdjGDABAVhNAGjn2er1YXV1FdnY2iWjY7XaOF2RFRQUcDge9r0AgQF9fH50Hm3WKRCJoaGhAKpWCXq/HxsYGbDYbp6sbDAY5Yh1AGuFva2tDcXEx+UEz1c/u7m4cP34cr7zyCiwWCyQSCdrb2wkFFggE2LNnD6RSKRwOB22qkskkiouL4fV60dDQgEgkAovFghs3blC3Pjc3F+Xl5WhpaeEkrPn5eYTDYczMzKC1tZWjuMoU0RkdLxNxjsfjeO211xAKhbB///4dK9/fuHGD/J9LSkporul+43ad1q3WDVqtlhLqvSLSb5cQyJtFIpG4pyJFJpOhuroaP/7xj3Hjxg0cPXoU7e3t+M53voNPfvKT6O7uJgrl7SIajWJwcBC///u/Tz9jHq+Z2gSZ0dvbi09/+tOcnx07dozsVxYWFrC+vo7Dhw/T7zUaDbq6utDb2/tOwfwIB5/PRyAQwPXr1x9acXm7YF2w3t5eSCQS7N69+6EKFbFnOh6PE301ExiPx+OYm5tDVlbWbTsr9/L+LH8xYDxzzxIMBiGRSOicmHYDkC4Oqqursbi4iPb2dgiFQqytraGhoYFsjzweD80fFxQUQKfTob6+ngogiURCuT4Wi2HXrl3Izs7mUJgzY2ueYroRmWsfm5+WSCSYnZ3lsL6i0SgVy2q1msMSy+xyMeBybW2NdENCoRDtI5LJJBXmLPR6PcrKyuh87xTMurS0tBQCgQBmsxkqlYq6zmazmXNcWVlZ5LoBgGyjGGg9PDxMI2hlZWU0v8wKfYFAwGnWTExMcIp5Pp+PmpoaNDQ0kEjbjRs3YLVaEQqF8Mwzz+D06dNwu924ePEiTp06xQHVu7q6UFxcjOLiYvzgBz8AkN7/trS0YHZ2FpWVlZBKpbDb7ZiZmYHD4UA8HidLsNraWuh0Og4o5PP54PP5EA6HqQMIpAt5qVQKrVaLYDC4DZgaHh4mS67S0tK7fg9bY25ujqjlFRUVlLceZN3Y6rTBfI4Z8KVUKjnez/fq5/6o5vp7OS6RSITs7Gz81V/9Fb761a+ivLwcx44dw+DgIL785S9TA+pOzgU/b7n+kSqY7/VmZnMGfD5/Rz6I9xtTU1M7FuK412DzWb29vcjJyUFtbS0HkfH+yseRmJlB5IUXoP3RD3f8/nw+H/F4HENDQwgEAhwlUd9v/y6iP/kJJO9+NzTf/Q7io2MQ7eqg1zqdTiraFhcXycLK7/eDd+MGUgAk5gWguQn8RAKFhYXg8XiYmJhAS0sLFXIHDhzA0tISampqINNoSFiBFY3M0kMikdDinUkDjsViqK+vx9LSEiHfeXl5aGhogFKpJMoTwJ1FYslVKBSitbUVGxsbZNtw8+ZNQmHZLDKQRnvFYjGCweA2Ubnp6WnU1NRwfmYwGCAUCpFKpUhwy+fzcYp8mUyGqqoqRCIRpFIpFBYWYnBwkNDFzBkwdg5WqxU6nY6TXIH0pmJtbQ1TU1N4/PHHibrM0GK5XL6t05Cfnw+TyYRYLAa1Wg2dTofp6WmkUimiIDE7KEYbE4lEKC4uhl6vx5UrV1BZWYmioiLqHKyvr+PJJ5/cdtxMDAVIU+NtNhtisRgKCwsRCAQwNTWF6upqhEKhbTTHvr4+WCwW6PV6nDp1CtFolLPxcblcdF1XVlY4BbPP50M8Hr9rN6isrAxjY2Pki30/Hea7xVaf40zrhsXFRQ69Oysr647F56NKyb4T6ny3YDS2P/iDP8Af/uEfwufzUTfjTsHYEbm5uZyf5+bmclTgM2N9ff22f8+6Luy/d/ubd+LRC8YiC4VC2LVr10MZg7pTxGIxzM/Pw2Qy3ZNC9U6DvV9/fz8JJGaOcNy4cQNjY2Pg8Xh4//vfv+Nina37c3NzWFhY4Nhczs/P4/Lly1AoFHjqqadQUFCwbVPPrJWmp6dx4sQJmEwmACAhxMwQCoVoa2sjVWWmGt7e3g6ZTAaj0UibZJPJRCAyy+uZ4l5bR35Yt5o9lyqVCi0tLRCJRFhbWyOgeis1m0V9fT3RqRnlnO0bhoeHqfhUKpXIzs6GUCjctq5sbGyQ+jP7HIlEgpycHASDQdTX12N0dBRisZhUo1m0tbWRKwZTDWcAdCZVHUgX3Gtra9T9ztxzBINBLC4uYnJyErt37ybXjtXVVcphCoWCY5cpl8tRV1dH3d6ysjLMz8/D5/NBo9FAJBJBq9XC5/MhFovhhz/8IZ0XU952uVxobm5GdnY21tbW4Pf7UVRUhOrqavock8mEwcFB+g5ZnvP5fKivr4fP58PMzAxqampgMBgglUo5Ta2FhQVcu3YNAoGA7CW3zr7OzMwgmUxifn6eUzBHo1G43W4YDIY7PqPsXLRaLVmSsmvyMGKrz3E0GiWwfGJigvYiLNffyWnjFynXA2kW4y//8i+jpaUF8XgcAwMDKCgouOPf/7zl+keqYL6XWFtbw9jYGBQKBbS3rJPeigiHw6Qq2dzcfF+I75tFKpXCxsYGLcAMqU2lUkjZ7eBlZ4N3q8PG075RCKSSSQT+1xeQmJ2D8k//BIKSkjt+RiwWg91uh1arRU9PDyn8piIRRF96Mf03V6+Ar1ZDvGc3gPQN53K5UFpaipycHPj9fhQXF9N7+nw+pADwAVSfO4+SgQGI3/teZJeUECqZvNqLdpEI8t/8FFFYWTAE6dlnnyXVy3379sHtdtM8L6PHAekE1NjYyBH9WF9fx7lz5/DYY49RwcxmjYqKiqgILigoIMqU1+uFxWLZhsgyVBxIf++ZlhRisRgVFRX0fpmiJKxbm5nkbqfczePxMDMzg0QiAZ/Ph6tXrxI9704LOFNmLi4uxsLCAlHNGBLNurHsszc2NmCxWJCVlYXW1laMj49Tgb6wsIDOzk6cPn0aPp8P1dXV6O7uJsXDZDKJpqYmbG5ukh0FS8Iulws+nw8ejwfZ2dkk2rV14zo6Oorp6WmigRUUFGB9fR08Hg9ZWVmYn5+H3+8nVe/u7u5t80rsM5lyOrtXnU4nzGYzTCYTiouLEQqFUJJxz3u9Xrz00ktIpVLYv3//Hb3Q6+rqUFdXR/9+0A7zm8VW6waPxwOn04nl5WVMTEyQeFhWVhY0Gg0dy6OaRO+HKh4MBjk2E2zz+078x4572bgyNgifz6dRh7cimGCR3++H0WjkFAYPMxhArFAo0NDQQM9SOByGSCQiAE0oFG4rZKenp9HY2MjJw7c7D6ZU3dXVBbVaTb9j+SsQCCAWixH47/f7sbi4CJPJhOrqauoissgs4lhOViqVeOyxx/Dcc8/B6/XCarWiqKgInZ2dUCqV28R6WlpaaP1PpVIwmUyor6/nWDGyyMnJwb59+2CxWGhz6/P5cOnSJRw7dgxSqZSKT5lMhvLychoNUiqV6OrqwsrKCoHQW4t9JuAFpJlXW4vd9vZ2jIyMEOVcLBYjFArRuBbrik9MTJC3c2bBz+PxsLy8jGAwiGg0iuvXr9/TWq7RaEgssb+/H8lkkrO5z9RC2djYQCKRIMuv69evIxgMIpFIUDPJarViZmYGGo0G7e3t4PP5tIetqKiAWq0mPZRoNAqfzweVSoW1tTWsra0hOzsbJpMJa2trkEqlHGeItbU1XLt2jfZRWq2W9ja5ubnY3Nykbr3f70dLSwtHCBJ4I9cnEgmOKGQkEsHExAS0Wi1pyWzN2a+88goCgQCqq6vR1tZ22+uZk5NDY2rsdW9lThWLxcjNzUVubi45Q7CG0/z8PMRiMWdUi13PX6RczzyvWZODCer+IsXPTcGcTCYxNTWF1dVVNDU1wev13tW/+EGC2VXo9Xoypn/YEY/HMTo6Sgb2mXMd/s9+DpHvfBeSd78b6n/+R8SHhiDqeKPzm5idQ/j/fQsAEP7u96H4zO/R75IeD3giEXhyOdbX17G+vg6VSoX29nbweDxEz51H4Otfh+TwYSB6y+Yo471DgQDOnD6NFNKL2rve9a5tx84KzCSA9cOHUFlfD+1HPoxgOJzuVIZC0F28iNDEJCRPnISwshIDAwOYmZkBn89HR0cHKioq0NnZSbOqExMTOHbsGGw2GyUEuVyOmpoaNDY2AgCqq6uxsLBAyUkqleLs2bP0/5VKJQKBAPR6Pbq7u+Hz+VBTU0MWSV6vl1MsZ2dno7OzEwsLC7ShYOqQLKLRKGQyGaG7Xq8XGo0GHo8HsViMUyxnFtN79uyBTqeDx+OBUCjE6OgoIpEIotEo5++Y0vXS0hLn2KRSKebn52GxWPD000/DarVSMSoQCJCbm4v8/Hx4PB74fD5MTU0RlauyshLRaJRUoFlXnG0cFhYWMD09DaPRiP3796O3txdLS0u0KWBARUVFBd2nkUgEL7zwAk6ePElK3ZkxNTWFeDwOPp8PpVKJXbt2kTBYIBCAVquFzWYDj8eDUCjExMQEEokE2XVIJBL09PTAarVuo+/09vbC6/VibW0Np06d2nY/snMFcMdZs9vFw+4w3y2YsqROp0N5eTmi0Sih8uPj40gkEvT7TFX+RynuB3X2+/1QKBQ7Oh+DwUDz/plhs9nuyPLJy8u769+z/9psNg54Z7PZ3ingH8GwWq2YmJhASUkJ9Hr9tlGdhxXhcJgKpJycnLfERiaVSpHNEpBen9lztLi4iAsXLkCpVOLJJ5+EwWCAWq3mFCgDAwOIRCIYHh7mFMyJRAKxWAxSqZR8flOpFHp6eiAWi+Hz+XDlyhWo1WoqUKRSKQfAOnv2LLxeL8xmM5588kl0ZOwFAFDhB6TXsOLiYnR1dQFIF6Ner5fEH/V6Perq6mCxWNDb24tkMgmTyYTdu3fj4MGDeP7555FKpWCxWLBnzx6yYkylUhCLxSgoKEBPTw8EAgHy8vKgUqkIIOfxeOjr66Nil9GNk8kkHnvsMSwtLaG8vBwajYajpM1ynlKpRGtrK6RSKV599VWkUqlt6wWQ7gBXVlZSPjMajVhaWqJigEUmyF5bW4vS0lIEg0GIxWKMjY0hFoshHA5vy0fV1dXY3NzkAOtKpZKA6sOHD8NgMHD2IUyhua2tDYuLi4hEImSFWVFRQbZPAoEARqMR2dnZBBj4fD68/vrrEIvFeOqpp7C8vEw0c4VCQdczJycHxcXFWFxcRCKRwMWLF7Fv3z6cOnUKEomEcz+azWY6L7FYjJaWFuTm5iIajcLv90OpVGJ+fh7xeBxKpZLcJZRKJRwOB0KhEHbv3o22tjYolUrOXmJiYoI6i08++eQ2Rl8qlaJ9/6Oa63k8HpRKJZRKJTltMFFMdi3UajWysrJozv9Ri/tlk+3UEePnLdf/XBTMTOCIzffK5fJt86UPIzITW3V1NYqKinDp0qU7eifeb2SqVDc2NnIoxQAQv94PAIj194OvVEL82GPpfw8OITEzA/HJExDu2oXE/DzEx47Q62L9A/B86JfBUyrg/Lu/w6Lfh5ycHFItBIDAX/8NEmNjCC0sQvpfPoLwsz9EyutFIhJBJJFA/NlnIQiHEZdKIc5YkJg1FJ/PR3NzM7RaLXJeeAGl514Db3UNvP/6UQwMDKSFIPh85M2bIaiqgqCoCKlUChMTE1TUXL9+HRUVFaipqYHT6cTs7CzKy8shEolQXV0Nh8MBkUiEJ598kmhpU1NTHOEvlUoFo9FIqH0ymSS67tjYGMRiMQKBANF+W1paUFRURPNUPB4Pdrsdg4ODaG1txezsLEe4ixV7QHrzxhbnTDGOeDxOAh16vZ7Q5/r6etrYKBQKmhkC0psMJpTBPidToVMoFEIkEiE/Px8+nw9KpRI/+tGPiGJtNBrh9/uxurqKzc1NDgUdSG9qmE0VkE6209PTsFgsZOOVqbqd2VFPJpMoKCgg5J51dNicVTweRzwev+3scGNjI+bn59HU1MRhSrzyyivw+XyoqKhATk4OzUMzFHZsbIzmyQYHB1FUVIRYLEaINeu0e73ebR2miYkJTE5OorGxEXv27EE0GuV0nt8s3mrU+W4hFouRl5eHvLw8srNwOp2EzA8PD5MX5FZ0/u2K+5m3uh+bCbFYjPb2dpw7dw5PP/00gPS9ee7cOXzyk5+87Wt6enpw7tw5/OZv/ib97OzZs+jp6QEAlJaWIi8vD+fOnaOk6fV60dfXh1/7tV/b0fG9E29dMF0JtrnJzs6G1+t96DkYSLOBbty4gezsbNTV1WF6evqhfw4DHD0eDzo7O3H9+nXOZ2R24iKRCG3wAoEAlpaWUFxcjKqqKkxOTnI6v9FoFD/5yU8QCoXQ1tYGm82G7OxsOJ1OAvjn5uZoLKatrQ3j4+MQCoUE4kajUcpDW32LGd22s7MThYWFNFpjsVjQ09OD+fl56oBKpVIkEgnaqDL9BnYMzc3N0Ol02LdvHy5duoTCwkIIhUJUVlZibm4OsVgMBw4coNc7nU68+OKLdEw8Ho8DrguFQhLqZPsKi8UCnU4HlUqF7OxsvOtd78K5c+cQjUbJGeTKlSt45plnoNVqORoiAGiumQHhLJhgKHNDCIVC0Gg0VNBmZWWhqamJ9CwGBgboNUqlEgKBgLRJRCIRFZLsPFjHnX03V69epf2FVCpFYWEh5ubmcPny5du6yGR2yMViMTweD55//nnU1tZCo9FgdXUVHo8H8XgcyWSSs9dUKBTIzs5GQUEB7VcOHz6M06dPA3jDonJrVFZWwuPxID8/H62trfTz8fFxzMzMQK1WIy8vD+Xl5cT2CofDWFlZoeO9fv06ysrKwOfzSSQ0EonQSJVMJuOMJNhsNly9ehXZ2dk4ePAgNjY27kk8ksXbmesFAgH0ej1pFYTDYQLL/X4/Zmdn4XK5bmvT9HbF/RTMDHzZSb7/ecv1b/8uLCNuh7RsbGxgdHQUeXl5qKmpoS/xdnZMDxKxWIy89DLtKh7256yvr2NsbIxUqn0+H5LJJCLnziH0D/8I6S//MpRf/nOEv/M9SN/3XnpdctMBzwc+CCQSkK2vQ/u972x77/j4OJBIIOXxwj0+hp4PfCBtQr+2htC/fROi7m5I3/9LCC4uQvLLHwJPIAD8fkQvXsKLzz0HVyiEFj4f+//27xHU61H6L/9M773w4ouw3kJuA4EAqqqqoLEsgwcgatAjkUgQOi9TKqG/OQLerUJ9amoKUqmUUG6hUAi73Q6bzUbX1mw2QyAQwGKx0Lzv1NQU6uvrIRQKOYgukEZOWaHH5/M5hWPm/MP09DQWFhaQTCbR1dVFHsUs8ej1egwMDHCSpEAgQENDA9RqNcbGxrbNPbC/rampIW9mmUyGsrIyOJ1OjrDFwsICFcsajYZEwZjdF+sKAyDrsng8jsXFRZSXl5MXMousrCzweDx4vd7bFssdHR0YGBggRJUVxeFwGH19fWSzJRaL0dDQAB6PR/PLQHqDUFxcDI1GgwsXLsDn82H37t2EmmbS/FgsLi7C5/PhwIEDnO5FKpWi7zwYDILP58Pj8UAsFpPfY3V1Nfx+P4RCIWpra+F2uzEzMwOPxwO32w0ej4cDBw7ctqs9PT2NaDSKmZkZPPHEE9uO683iZ4k63y0y7SyMRiMuXbqEiooKuN1usmliiDTzfn47jvt+k+hObSYA4NOf/jQ+8pGPoKOjA52dnfja176GQCBASpof/vCHUVBQgD/7sz8DAHzqU5/C/v378ZWvfAUnT57Ed7/7XQwMDOAf//EfAaSv8W/+5m/iT/7kT1BZWUlWE0ajkRL1O/Gzi9vdv4FAACMjIxAIBJz53kxbqYcRmT7ONTU1pL1xJ5/k+41MYJypVAsEAvh8PvT29pJoViKRIFFAFufPn4fT6cTc3BxOnTq1jXqaKVo1MzNDjQRGAZVIJCguLsbs7CyNfjD7wN7eXthsNs6YWWYxbrPZiK57+fJlGI1Gys0CgQCxWIy+Gx6Ph+PHj5Mf/cbGBnw+H+daRiIRLCwsUMFns9mwtLSE2dlZVFVVYXNzE8vLy1AoFFCpVPB6vdsK+IGBAcpdmfeC0WikcaeZmRmMjY0Rtb6pqQkDAwO0x9BqtZiamuIUy3w+H/n5+WhpacHo6CiWlpY4nWT22qysLNTU1ODmzZvU6Jifn0dHR8cbzYhAgMBqkUgEhUJBnTB23TKDncf4+DgqKyvh9Xq3+VBnanJsLZbr6+uxuLiIQCBAOYQV8kNDQ5y9a3NzM4mFsny7sbFBri8TExOYmZlBc3Mzdu/ejVAoRHPSmcG6pB0dHdvGFNl1Y/kqFAohGo0iHA5jbm4ORUVFKCsrg8vlQn19PWKxGKxWK8bGxuBwOJBKpdDU1IRTp05BKpVyQOLFxUWEw2EsLy+jra0NtbW1247tbvGo5HogDYQYjUYYjUZcv34dubm5SCaTHJsmBpZrtdq3xTHjfsFxNj6zk/h5yvWPVMGcGclkErOzs1haWuKIV7DI9GF+0Mj0cd5qV5E5S/sgwc5neXkZjY2NNJDOEkvwL76CxNwcAhYL9H3XILqF3KXicaSCQUAsAqRSIBAAP6NwSLrd8H/mDwCZDKnf/BQ2r/dDYMhC84c/DLFYnJ5f/puvIzAwCJ5KBd31a0AoBJ5SAUFbG6KnzyBVXgb3reTr8Hphqq+HtK8PwT/+Arx/8gVEo1Eov/EPUBw7hhSfh/p9+1BWVobxL/wxvNPTmAGgeu45nDp1CsXFxWmxqgwKz+DgIHVjmRLpyy+/jFQqRYvi5uYmkskkHn/8cUxOThJFaXZ2Frm5uWhra8P6+jqHbsXUGZ1OJ/npGo1GlJWVkW1TpsDQ0tISqqurYbfbkZ2dDYPBgEAgwFHHBNKLxdzcHEwmE0fNsrKyEvF4HAsLCwDSwlOs4PX5fBAKhTAajVTAZ24sAJAdFbsfMkOhSPtVs/NOJBIwm83bkuTy8jJR1y9evMj5fTKZRDgcxu7du3H58mWkUikoFAq43W66h1mSFggEuHDhAgQCAbRaLaqrqzE+Po54PA6DwQCPx0MCJcvLy2hubuYcx+joKFZWVlBeXk70sFQqhc7OTqyvr6Ovrw/5+fk4cOAAbDYbcnNzcf78eZw/f546C4xelalmyGaAJiYm4Ha7kUqlcPPmTcjlckogNpsNKpUKhYWFMJvN9z3b+HaizneKTJV2tiFhdhZs/pnH45GgiF6vf6hKvneLn2XB/P73vx92ux1/9Ed/RCqtr7zyCq2bbISAxe7du/Htb38bn/3sZ/EHf/AHqKysxE9+8hMOePV7v/d7CAQC+PjHPw632429e/filVdeeSQQ/f/owYDkgoICVFdXc75bgUBAWhcP+rzGYjGMjo7C5/Ohs7OTw5ZhApwPI7YC42yzzufzYTabaVa0srKSM+cXDochkUhoD5L5bLPOr8PhQEdHB/Lz8xEIBPDYY49Br9fD5/PB7/eThdMTTzyB7u5u6l4ZjUYOxdput6OxsRGjo6O4efMmDAYDR+gTSAPKu3btgs1mQygUgsPhwA9/+EOcPHkSp06dglAo3DYrzXK0wWCA1+vF+fPnEQwGae2IRqO4evUq9u/fD4FAgNHRUayurmJ+fh4ajQa7d+8mKyYWiUQCFRUVnI6qwWBATU0NsrOzMT8/D7fbTeun3W5HZ2cnsbeqq6sRDAYJCGCRTCZhtVpRWlrK0S4pKyuDQCAgwblwOIyBgQGiHbPPl8lkSCaT8Pv9kEgktJ8TiUSc4jdzDykWi2EymThMsOXl5W0UY6/Xi/Lycuj1evT29nIcP4A0sHHy5El8//vfJ3A6c2abfaZQKMTw8DCGh4ehVqtRXV2N9fV1eDweKsgnJiYQi8UwNTW1bQxvdXUVIyMjKC4uxtzcHEKhENbW1vD0008jFArhwoUL4PP56OrqQlZWFvLy8nDlyhWsrKxgamoKEokEdrsdi4uLePe7381577KyMjgcDpw5cwZA2qt6c3MTOp0Oer0eXq8X8Xgcubm5sFgskMlk9zUi+SjmeiB9XEqlEnq9nmyamHgYawhoNBoqoHc63nS/kUgkdryvYLl+p8f385TrH8mCmQluxWIx9PT03LbF/7A6v6urqxgfH0dJSQkqKiq2fdkP43Oi0Shu3LiBcDiM7u5uOp+kw4Hkiy+BLxRC8p53I/hXX4P0vW90lVOxGNxPPInE3ByUX/0KdK+8hMTSEkQZCTby0suI3lps5guMyPqtT9F5JD0e8FMpSCbT3dZUJILIT59H4E/TSI3tb7+Opd/6FFpbW7Hr6/8H614Pyi9fReoWDWcz4Cf7p+r9+7H/778BwSc+jqxbVBg+j4fwzZtAUxOpFDNaVSAQgMViIXVFph69NTLR4oKCAqhUKs6DGggEYDabkZ2dTQmFz+ejsrISFRUVGB0dhdPpJFsINm+k0+k4hTCzY7h+/TpisRii0ShGRkbo9zweD83NzVhcXKRCLVPZkwl3SSQSHDx4EBcvXoTf7+d4dSeTSUSjUTgcDrz++uuIRqOcYi6zy54ZTIhkeXkZZWVlMJvNnHsuPz+fxL4ikQheeuklhMNhKpYzZ71YR5lFNBql98pMpuw+Z+JhmTNVubm5UKvVKCoqIs/lzEgkEkTtYrYeAIhyND8/j2AwiPn5ebS0tFABzjYz4XAYCoUCfr+fs2FNpVK4du0a7HY7urq60N7eDqlUioKCAng8HlI3Z2wDtllh9LydxqMouJFIJLapeW61s/D5fHA4HFhdXcX09DSBCW81In2/BfNOKdksPvnJT96RlvX6669v+9n73vc+vO9977vj+/F4PHzhC1/AF77whfs6nnfi4QcT3LJarWhoaLjt3BoDVR/UgsXr9WJkZAQKhYLmfDPjYeT6OwHjyWQSi4uLiEajNBer1Wo5rJnr16+TL/PBgwcJaGTh9/up4Lt48SKKiopw4MABGh/KZPQA6Y4fcy1ghUdFRQUp+jIfeSCdJ1599VXE43FotVrweDxoNBrs3buXtC0ygVe3202UWAYwazQalJWVYW1tDdFolApvVqBnXluNRoO8vDw4HA5iEEQiEWxsbGB2dpZTtJeUlKCwsJA+h43p2Gw2XLp0Cbt376ZrDKSf85ycHFy5cgVerxc5OTno7++n36VSKdTU1FDO5fP5HJVthUIBs9lM7Kbh4WHqSrMuNzsvr9eL3t5ebGxsQK/X0zFkioBlgtosB8/OzqK+vh6Tk5MEdLPfM4oyj8fD6dOnOccmFoshEokQCASoe8uCx+NRF1upVFJhn7kXyhQPA0CNqIaGBszOznIEtlhMTEzA4/GQICsA2tesrq7StfF4PKivr+d816FQCDk5OSQ8mxlzc3MYGxtDdXU19u3bB7/fj4qKCgJmLBYLLBYLANDom9/vJ4XsncSjmOuB7WuaSCRCTk4OcnJy6Hl2OBwkfCoUCu/JaeNhHNfPQq+Exc9Lrn+kCmYej0dzRQaDgfwAbxcPStNKJpOYnJwkRINZwdzucx6EpuXxeDA8PAyNRoOenh7O+fg+9ZuIXe1FVW4upFcuQf6Jj3Nem/J4kbiFQsav90P61JMQFBSkO3PnzoHHF0DU04OEPgsxgRClT5xEzi1qVejb30Hgs5+DtKYGsZwcCBYWwG9sROzCxfSbi0QYXF9His/HSH8/9uXlI/v7PwDEYiQCAQg+/J+hffIUcGuRlE5NQfyhD0L9O78Nv9+fFvVwOFD36nnwwmHkNjW94R2dSOCVV16B3+/HzMwMDhw4gPX1dSrKlEolqqqqMDQ0BCBdaDGFbI1GA7/fT/ZFQJpKtbm5SclAq9VienoaGxsbOHbsGPLz81FSUkKzwhqNhkRiRCJRWnX8Fg2PRaaoRl5eHnlussLU7/ejtbWV6Nss6UUiESq6gfTsrlarxeuvv45kMgmbzUZoKfCGOAiPx8P+/fths9kwOjpKAlnZ2dmERMdiMc7iyePxsHfvXhiNRkxPT2Nqago8Ho9D4wbS3W2FQgGTyYSSkhJKMgA4dPLMglkqlW6zCmHdZkav27t3L2KxGM6ePYtQKIQDBw4gKysLAoEA5eXlWFlZIXEZo9GIVCqF6elpohPn5+dz/A9lMhmCwSDcbjeOHz+OcDjMKabC4TDNVy8sLHA6L2weTC6X4+LFixAKhdBqtYhEIpDL5RgfH6ckcq/I6KOIOr9ZYufz+dBoNLQ5ZYg088iOxWLk/azX6+9oZ3G/x3Y/SfR+C+Z34hc3eDweQqEQRkZGkEwm0dPTc0cmQiYomSk+tJNgXqllZWUoKyu77TPxoGyyOwHjADA5OYmBgQEA6W7nhz70oW2vZ7lnbW0NIpGI5kcZu8RkMkGn08HtdqOwsJCEPF0uF1588UXw+XzaXwgEAqLqMuuiUCiEjY0NHD9+HOPj40ilUjSCU1paiv7+fsTjcfh8Puj1ehw6dAgAcPXqVbjdbsrHcrmcLKcA4MqVK0S5ZpZVLNfKZDKYTCai1IpEIshkMtjtdly5cgX5+fmcIpQB26ybajAYyOrw1KlT2Lt3L3Q6HcxmM2w2GzQaDSYnJyknisVixONxmiMGuLleIBDgxIkTUCgUmJqawvLyMpLJJAlbxWIxyoupVAqTk5NUEObm5mL//v34/ve/DyCdd1977TVarzNB59raWshkMlLTBtJe0WzOE0jn+8y9ZWNjI6qrq+FyuXD9+nVEIpFts9bRaBTxeByVlZUoKCjgFMw+n4/2KZkF89Y8z64DY8QB6fGympoaXL9+HdeuXUNbWxvR9MvLy+H1eqFSqbC5uQmJRILy8nKMjo6iuLiY7J0ywS65XI5wOIx4PI7q6mpUVVXddqQqFAphamoKzzzzDP1coVAgFoshOzsbq6urlNOYWjmjze8kvz2qQpp3y/c8Ho+cNoqKishpw+FwYGlp6a5OGw/juH5WbLKfp3ikCma73Y6hoSHOXNGd4kEo2SxRM0XJzLnLrfEgqPPy8jKmpqZQUVGBkpKS7ecjTReYSbGI8+AE/+mfEevrg+Iz/xPKP/vfiA0NQ/brbwyrxy5chO9jnwAArH32D+H+6lfQ2trKSdDxvusAAP70NBy//xkUfOnLSA4Pw6NUwt7WigK5AoVDw7A2N6HItoF4fz+QSCCWTOLiM08holKhS6FAXl4eCs6cQd6Vq4hduYrkf/81zK6tEV3X8J//EzxqFYL5+Si7RWfLVGxmQhYMSS4uLqZ5Vo1GA5VKhaamJrKYWFtbIyqWQCCARqPBiRMnSGWQedsCaZuOy5cvY2VlBcvLy3j88ccxNDSEjY0NjpL1nUImk0GpVKKtrQ1isRhDQ0OcBDU1NUVJtLKyEhsbGygqKoLD4YDP50N+fj5qa2sRi8Wg0+k44jQ5OTmQy+VUAKZSKZw5c2Yb+FJZWQm5XA6bzYbKykoOsn7y5EmoVCosLy9jdHR0232YeW/G43FMTU1hYmKCUzCyzUhlZSWHbuj1eiESiVBfX4+5uTn4/X4kEgk8/vjjnIXS7XbT5uW1115DZ2cnWYh0dnYiHo/D5XIhGo3i4sU0GGM0GlFUVMShyGSCDoyexxJoIBDA/Pw88vPzUV5eDrvdjoqKCnptPB7HCy+8gEgkgo6ODjz55JNkw5LZcWWbYkZxerMkwnywH6XYKRK+FZHO9H42m83UjWH/u9+Cg1Fi78dW6nYice/Ef+xgtNzc3FzU1tbe9b5i88X3A5Bnioi1trbetTP1ILmeAeNarRatra3b1hV2flv3AIzhVllZiZ6eHgIcWUSjUbz00ktIJBJYWFiATCZDZ2cnpzhxOBxkzyOTyZBKpUj9m409ZapkM+9TIL3eLC0tQalUIi8vj6yS2FyxWq0m6jDrHiWTSTgcDuh0OpppZedmNpvp30VFRQjfcs7QaDRQKBTo7OykPOH1erG4uEgUZj6fj+PHj0Mul2NtbQ1er5fyYSKRwNTUFKampkjxORaLbfN33qrrwYLtN+rq6qBQKGCxWDg+r8PDw8jKysLGxgby8/MRjUbJO3htbQ1isRj79u0jsJjpogDpIr2wsBCLi4t0j46NjW07lvz8fLJzMhgMnP1aW1sb6Xn09vZuK3IzO9XsO5udneVQTMViMSKRCHJyclBWVkZgeSQSAZ/Ph8lkQjQahdVqRSKRwO7du7etzey8hoeHqWlQWlqK0tJSpFIpOBwOyGQyvPDCCzR3q9Vq0dDQwOl2svuL3YtsvIjNmkulUtTV1WFsbGybEjajcxcUFODJJ59ELBaDQqG4Y35juT4rK+uO+fxR7TDv5LgynTYAkNOGw+HA2NgYksnkNu/n+437nWF+mAD9oxiP1G6R2QHdiyz5/SY3u92OmzdvbhMRe5ifw5L0xsYG2traiKq6NVRf+yqily9j2O9HXiIBoVCIpNOJ4J/9OQAgpMuC6i++BOn73w8gPc+MVAqQvLEw8aQS6lzH5+cR+PMvQbRrF+S/9SlALEagvg4IBYFb53D9V/4r/CoVNng8dP77t9H02utQ/MFnIPjIh5GwLCIolyN8ayZp/OZNdHR1IU+jgf/qNQjb2sDPyUGhQIDp6em04mZREdzLy4DTievXr8NsNtMizOfzUVFRQZ1khUJBydTr9SI3NxdWqxWnT59GWVkZ1Go1cnNzqWCWy+WUpCQSCWQyGYfWvXv3bkp6LpcLzz33HM3t5uXlcWZ+RCIRKioqMDk5CSBN89q1axctsGazmawYWMRiMRw5coTmoDweD6LRKHbt2oWCggKiKotEIhw7dgzf/e536Tz37NkDr9cLuVyOlZWVbUImQHqxHBwcxJEjR+Dz+eByuTi0MrbgbaVoA+mCvLy8HCMjIwiFQkgmk/TaTJAgHo+jrKwMUqkUZWVlsNvt4PP5hHQrFApkZWURwLG6uoqhoSHk5eUhJycHo6Oj0Ov1cDgciEajGBgYgFKppEWbiYaxDU8ymcTq6ipWV1dhMBig1+tx+fJlUtcuKytDXl4eZzEeGBggevF73/vebQsuo+sBb9B+WKytrcHlcqG6uhplZWUcu6bMJMKSauZM+aMkBMLiQRI7j8eDQqGAQqFAUVEREokEeT9bLJZtiLRarb7nz2L3306PLRgMoqCgYMfn8k78YodYLMauXbtuKyJ4u7ifPBwMBjEyMgIej8cREbvbZ9wPm+xNgXGku8oqlQrz8/OcTf3AwADNLL7//e+nwoIBVJnjGcFgEIcOHYJSqUQ8HifV6Pb2dtTV1YHH45HoFvDGs5pIJFBaWgqLxQKj0Yji4mKyBmKF2ezsLBoaGtDW1obz58+TY4JQKIROp6PuEevWsrnjzHOpr6+n/C4UCrG2toZ4PA673Y6amhosLCzgzJkz0Ov1NAL30ksv0Xl2dnaSp69cLufk76KiIgL7otEofvrTn1JOaGlpwebmJocGXVVVRRZMKpUKBw8epHzqdDoxNDTE6c7G43F0dXVhdnaWhEoZtXvXrl3Iy8ujz+/s7EQgEKCCdN++fZDJZJDJZHC5XFhZWblt4T49PY1nnnkGGxsb28aR2HOwurq6rVhWKBRob2/H2NgYNQvYd5uZ65nKulqtppwXCAQ4o2ylpaXUfff7/XjhhRcgEAjQ2tqK/v5+EutioqtarZYzksXm62UyGQKBAI1zCQQCtLW1YWBgABsbGxAKhaivryclbhbz8/M0Cnf06NHb2kSy+9fn80EsFlMh7vV6YbFYYDKZKL+xRorZbCa7JpbrM8UxH8VcD9xfJ5fF7Zw2HA4HjTVIpVKO9/NOmgM/6/Grn5d4pArmzK7TvfztThDnVCqF+fl5MkK/103cThN1KBTC8PAweDweenp67pqk+UolJMeOIXH69BuFklYLYVcX4kNDEB86SH+bWFmB+6lngGQSkW/8HRZ/73dgLCxC/ckTb6g0/umfI/baa4idOw/JyRNIOh0QfP/7iHzsVyD9489DkEhAKBEDsRhS09MQ1dUhMjuHwOf/F7IGriPrwusQfv6PUXP2VQR1WlS/973Q/vgn4B8+BPW3vonoufNIbmzAkJuL9vZ2WK1WKJVKZGdnQyAQEIrt9XphMBiwubnJUanMTCINDQ00VwSAKF1HjhyhOV6fzwez2Yy2tjZMT09TV7ugoIBYCLm5uWRnwIIh3QCIvmq32+FwOKDRaMjnMRaLQSgUwmaz0eZDJBJBp9NBIpGQymameEcoFCKEPBqNory8HEtLS8jPz4fJZCKBLD6fj/Pnz9+WClRdXU3JPCcnB2fOnKGkxu4XsVhMlgtVVVWw2+3kuRkOhwmMYVSlWCyG5uZmLC8vk/I6kL5/MwXUWBdCKpVCr9cjPz+ffg+kRTcikQgsFgucTid56zU0NGB8fBzhcJjmxnQ6Hc6ePUsFa2dnJ4RCIXp7ewnRX11dpU0Wj8dDOBymOalwOEzqnkCaRpZ5rVZWVnDjxg2Ulpbiscceg8vlQlVV1W2/i3g8jpaWljsmEZvNhpmZGchkMqIrP4qo84Mk0K0hEAgoYQLpDRUDE0ZHR2nWn/3N3dYq9gzf71zTO/FObA2NRrNN1PBOsVNGGQPG8/PzUVNTc0/P+U5z/b0C40B67SsoKMDa2hqnKC8pKYHL5eLY4aVSKbz88svY3NxER0cHAYxsbAhIg6hMACsnJwcikYicJvbt2weXy4VIJIKZmRnqMieTSZjNZhQXF+PUqVNYXl7G+VsaJfn5+RAIBNjc3MSxY8cwOzuLQCCA7OxsdHV1YX5+nmZM7XY71Go1FYY5OTnkZsKCjVEBacaRw+GgAndjY4MUmvft24fz588jGo1ifHwcZWVl2NjYoHPLzs5GUVERGhsbKV+PjY3Re/F4PCwtLdG6yQplh8MBhUIBiUQCk8mEeDyOVCqFRCKBV199lTporCtZXV2NtbU1Ttc5lUoR2G8wGHDo0CEsLi5CLpejrKwMNpsNJpMJBoMBZ86cocIxMwwGA8RiMTlpDA0N0chU5n2gUChIA0atVsPr9VJXORAIkAAYK5jZ52dagwFpIbC1tTWawWZCZBKJBFVVVRx6utvtpuJ0enqaQPP29naykbx27RpEIhFyc3MxOTmJ8fFx6HQ6yrX9/f3w+/2kMcO+Nx6PB5/Ph4MHD5L7RyQSoYKKUe9ZMNsvuVyO7u5uLC8vb7OIvHLlCjweD1ZWVnDixAmOXVNlZSXC4TDN+1osFvp+9Xr9tnG3RyEelpAhwHXaKCkpQTweJzCBOW1oNBrK9W/mtPEgM8y/yPFIFcw7iZ0oZ0ajUdy8eRPBYBBdXV33jGoDO5tr2tzcxI0bN5CXl4fa2tp7ehB4PB4nUfP4fGi/8+9IJRJp26dbEb95E6lbdOG1s6+i4uMfS9Mw43FEzr8GQXkZkhkzNPHZWcReex08AE6zGT80GFDf2IDHFxax/K1/h8G8gNThdEHONxjAk0oRiUQwV1cHvcWC2j17kfrn/4vA1V4Ev/Nd8IVCJFdXEbt4CeGv/AX5GWu1WhQWFqKpqQl+vx+Dg4OwWq2ULBmyl0qlOHO7BQUFJAzFBKxSqRSWl5c580+MnlVUVEQef3q9Hjdv3oREIoHVauUUy3w+nzyYgTQCy9QvGXLtdDoxMDAArVYLpVK5zQqJJZWGhgaifAHppJY5g2S1WrG8vAyXywWhUIjS0lIYjUZK0CKRCNFolGNhxZS7jx07RlRmlkAZpQoA0bmvXbsGqVSK/fv3Y3l5GRqNBtevX4dEIqFzYa8dHR2lJCyRSLYpvrKinKHSm5ubOHPmDCXcvLw81NfXIxQKwWg0YnNzk8TcgsEgsrKyaONz9uxZssIAQBuz2tpaPPPMM3C5XFhaWoLRaIROp0MwGEQkEoHb7SZbrTNnzpAtSUlJybbncnJyEl6vF6Ojo3j/+99PIBfbRIhEIjrPTGQzlUqhv78fDocDXV1dKCkpoSTC5n2np6cRDofh9/spsT4KdKIHFTa6W0gkEuTn5yM/P58Ef5xO5zYwgYmHZSLSTITmfjrMv+io8zvx1se9FrOpVApzc3NYXFy8rbvGw/gMgAuM7969+57VV7daVzU1NaGhoYHzXEWjURJpGhsbQ2trKwl5bmxsIJFIcMS9mJNAKpWCQCDApUuXoNPp8Nhjj1FuDIVCtLYplUokk0m4XC4oFArqSrIZ65KSEiwuLkIgEOCXfumXcPbsWSQSCYjFYqjVahw4cAAymQyJRAKzs7OcIoyNADkcDmJJ1dTUIJlMor+/nwBYIN1NZQWWUCikznd+fj60Wi3C4TDKysowPz8PsVgMnU5HNHMWubm5dK3EYjExyEKhEMrKyrCwsICxsTGsrq5Sx41dBx6Pxynq2Qw58IYvMwuv10tUYQAwmUzIyclBY2Mj/T3AVaYWiUTY3NxET08Pamtr4XQ6aUSL/Q07jmg0itOnTyMej+Pxxx/HxsYGtFotKXPrdDrOa+fm5ii/s/Ezdi8AIICANSlisRguXrxI955IJEJzczNCoRAEAgEMBgM1JOx2O7H/2P2UaSnpdrtx5coVaLVanDx5En6/H1arlYq19fV1hMNhxGIxrK6uQqPR4MUXX0QwGERnZyeeeOIJCIVCDkDLAHqn04mamhqOK0coFIJQKIRSqYTH49mWT8xmMyYnJ1FTU4Py8nISx/R6vXA4HNREEAgEmJ+fh16v3xG76q0K9l28FcchFAphMBhoBCXTaSMTTLiT7sv9FMz/EXL9z23BfK/KmWy2SK1Wo6enZ8czfPfSyc70daytrb2t2fvd4nb+j7ytN+u+ffAcPYJkPI7qX/0ElOxB+Id/RPArXwWkUii/8Mfwf24a/IoKiJqbIdqzG7G1dXhuUVoWx8bQkKVH3tQ0wOPB1duH8Md+BeW/9mvwhsOYeO6nqPiT/w0eAPnv/g42JybwWk83IBRi32sXIF1dBc+P0VRNAAEAAElEQVSg51ClWAHE4/FQVlbGoUyXlpaioqICr776Kl1LiURC6palpaXQ6/VEEdLpdJxZV5VKRZ3fo0ePor6+HlKpFL29vQDSXoOZM0x6vR6bm5tURDKklgWj8ACgpL65uYmSkhISGcv8rs1mMyUlRlvOTKSZIh/xeByzs7O0QK2urkIikVDCys3NJaQ9mUzCbrfj+vX0nDmzsGBJ9caNG3C5XLh27RqAdKHLrqFYLMapU6ewurpKyqdb76FMX+XMzUWmuArrXkciEQI0/H4/zp8/j+bmZpSVlWF6eho2m42sUADg4MGDpFpos9lQX18Pi8VCgiNra2uorq7G66+/TvNKfD4fdXV1mJqaQkFBAbKyskjNnH1uZjHMNmuVlZUIBALbVLpv3LiByclJ5OTk4OTJkwiFQhwFTjYTDaQpYKzDKhQKkZ2djezsbKRSKQwPD0MkEsHhcGB+fp7mofR6/Y4pTA8rflZdbx6PB7VaDbVazQETnE4nZmdnEQ6HOXYWwM67y8B/DCGQd+L+YquC8N3iXopZJroVCoXuebRrp58B3B8wzuJ2APzW14vFYio8Ojo6SI3abrfj5ZdfBgD09PRAKpWSt25DQwPMZjNCoRBSqRScTifNrjInAblcjoMHD0KlUqG/vx9zc3OIx+PQ6XSc4oXlCJFIhHg8zmGIMbHNEydOwO/3U/GZm5uL0tJSTE1NkcsEs4Z67bXXsH//fuh0OpqfFovFKCsro/yu1Wpx48YNpFIpNDc3o6GhAYFAAHNzc3A4HHC73dBqtXS/FBUVYXl5mWjRWwtcABzmFMvV0WgUKpUKLpeL8z24XC4qmJVKJRKJBEc4KxqNctwYLBYLrWtsVIuFUqlES0sL2XuxnB4MBmEwGFBeXg6TyQSpVEoU5rNnz9Lrr1y5QqD20aNH4fV6EYvFaG+11f5sK3gCpAH3rQJjmV1WoVCI559/HgUFBejo6ODs21iDoaWlhTrWbJ45EAiQWjVTrM6k54vFYtTU1GB6ehpqtZrGpBjN3O12c/ydNzY24Ha7YTQasbCwALlczvGeXltbw+uvvw6RSIR3vetdqK+v36a2PTY2hkAggLGxMXpvPp8PrVYLrVaL8vJyLC4uYmNjA+FweBu7Sq/Xvy3Wgm9lwbw1tjpteL1eOJ1OWK1W0n3JFA97R/Tr9vFIFcw76e68mXIm61YyEY07zRbdy+fcLYnG43GMjo7C4/Fs83W812BJLWm3gyeXg7flpiOl7U98HI2NjdyNPCvwkkkIqqqASATJ8XFYv/d9LHzsV5Cr16Px078NS1sbKgQCJPRuAEBCIMDlT3wMcYkE6zdGEI1GUcPjgXfr/RKWJQQ//J8RvXIFABD53B8ix+OBqK0NgVsFaWaEw2HMz89TgdrT04OSkhIqjIA0PYl1BxUKBSHaer2eKDsMIZZKpRzkemlpiehSubm5tNC2trbCZrOhoKAAN27cAJBO9GxREAgE9L13dHTAYrFQYmTH5XQ6sXv3bvT19VHyEQqF5K0skUgQCoVICCTT5ikTGWdI8fe+9z3OLLJQKERjYyOysrJoE8Nm1di5Njc3w+l0YmRkhJPo2PmwBBqLxTA+Pg6z2cwpkpmaokAg4NhpSSQSUlhcXl6mzRCj5MRiMezduxderxfXrl0jGtrw8DCqq6vR0tICPp+PoaEhqFQqGAwGaLVaOJ1OeL1eUiPXarUEnoyPj0MikSAYDFKinJubQ35+PuRyOc6dO4eWlhY0NTWBz+cjPz+fjnd5eZmAgoMHD97WaD5T9E0ikRA6ylS28/LySJxtK62LBeuWZmVloaCggDMPxShMjM2g1+u30cXfqni7aOKZYAIAjrjK4uIiif2sr6/vyM7iP8Jc0zvx1kcm2He7cLvdGBkZIR/f+wG73oxN9qDAOPDGnHQsFkM8Ht82BsGKfj6fj5MnT25jzrCQSqWkhH3t2jXodDrU1taS6jhbQzKB+GAwiIsXL0Kn01FRCHAtooB0zjh27Bg0Gg2EQuG2PRDrgDOgu6qqCs3NzQgGgwTUCgQCKnwYFdnr9UIikSAnJwc+nw99fX3kVJApdhmJRCiXFxcX03pfWFgIvV4PsVjMmd0ViUScvJ1KpWAymSCXyzE5Ock59s3NTZw8eRKXL1+Gx+OhkalQKASZTEa+t+zcSkpKsLy8TO9RX1+PiYkJOu7Tp0+TpRc779LSUhQVFaG7uxubm5uora0lFlk8HkdnZyd1fJ232UtlfmeZ1Ht2r/B4POTl5RHtNrNYb21tJaHOzH1ESUkJrFYrdu3aBZFIhMHBQSQSCSwtLWFpaQnFxcXk+HH16lWkUink5+cjEonQXufKlSvbQPkrV67QXiYejyMej+PGjRvIyclBRUUFLl++jLKyMuzZswcOhwO1tbV0TOFwmMbWamtr8cQTT2y7FqzBEYvFEA6HaewhmUySCF5NTQ3Gx8dRXV297fUs+Hw+ZDIZ6uvrOeyq9fV1zMzM/MysGTPjZ1kwZ0YmmMCcNliun5ycJPV2u91OziT3svf5j+CI8UgVzDuJuylnJhIJjI+PY3Nz801ni94s7pZE/X4/hoeHIZVKsXv37vv2RBMIBIhfuADnp38HPJ0OulfPgH8LRbNarZiYmEB5eTlKS0vTRU5fH7wf/1UIamqg/tf/C0FpKQSVleBnZwMKBRAIYFAhh2dhAWtra6jq7kbnK6chrK+H9Ld+EwAQWV5C6tZD4J2aQs973gO9TodgJIIJPg8pfRaaCgtRVVWVTkBVVbQJYUrSmTMydXV1SKVSWFpagkgkQm9vL/r7+5Gfn4/CwkKsrKwgEongsccew/LyMsrLyzmiEVsjE0Ht7u6GTCbD1NQUzVkx9cW8vDyaa9XpdFhYWEBRURH6+/tht9uh0WjIc5J1k91uNweVDYfDEAgEOHjwIEZHR7G0tIR4PA65XI76+no4HA74/X4kk0miW7M4fPgwiViwhThzY5NKpRCLxbC4uAiRSAS3203Up8zPB4DFxcVtllF8Ph8NDQ2QyWSUyDJnglk4nU50dHRQAQuAZsT0ej0n8bL3zc7ORllZGVQqFV5//XWkUinqtKdSKQIosrOzUV9fD4FAgPHxcUrymbTv/Px8BAIBxGIxrK2tob29HYlEgqj7jJLNUP+LFy+Cz+dj//794PP5dJ0yqUGZz1M0GkVfXx8JlJjN5m0b1v7+fqysrEAikeDd73433iwybaW2zkPdjsKUqcb5VvkfPipz1QyAKSwspA7V4uIilpeXMTExQYi0Xq+/oxI5A8d22ul7J96JrXEn4DoTGK+srITJZLpvYOtuol8PAxgH0utuOBzGs88+S6KSDDD0er0YHh6GSqUiIc9wOIyXX34ZsVgMx44dw9GjR5FIJFBQUIDx8XFac5mStU6nQzQaJTZXd3c3PB4PAdE+nw9NTU0oKytDbm4uZmdnEYvFEIlEsGvXLthsNjQ2NtL5ZXZi2ZrX2tqK7OxsWvPNZjNmZmag1+tRXl6O8fFx8Hg8FBcXg8/nw2g0Yn5+HqOjo+S1DLyRv1g3K5FIoKysDA0NDdT9ttlsNM4lkUiIqsvAa5bfb968CT6fT93j9fV1PPbYY1hdXeUUpalUCisrKzh06BAmJycxMzNDhR7L9ayw12q1yMnJISp0U1MTFeQAiHbMgsfjIZFIUG6KRCKYm5tDIBCg9ZHlervdzmkIsNcbjUY0NjbiwoULCIVCxJQC3ugkx+NxqNVq2O12DhugsrISNTU1CAaDeO655+h17F7o7OxEcXExLl26BL/fzwGhlpeXsbS0BIVCgaqqKkgkEhLiBLiAlVKphEKhINE4o9GIvLw8jI6O0v4nHA6TpZbT6YRQKERLSwt1cqPRKNmgMW2WzO9odHQUdrsdra2tqKuro4KWhdlsJg2c48ePc2ypbheZuX4ru4pZMzqdTrJmzOw+y2SytwQsz2yqvJ3BZtRzc3MpZ1+/fh1utxvLy8vktMGYd3di6QYCAQ474BcxHrmC+UFpWoFAACMjIxAKhTuaLdrJZwBpf9vR0VGYTCZUVlY+0E3P5/ORmp4BL5VCyulE0rYBqNUkdLXVJzpy+ixSPh/i/f1I2TYgeTKtNJhIJBD9/nehSyRQEArBMzGBnJwcCPoHkLLbEX39dVy6eBGruTnoaKjHns/+ETz5eSj53d+B9haV2FFRgQnLIjA1BY1Wi56enm3Hm2kZkEgk0NPTA61WC5fLhZycHEoK8XgcTU1NGBwcBJDulD///POIxWLweDzo6urCuXPnEIlEaKaFKT+nUilUVFRgfn4efX19OHnyJPbs2YPBwUF6f2ZVwY5pZWUFY2NjcLvd2Lt3L1ZWViAUCklJWqlUoq+vD8lkkpDJmZkZBAIBvP7661AoFBwKt9lsxnve8x4IBAK43W4MDw/DZrOROB1bHFhHN7MTLJVKoVAo4HA4wOfzsba2xilYWeEokUhQWVkJn88HuVwOlUpFtlsM6VtaWkJPTw89G4xCtxWdnp+fJ7S5qakJNpuNwCKj0cjpjDNVbpvNhoMHD3IKXyaUxYIh8JkUNyAtvsZ+ZjKZ4PF4sLq6Cr/fj0uXLiErKwv79+/HhQsXaO4uPz+fxErYdWDiYQ6HA7t27cLx48dJNIzF8vIyUeKsVisJvmXej6zYvtdi9m7KmVspTExtmhWMKpWKCuiHOQ/1MEW/HlYwdF4qlWLXrl0cJfLx8XEkEgmO93PmBuNhdZidTid+4zd+A88//zz4fD7e85734K//+q/v+N5OpxOf//zncebMGSwtLSE7OxtPP/00vvjFL3Luq9t9/9/5znfwgQ984IGP+Z24e+yUUbY1D8fjcQLw2tvbORvq+wn2GVuFGh8WMA6knyW/30/rn9PpRH5+PtlLbfWJ3tzcpJy0trbGseBpbW2lkRqWv0QiEQHa/f39sNlsNPKTSCRQUlJCtNWsrCwsLy8DSF/LQ4cOkSAji0wAIRaLob6+HuXl5eSNq1QqqVgvKCigzXQ8Hsf58+fhdruhUChw4sQJrK+vU65k3T7GMjMYDPB6vTCbzdDr9Th69CiuXbtGOU4gEHAUxDc2NjAxMQGxWEw082g0CpvNBpfLBbVajZs3b9Lr6+rqqKM4MjICl8tFXV92nZuamggsvXnzJhwOBxYWFqBWqyEWi6HX6wl4YOws9p2aTCbSXpHL5Xj55ZepwbC2tkYNnoaGBgIocnJy4HK5EIvFaA7ZarWiu7ubjksikaCgoIBYPqxotdvt9D0bjUaIRCIUFRUBSO896uvrMTk5Sd/f9PQ0pqenkZ2dTV1b5hwyNTXF2XOLRCKix7PIzc0lwbqysjISS00mk7h8+TIEAgFOnjyJn/70pwDSAHltbS118WOxGKanp1FeXo6xsTGMjY2hqKgIJ06cQCAQ4Ni9BYNBjI+PAwDOnTsHhUKBQ4cOcbRw2DPIGHxvFnfL9bezZmTjemx+nuX6hzmqxXL9210wZwaPxyMmQ2NjI+19mX3c+Pg4OW3o9XqoVCra+4RCIboHHyQe5Vz/yBXMO4mtSdRms2F0dBSFtzqjD2MTuxV1TiaTmJ2dxfLyMpqammjTfj+RWFuD/zN/gDyhAMnP/E8okynwi4uQKDFhsL8fsViMfKKTHg9C3/gHCKqrIPvP/wmJmRkI6uvALzHR+125cgULCwvQ6/V44okn0NTUhGg0iqHlZRQODCKZmwvLreQ7trSElu4u1Hzkw5C2tVESl/zoxxDV1iAhEiJLqcTw8DA2NzdRVVWFa9euQalU4vDhw5BIJOjt7UUsFsPExASKi4tx7do1Qk2Z7ZHBYEBPTw9mZmawvLxMyT8ej+Ps2bOIxWJQq9UwmUwcv+NAIIBkMkmL9vT0NCVmkUgErVZLDzQAnDlzhj57eXkZPT09mJqags/nQ1FREfLy8lBcXIy1tTXYbDaEQiHMzs5CrVYjEAiQqiPwxjwU63wODg5iZWWFEF6TyYTS0lI4nU4SW2HHFYvFyCeSzZvJZDKiJmdlZUGhUBAFjcfjYXV1lZDN2tpalJSUQCqVYmFhAWazGXV1ddjY2KDPySw4s7KyaFPArm1OTg5KS0tp9mh1dRWDg4Oc2R+NRkNempkFmtPppPNkzxcTINkamerh/f39aG1thVgshsvlgsfjQSgUQm5uLgoLC4nezgp2nU4Hl8uF2dlZFBcXU4G+sbHB8SFlHssGg4Eoc/F4HIuLi9i1axeCwSDOnDkDIK3umZ+fz6G73y0yUee7Rab/YXl5OaLRKKlxZs5DsaT6ICDdWyn69SCRKQKyVYk8EAjA6XRyNhjPP/886uvrH5py5i//8i9jbW2N1oyPfvSj+PjHP45vf/vbt/17Zm32l3/5l6irq4PFYsGv/uqvYnV1Fc8++yznb//1X/8Vx48fp3/f7l5/J97e2Kol4vf7MTIyApFIxFGPftDPALig1cMCxpPJJPr6+mCz2VBcXIzOzk4Eg0EqWFZWVtDc3Eyb9snJSUQiEdTV1RFtMnO8ZH5+ngqV97znPfjABz4AoVCICxcuwGAwIBQKIRgMkraGSqVCdXU1amtrEY1GqaPGQiqVYmlpCRMTE6iqqsL4+DhCoRAOHTqEw4cPo7+/Hx6PB2NjY2hpacH09DQVj2q1GoWFhSSAlUgkSGwJSBfafX19ZGnY2NiIYDCI3FtuG6OjoygtLaVRnLW1NQwMDBDjSSwWo6qqip7L0dFRDA8PA0h3Kt1uNzY3NzE9PQ2JRIKOjg7k5uZifX2d2FwLCwscK0RWLGd2Tpl+xs2bN4nOrNVq0dbWRo4dmcUmy8GHDx+muV8AxBJLJpMoKiqiQj6VSsHj8eDSpUuw2WzQaDQ4ceIE4vE4QqEQBgYGUFhYyBF1Y0JVLNjxMh0ZsViMzs5ODA0NUXf3/PnzNJYGpPcIdrsdcrkcYrGYCr5oNLoNBA8EAkTFzXzeMi0vZ2ZmsHv3bhL9tNls5APe1NREHfmpqSkkk0lkZWXB5XLB6/ViamqK5s7X19eJycTuk5WVFWRnZ5OYGztXu90Oo9GIM2fOwOVyobm5GXv37oVWq70nBtO95vpMa8bi4mIa1WI6J0xtmuX6BxnVelTYZFsj02Elk3kHpJmfbO/DGhhDQ0NIpVJYX19HS0vLA3/+o5zrf64LZmY1wYrYpaUlNDY2Ii8v76F9RmZRzmZrotEoenp6HngjGHn2h4hdugQtgNj7fwmKz/xeel65txc6gQBt3d2E2Ib+8Z8Q+od/BADoLrwGzbe+ue392CLLOrASiSTtxarVwvyXX0ZNTQ0qb96EZX4eDf/2/6BeWUGioAD+qir8+Mc/RjKZxJ6DB9D1d38P18HHwZdKieK7sbGBeDyOcDiMtbU1osMwylUkEuHMzBw5coTjcTw7O0vXS6VSobOzEw6HAx6PBzwejywpGEARjUY5PomZ9KWSkhLMzs7i/PnzeOKJJzA/P08Fl1gsRmNjI/h8PiW0tbU1LC8vY3FxES0tLSSwwUCCgwcPkr1GQUEBuru7sb6+Dq1WC4/HQ4U6C4vFguLiYlRUVFARyGgrTN7fYrGgtbUVDocDVquVaFn79u2DXC7H6uoqJiYmYLfbMTo6Sguny+XC5OQkiXsJhUKsrq5uoycD6aStVCpp48Pu08LCQvj9ftjtdjz//PO0UWBJls/nY+/evYhGo/D7/UgkEjQX7vf7kUqloNFosGvXLhIbA9Iq4axgZYqszFLE4XDQ39bV1SE/P5+K9o2NDeh0Os4GjSVRIA2esGteU1OD0dFRyGQylJaW4syZM4hGozAYDKisrITBYMDIyAh5hDqdTkL6GaBzu1mo28X9JiyxWLxNbdrhcGBtbQ3T09NEH2N05Z10jB/lJHq74+LxeFAqlVAqlbTBYIDJn//5nyMQCOC//bf/hqeeegrHjh1De3v7jjvok5OTeOWVV9Df34+Ojg4AwNe//nWcOHECf/mXf3lbJeSGhgb88Ic/pH+Xl5fjf//v/43/9J/+E+LxOKdLoNVqH2rOeCcefmTm4fX1depQVVZWPrTnJVMXhcfjPTRgHEiLTjHF6s3NTRw9ehTRaBQjIyMIh8Po6uqijb/NZiNBSLlcjn379m17P5brE4kEYrEYdYWSySTUajXa29sRCATQ39+PRCIBr9eLubk51NXV4eWXX4bb7UZpaWkajE8mUV5ejitXrsDv95MwF5DWDlleXqY8XVpaimAwyBH+bGpqoq51pogQu6aHDx+m7qtEIiGQeXNzE6WlpaTYzSIYDBI4XFJSgpmZGQwNDZGIZmaRV1ZWhpycHCpYo9EoBgYGIBAI8NRTT5E9UigUQigUwv79+zE4OAi/3w+JRIKTJ0/SZ2dlZeHll1/m+CC73W6srKygtbUVarUaa2tr4PP5yM3NpWuyublJXV6fz0cFY0dHB8rLy4mhsL6+jtnZWU4X/vnnn0cymcTBgwexa9cuzM/Pc9S6yT2Fx6PRNvY9AyDBqtXVVSwtLdFsc2axW15eju7ubni9Xvj9fpSUlGBkZARisZjuo8OHD+Py5csIh8MIhULIzs6GzWaDUCiknF9RUYG5uTmaPQbS4mu1tbUwGAwkDsrYcWyfkrnWhkIhtLe3Y2pqCiaTCWazGX6/H7W1tejr68Py8jKkUilKSkrQ0tKCGzduQCgUIi8vj4AeIC38yePxcOLEiW3Pxu3ifvPq1oKRjWo5HA4SJ2W5Pisra0eiwo9qrmf33O2OTSKRwGg0wmg00t5neHgYP/jBDzA6OoqJiQmsrq7i6NGj2L9//45rpEc91z9yBfNOKdnhcJik93t6eh760DlL1ExUhCGO90vLSCWTiL7yCvjZORAfPIDQN7+JsFqNVEkJVlZWMDk5ibpLlyH51r8jdPwY+J/5n+BpdRDeomLxDAbwMlCRhYUFDA4Oorq6Gnv37qUZXvq8VAruzc20CuTCAqRaLQ7u2QPhV/8KKQD8vDyEolFagGPVVbjxX/8LIpEIvDduQKlUIhAI0AIsk8ng8Xjo32KxGMPDwxgbG6POmkKh4GyKp6amEI1GIZfLcezYMRgMBgiFQkJmM/2YpVIpIZB5eXnkH9nU1ETqmtFolBLP8PAwCXRUVFSgoaGBOr27du3C5cuX6VhZ4cV8/tbX16FUKiGTydDQ0IDNzU00NzdDLBajuLgYwWCQusRisRh1dXU0r7yxsYGrV6/S4sJo5oFAAIFAAGKxGMFgEGKxmINgC4VCBINBuiYsmpubIZFI4PF4sL6+jmg0inPnzhGizVSkRSIRdu3aBbfbjenpaQ6yzWbhlpeXMTY2xvm5TCYjFWtG83Y4HFhaWoJKpYLJZCKV7oWFBTQ3N3O+w7m5ObpHGLWbeUOyOTf2e5vNBolEgrGxMXi9XkLYVSoVzQe1t7dDr9eDx+MhPz+fNmNTU1N07Jl0ms3NTWxubqKzsxPHjh2DxWLB1atXUVVVhaqqKqytrcHn85FFGUN9/X4/ZmdnYTQat216b+eRvdPInIcqLS2leSiHw0ECGjuZh3qUk+i9FLrMouTv/u7v4Pf7YTQa8aEPfQjXrl3DX/3VX0Emk8Fisexo/ezt7YVWq6UECqQ3eHw+H319fW86v8bC4/FArVZv++xf//Vfx6/8yq+grKwMv/qrv4qPfvSjjxRN7p0AzfOybmxjY+MDF7FbI5NaOD09/VCAccaWMhqNyMrKgs/nI3uc4eFh8Pl8LC4uwmaz4dixYxAIBFAqldQMyFwDPR4PXn/9dSiVSuzbtw9CoRAqlYpjx7exsYFoNErih21tbVhaWoLVaqXzYEVSLBZDXl4ezGYzzp8/D6PRSE4QrEtqMBgINBcIBDCbzTCbzZzOTOa4GHOWiEQiOHz4MLRaLRQKBTF0MhlZOTk5GB0dRTwex8bGBu019Ho9Ojo64HK5YDQaKfe43W7qaufn56Ourg4GgwHxeBzNzc2wWq0EnrKO54EDBzA3N0cWSYlEAm1tbZicnKRZXbaBZsUyn89HfX09xsfHkUwmyX4xEyRwOBykSL6ysoK1tTVil7GQSCRIJpOYmJgge0Z27Pn5+RAKhbhyS1T16tWrNPq0ublJ+xzWjV9fX6eOPZCmYUejUchkMvz4xz+m9xYIBDCZTCTyCaRBjEQigf7+fvB4PNTX16O9vR0qlQpDQ0MoLCwkhxIgzVRj+w6VSgWHw0FFs06nIxV0dr+xe5M5XgBvCJQJhUJ0dXXB7/fD6XSisrKSWCEejwcXL16k42bBnvNgMIgDBw7A5XLh+vXrKCgoQHt7O/lsZ9pmse98cnISUqkU5eXlnDX8YeR6dl5bR7UcDgcsFgvGx8ehVqsp16vV6jf1On6Uc/2bXS+29/nUpz6FT33qUzhw4AD27NmDSCSCT37yk7Barbh8+TJ27dp1z5/9qOf6R65g3kkkk0may3iQIvZuwex3+vv7H0htm0XkBz+A//f/EODxoD3zCvT91zEwMICEywX/8jJaW1sh/MY/Ig4geuEioq+cBk+lhO7yJaj//f8hsbgIXgaKNTExgUAggJs3b6KxsRENDQ0A0jd9IBCAYNEC1YYd3vw8yGZn0fUbvwGVSoX4K6/g4uXL8Av42C8Q4MCBAwgGg6isrCQ6GOtAAumuodVqhVgspqJRpVIRjZnRqdnxMJS3pKQEbW1tmJqaQnNzMyWnZDJJCUqj0SAcDqOnpweFhYUwm83wer2ESgMg9WU+n48nn3wSBw8ehEQioYJWIBCgo6MDAoEAsVgM6+vrNDsNpJHQUCiEM2fOoKOjA2azGclkEk6nE/39/Th06NC27yoej1MRqNVqUVxcTOdut9u3zdRlWjOEw2Fsbm5CKBRCr9cTXWpoaAjJZJJDZ5ZKpTSbxgrv1dVVuN1uUqM0Go3o6OhAJBKBTCbDzMwMp6NcWVmJvLw8OJ1OnD59mnNcNpsNPB4PXV1dGB4exurqKoaHh2luyO/3Y2xsjOZF2CYl04OaJUixWIyCggKsr68jlUrB4XCgpqYGOTk5uHDhAil3PvHEEwiHw7BYLAiFQhCJRFCpVOSTyOfzOfYSLDI3iKzzLpPJqBBeWFiAyWRCb28vUqkULBYLBAIBDh06BJvNhtzcXE4SGhoagtVqxezsLN73vvdxnt27zTXdb2ydh8qkK8/NzUEikdx1HurnvWDODNap+cQnPoFPf/rTZDO203V6fX19G81eKBQiKyuLwLU3i83NTXzxi1/Exz/+cc7Pv/CFL+DgwYOQy+U4c+YM/vt//+/w+/34H//jf+zoGN+JncdOnr1UKgW73Q6xWPxQ2F13Oh4ej4fBwUFkZWU98J7C5/NRfurq6sKpU6dgsViwsrKC69evo7y8nPICE2pKJpM4cuQITp06hZWVFU4DYGFhgZwIPB4P5QzW6VEoFFQwJpNJNDQ0ID8/H+Xl5ejv74fVasXCwgKOHj0Kq9WK8vJyYnYJhUKiKefm5kImkxGVGgAVcCyMRiPlhwsXLsBkMkGj0dDcal5eHoG8ANDX14e5uTkolUqIRCJUVVUR22RycpJTUIbDYVy9ehV+vx/79u3DiRMnEAwGKfcCacujrKws6h5fvnyZQ0FWKpU4f/482traOEDIlStX8N73vpdzbCwYo00oFKK6uhpms5maBVvFODO70OFwmL7HTNr85OQkUXkzo7GxEWq1GqlUCi0tLcQyYAyDrKwsGjcSi8WYm5sjdpZSqURjYyMJqjHxOBaRSAQ+nw9tbW0EUGSqfKdSKQKk9+/fjyNHjmBsbAx9fX2kYyKTyWhMLT8/H8FgkAp5k8mEXbt24dq1a/B6vYhEIigtLYVarYbNZoPH40EikaBcn5ubC7lcDqVSua2zJ5VKqbkxMzNDQBFTPbfZbKRJtL6+Tvcns1oTi8Wc2Wez2Uz3s0aj4QA5b4U2SOaoFrv2rPvMmABMJFSv128bG3mUc/39HFc0GsVjjz2G97znPUilUpibm9vxTPOjnut/LgtmtlH2+XzIzc1FU1PTW9IRSCQSWFhYQDwex65dux5IbZuCIZB8Pni3/PQ8Hg+U5gW0XuuDIhQG//N/hPC//isSK1bEBweR8vkRPf8aAp/9HFKBAALzZtieeRoFBQWoq6vD0NAQKUWzOH36NOx2OyrLy9F87jxSkQjyv/wlyG8tyo6pSSz70wXe3NgY2vfsodceOnQILpcLYrEYZ8+eBY/Hw8TEBP2e2RllMgGamppoFgUA/f3CwgL27NnD8SRm15YlqJycHOzevZt+V1BQQNQgACSIkUwmkUwmcf36daysrJD4ls/ng8FgwNLSEkpKSiASibC4uEjv39XVBYFAQIrNw8PDHIp3prIfE5xYW1tDZ2cn9Ho9HA4HNjY2IJVKsXfvXtp4AOlilXWeWYEcjUbp/ePxOJxOJ3Jycsi6Y2pqCnw+HzweD2KxGOXl5UQdEYlElLjEYjHa29tx5coVDA4OIh6Pk3cwS5L5+fnYvXs3JQNGmWEUeh6PR3T1tbU1GI1GmuvKyckhxXEg/Vz19/cTxZgtmjKZDN3d3VhaWsL8/DwGBgboeWMd7urqatTX1+PGjRtIJBKIx+OULOrq6tDf349oNIpYLIbh4eE7UpnEYjHkcjmCwSAHVMjLyyPRGHY92e+Z4FtzczMGBgZw/vx5NDQ00CbOarXeFu19qxPWnejKTqeTqG1b56GSyeSOveJ/FnE/BbPf74dAICDmCfMaZ/GZz3wGX/rSl+76Hqyj9CDh9Xpx8uRJ1NXV4Y//+I85v/vc5z5H/5/5jP7FX/zFOwXzIxRMqV4oFKKnp+ctEcVjncJUKgWj0Yjq6uqHwj5hjDmWM202G7xeL4RCIdxuN2pra2nWmFGN2T3PGGcNDQ1QKBQoLS2FxWIh0R0WN2/exMjICIlBBoNBGosB0s8uUzseHh7Gu9/9bnp9W1sb2cm9+OKLiEQi22ZmtwZzEmA5ngkAAsDJkyehUCgIbGbrKwOTE4kEPvShD9F7FRYWYnFxkQpQsVgMjUZD3dG5uTmaZWV0TKVSCavVCpVKBZFIBLvdTvodJSUlaG5uJpXo0dFRziiQWq2m+ycajRIbq6KighS+Wf7et28fLBYLuUWo1Wp0dHRgY2MD4+PjEIvFaSZehlDo6uoqqS9nZWVhenqaxsxYgcfWd2bVx/5/S0sLrl27hqWlJeh0OoyNjSGRSJAyt0wmw6FDh2ifFY/HyWOY7XWYNsr09DQ6OztJY0OtVm9z52Be4uzeYMexa9cubGxsYHZ2FmNjY9QtZnujpaUl7N69m4D5QCCAgoICKpLHx8eJrjw7O4uJiQnS+GAsKyD9zGm1WtjtdoTDYc5+MBQK0b3Icj+LmZkZnDx5EktLS/jBD35AyuIMXBIKhZy9KICfSV6VSCScUS3mdczUxuVyOeV6rVb7SBfMO11jtzpi8Hg8VFZW0u9/UXL9I1cwv1mSyrR3YDOCb0WxHAqFMDw8TMnuoRTLACRPPw2+IRt8gx4+rRbDV6+mvXx/+jyS4+Pw9fZC1NYKQV0dpEcOw3+rS5pKpZC6taAMqFWwDQxgbGAAv/TBDyL7W/8ODA0jVVZGHs5s1mP95k0YkwkYPv85yLu76DgU0zPIWVxEQJ+F4oxie319HWfOnAGPx8OTTz6Jw4cPY2BggNBksViM7OxsWK1W+P1+aDQa+P1+zMzM4NSpUyT2wRY/mUyGkZER2Gw2bGxsIBgMwmKxoL29HYcPH8b6+jpnE726ukoIKBMWEovFNNOl0+kIvUskEuju7sbCwgLm5uboM4qLi1FTU0P046mpKRw5cgQGgwEejwcbGxtkQcHUVZPJJBWDLObm5tDQ0EBiHKlUiha7paUlJJNJ1NbWQq/X49ChQ7Db7XjttdcApO/j8vJymM1m8rljRa7b7QaPx8Pjjz8Or9cLh8OBS5cuQavVQq/XUwKWSCSEujMPXCDdhWYd8/b2dsTjcUxPT0Oj0eDKlStIJBJQKpU0p6VUKhGNRlFQUMDp2meCIExMZHFxEWVlZXA4HJTow+EwDAYDp4BtamqCQCDA2NgYotEoFAoFTCYTgsEgsrOzOTTB0dFR2gDt2bMHIpGIqEyLi4ukOs08H2OxGBVXrKtUU1MDt9tN3o+nTp2Cy+XCa6+9RlYeDQ0NMJvNSCQSGBkZwY0bN3D48GGUlpbetiN1r0IgDysYXZmh4qFQiAQ02AaDUTJjsdgjVTjfD0LP/NbvdI1/+7d/G//lv/yXu75HWVkZ8vLytlmwMCDqzeaRfD4fjh8/DpVKhR//+Mdvek27urrwxS9+EZFI5KEISb0T9x9MhGlubg65ubkIhUJvSbGcSCRIT0IsFiM3N/eh7CmUSiVOnTqFYDAIvV6P/v5+hEIhElJcXV2ldbajowOLi4skksQcFaLRKIlhPfnkk6itrcXq6iq8Xi8BvSzXu1wuiEQilJWVcWiQmd3RTHA4FovhRz/6EcLhMHbv3o0TJ06QNR+QzmEmk4ncF5h3s9PpRCAQQHd3N8bGxuj9BQIB2RMB6dGshYUFlJSUYM+ePZidnYXJZOJ8/vnz5xGPx6FSqVBQUACTyUSFmEaj4czzGgwGlJSU4OrVq7h58ybl+sLCQoyPjyMYDJJOSVVVFRYXF+F0OgmYbm1tpdlLl8uFs2fPUsE6MTGBkydPYnV1lTzpI5EImpqaYLVa4fV6UVJSQvY79fX1pAgNpMfBlpeXiZlntVqxsrJCxXpHRwdEIhEcDgeuXbtGxRPL6alUikaWgDTlO5NB5vF40NDQAKlUirm5OYhEIkxNTcHpdCIrK4v2WyUlJVhfX0dFRQUCgQCB4Vu73EB6H8K6sJkK8YlEAoWFhbQ/yMnJgcFgwOrqKtbW1qBUKqHT6dDU1IRUKsVhiq2urlKXV6VSoba2luxDWREuk8nA5/OxsbFBQEpRURGEQiF8Ph8aGxtJXGp8fBzHjh3DM888gzNnziAQCFAharFYEI/HyUu6paUFTz75JIRC4ba1+2FRsu81eDweNBoNNBoNjWoxYGliYoJsS+PxOILB4LYC/+2M++3G380R4xcl1z9yBfPdwufzYWRkhOwdmIfew47NzU1C30pKSnDp0qWH9sDxeDyI96Utjyb7+8lSKNbTDdHEBPhGI2JXexG72gvtq2ch7OhAfHgY0Wd/iDifD0EiAbHXB2g0ENlsiLx+AeF//f8AAJa6Oqxk6dDU0oKamhosLCyg7Rv/CKXNhujffQPIoB3LP/AB7PvKV8CXySHLsDFg6pSMAtfb24tkMgmDwYCWlhYYjUbcuHEDa2tr0Ol0SCaTNC80ODhIthDMN7Grq4s8B9VqNdGqRkdHIZfLsbCwAKFQiPr6eiqWGRpfVVWF0tJSzpwu+775fD46OjqQnZ0Nn89HG4y5uTnMzc3hmWeegdFoxMrKChQKBaRSKY4fP45XXnmFZoSOHTtG5+p2uzlJRS6XQyQSQSKR4PDhw7BYLHj++edJoGX//v0k7sEik6bd1NSESCRCCVkqlXKETWQyGQwGA3JycmA0GrG5uUldapY02SalpaWFQ4XXaDTYu3cvvdfVq1fJK3jrnPHevXuh0+lojs1kMpHNBUOjS0pKoFAoyD+ToYSZ/phMKA14o1PI4/FQUlJCgmYXLlyA0+kkv2oWmSqWdrsd2dnZ0Ol0NKtkNBohFAo54mpqtRrZ2dmoqamhha+wsBBzc3PEVMjOzkZpaSl1a5k4y/T0NFHkmMjJ7eKtoGTvJGQyGQoLC8nr2OPxYHp6Gh6PB5cvX+bYN7zZPNRbHUw/YCfxZpZSrLP1ZtHT0wO3243BwUG0t7cDAM6fP49kMomurq47vs7r9eLYsWOQSCT46U9/ek/q5axT906x/NbH3e7nWCyGsbEx8j0OhUIcsO9hBQPGeTwedu/ejevXr9/WRvJ+Q6fTgc/n49q1a9BqtSgsLMT09DTcbjdEIhF1/YxGIxoaGnDz5k3YbDbquLIZUiBdRPX29gJI54ZUKoWioiICOIF0cWw2m8nHmR1De3s7/H4/Wltb6dimp6ep0FpbW8Ps7CypKdfX16O2thbr6+tYWlqCUCiEUCik4nhubg4WiwUikQhqtRqhUIi61VNTUxAKhRgaGgKQLuSlUil56x45cgRutxtjY2MQiUSIx+MwGAzo6upCKBQi8DaTalxeXk7deBbr6+tYX19HT08PGhoacP36dYhEIlKOlslkZI908OBBKJVK8gjOtFySSCTIzs7G5uYmjhw5goWFBVy+fJkUzQ8ePEhClCwyGXA5OTmUm4D03oF9H+weNxgM0Ol0yMvLI8q53W7nsO48Hg+6u7sRDAapQcHj8dDe3k5r78LCAmm+sLwoFAqh1WpRVlaG6upq6mqaTCYUFxfT/DC7FxobG2l2mGlqJBIJSCQSRCIRXLlyhdhwQBoMYK4njHl48+ZNTExMQKFQcKzIMgs/m80Gg8FAoOn09DREIhEKCwtx6dIl+juhUIjCwkLk5OTQ62tra3H58mUAaapzVlYWWltb6WczMzOorq4m0JldvzuNarzd3dzbeR0vLCzA5XKhr68PUqmU43X8dlpL3k+HGbh7vv9FyfU/NwUz8yksKSlBRUUFeDzeHT2S7zdSqRSJWtTV1aGgoIAWtIc1A5FMJjE5OYn19XW0tbWlvf3GxhDPy4Pm+ecAnw/eT/waBNXV4OdkIz44CKRSmC4qxOSRQyhYWUF3sQnGf/s36AsLEF28VUyKRBiKhJHc2EDghReQVVmJI0eOQDA2jsB3vwfRU09yjoOvVkH5v/542/EplUo4HA5IJBLyAQbSBd/k5CSWl5cRDAZRVlZGHpEFBQXQ6XRUgLH5qrGxMZw+fRpPPPEEuru7idoEAJWVlTQfZTabqVPZ2NiIkpISzM/PU9HFFKnn5ubg8/lQX1+PmpoaSKVSKs6YGiiQXoBjsRj27t0Lp9OJeDyOM2fOwGg0oqenB3NzczCZTJSEkskkrl69Cp/PR0i01WqF2WzG0tIS1Go1h9bldrsxMzMDl8uF9fV1dHd3bzNt93q9qKqqwsrKCqRSKS3qhYWFRF8XCATo6+uD2WwmK6tgMIiGhgbMzc0hLy8Pc3NzCIVCyMrKojmyrQsPS9xisRilpaUwm81IpVIQiUTo6+tDQUEBde3b29tx9OhREiMB0vPp586dA/DGPByQXjgZHYolc0ZfY0wBNnM+OztLm4NMcRQgXZCzzRMTSnvssccwOzsLn8+H6elpHD16lI6nubkZiUQCFosFY2NjVJCXlpaSCj7bDNbV1cFut8Pj8eDq1at45plnUFFRQTPexcXF2+5xFj/rDvPdgs1DMYXt7OzsHc1DvdVxP3NNgUDgoSDntbW1OH78OD72sY/hG9/4BmKxGD75yU/iAx/4ANE0rVYrDh06hG9+85vo7OyE1+vF0aNHEQwG8a1vfQter5eYG9nZ2RAIBHj++edhs9nQ3d0NqVSKs2fP4k//9E/xO7/zOw98zO/E/QdTXpXL5eR7HI1GH2quB94AxvPz81FTUwM+n7/NRvJBg9Gqmf6J3W5HMpnEgQMHkJWVhdOnTyMajSI/P59GhphXMY/HQ21tLXp7eyG4Nb7Fwu12IxQKYX19Hfn5+ejq6kI8HselS5dIVJMFj8cjbZPMyNxUGo1GYnGJxWKsrq7C7/fD4/GgvLwcbrcbNpsNOTk5NGbCRJdaW1vR19eHvr4+HDlyBJ2dnbDZbASAMpAWSBe5L774IpxOJwwGA44fP44zZ86gubkZQLqAO3jwIM6cOYNgMIj8/Hy0tbVBq9UilUpBoVCQMwMLPp+PkpISGAwGJJNJul7t7e1IJpNQqVTEEEwmkxgdHeWMEsnlcgwPD2NlZQVlZWUcFW5mfTg/P4/5+XnI5XJ4vV4UFRUR3d7j8RD4nUktlsvl2L9/P40ZLS0t4cqVK5yRqsbGRszNzUGlUtEMsEqlontdoVBsU5lm0dzcTH7FYrGYtF+WlpbI+nD//v0A0s4em5ubqK2t5QD9mYrkRqMRCwsLxHLQ6XRQqVTQ6XQ0Y5xMJnH27FnKBZmvB0CvYU2M2dlZVFdXQ6FQ0B6ovLycxq6qqqrIZnNhYQHBYBCRSAQmk4lo1qyzWFBQgOLiYiwtLWFhYQF5eXk4evQoVldXsbGxgerq6m33OItHKdezUS0mtFZXV0fWVTMzM4hEIsQ2ZDakP0uw/H5yPQMBHlRb4lHP9Y9cwXy7OcOpqSmsra2RTyELoVDISSIPErFYDKOjo/D5fOjq6iJKaabVxIMWzOFwGCMjI0gmk9i9ezchloofPAv5//sWPAIBdBcvQPmXX0bswkWknE4oPv85RM+/hs32NiAQgM1gQHJ0FIZFC2BegD8/D87qauTwgIIbN7HS3IS8mVm0NLdAcOkyxJ/7LG7m56P+NnLsWyOZTKKwsBB6vR4VFRX4yU9+AiCdxNimXalUoqmpiZI7kEa+TSYTysrKMDk5CZPJRMh5KpXCa6+9BrfbjaysLBiNRiSTSdoMzc/P03sDb8zJJJNJjI+Pk+hE5pxQZWUlFctut5so5ECa1hEOh/HCCy8Q2so2IMzjt62tjf6eLQ6seGZdXbbR5/P5hKqrVCoYjUbU1taSGjKjlQHph511eVl38NSpU5idnSUwoaqqioStmGo1u/aMPl1aWori4mJsbGwgFArBYrEgHA5Dq9UShWdmZoZGEtj5KRQKuFwuRCIRzM3N0bEw5c9kMgmz2UwKnXV1dbh+/Tpef/11Oj69Xk9+yj6fjxZORkdnlk1nz54l391M5B0APZNM9ItR6zc3N4kh4HQ6UV5eTuJhg4ODNKcVCAQwOzuL3NxclJeXEyVxdHQUQqEQPB6PaHznz5+n70cqldLv75Y8M+/3R00Nmd2Pd5uHmpqaglKp5FhXvdWbgftZ/1gCfRjX+N///d/xyU9+EocOHSJxur/5m7+h38diMUxPT1MHamhoiAC5TF9vAEQTFYlE+Nu//Vv81m/9FlKpFCoqKvDVr34VH/vYxx74eN+J+wur1YqJiQmUlpZylG63+sI+SNwOGGfxsED4zH1La2srjWF4vV5YrVZYrVZ0d3fjwIEDmJiYgN/vR1tbG27cuAGRSISlpSWkUikMDw9DIpHQmp95nCwaGhoQCARQXFyMqqoq6hi+2fOqUCjQ1NQEk8mE8fFxKuJ4PB6sVivZw2SKSG5sbECv16Ouro5opZldpbm5OSwsLJDgp9/vR05ODq1jm5ubBD4Hg0FcuXIFgUAAly9fxuOPPw6bzcahkGdnZ9O8ZzKZxEsvvUTaCIzGfeXKFYyNjaG4uJjowECa5sssJoE37MIy8xVTGmfBKNJ8Ph8mk4nAYXZdrly5QpRrNi/OZqkPHToEn8+HF154AUAaKM5UE8/0pWbFp06nw4kTJ2hGf35+Hi6XCyaTCTKZDGKxGJOTk1Q8Zc4hx2Ixssti4qButxsqlQrRaBROpxNWqxVZWVn/P3v/HeVoet4Hoj/EQgYKQKFQqEIlVM6pQ1XnNJ0nMpmULdErUdZKOrLWx5bvtXxXltfyWrJ3Lfv6HNq7tte+ImXOkBxyODM9oXOqru7KOScUCqGQc8b9A/M+g6/TdPf0kE1xnnPmnOnuKnwB3/c+7/M8vwCz2YxEIoGbN29Sfubz+eju7oZGoyEVcRaZTIb8amdmZkgpnQnNsaZSLpdDIpGARCLB2toapFIp6urqMDk5SXl6Z2cHDQ0NNBSZnJzkIChGRkYgFotx4sQJvPfeewBAz3pdXR3pnUxPT1OjgxWdAMjm6HHxIud6oVDIoWpFo1Fqlq+urpJwLJs+f9FUrWcV+GS0gs8bL3Kuf+EK5sKIxWIYHx9HLpdDf3//A9OK55VECzva/f39HOhh4WL7ecLn82F8fBw6nQ6tra2cB1LACsZMBon33kP0z/8CSKfhjcZgff1V1Bw/jl0iEUb/8i9hGhtHJgfgkwXr9t/9NiJCIUwyGfRT06i/fBUlv/U/IfytXwMyGUj+7rfR8F/+K1IAkv/3/wXx0SOPPMf5+XmyHqipqSHOKyvmGKentLSUoFQM4nT79m289NJL2NzcRCAQwLFjx2iRZzAalvj9fj9xVRiflwlAtLS0UId3bW2NJpNNTU00abxx4wb27dsHpVLJ8YxkHso//vGPAYB41kB+gTUYDPjpT39KVgebm5tYXV1FZWUlOjs7qfANBALo6+sDj8cjQQyVSoUjR45Qt7ejo4P4ySz4fD4MBgPa2tqgVqsxNjaGWCyGzs5OtLS0QCwWcxo+Kysr1DHu6enB7Ows8Zmj0SiSySRNAcLhMInDJBIJpNNpKjJZh9fj8UCr1UIqlcJoNFJy0Wq1aG5uxuXLl4n3G4lEUF1dTd1mrVZL3y8TM2F2XUD+XSvsdLN3JJ1Oo7e3F2tra3C73fB4PIhGo9ja2sLq6ipsNhv5RZeXl0Ov1yMYDKK+vp7gcuzcgfw7z6DrHo8Hu3fvhl6vh9/vp+eNPRsbGxv0Z71ej4MHDz4gUsME2hobGzmTeXbfXpSuM4uHQccexYdiHK9MJvOAddXzjmcV/XpeNn9arRbf//73H/nv1dXVnEnH4cOHP9Oe8NSpU7Qp/DJ+/nG/Yj1DXnV1dT2AomE2S583HtUYZ/E8CuZEIoGxsTFkMpkH9i2F0+vV1VVsbGzAbrdjZWUF9fX1qKioQE1NDbxeL8LhMCKRCG2Q2e8KhUKo1Wpks1l0dnZiaGiIXCVcLhed/+7dux95jj6fDx999BEAUOG5urrKsfWsqqqCwWCAVqvlIKzm5uZgMBiwvb2NZDKJl156CcePHwePx6PJL4/Hg0Qiwfr6OtxuNw4fPpynnn2SL0UiEfbv30/5PRaL4e2330Ymk0F5eTm0Wi1SqRTW1tag0WhgNpsRiUQI/SSVSnHkyBEq5AKBAKkoA/lmwNTUFG7dukW2RrOzs0TNmpycJP/n7u5u9Pf34+7du7QJP378OG3+VSoViouL4fP5CHHIEEHt7e0oKyvD2toarFYrWltbsXv3bo6KOZDfY7J8XFVVBZlMhrm5Ody4cQMVFRWwWq0QCATI5XJIp9MIhUKIxWKIx+M0iGACsSxY45QV7uy+ssIzHo+T+rVWq4Xf7yefbqlUivr6egiFQojFYmrcs++/EH1QiGaqqKiAQCBAOBym+z03NweVSkX6LzqdDnK5nCzN6uvrOXS1QjcR9lwlk0kEAgHU1dVhY2ODs6/yeDy4e/cu596fPn36gXc3FAphcnISBoOBIzgFvFgTZhaPgonLZDLIZDKiavn9frL7vN+6SqlUPvdGwLM2xwE8l3z/Iuf6F7ZgZnCp0tJSNDc3P/QLfB7JzW63Y3p6mgP1Lgwejwc+n//Mx8nlcrBarVhYWEBDQwMqKysfOEbyN34DotuD4AOAthj45FgTlhp4l5exOTuLr3/jG9g9Oo7MxgYysRh4eh3k//AfIpvLArEYIjYbuv/qe5D87V+DqKEBYMcoeCFz2U+vgcn163Q6WtjZPWbqnmwSmkgk0NXVhba2NlrUjxw5ArfbTQlPpVLRou5yuXDr1i1sbW2htbUVx44dw+LiIiwWC2ZnZ2nazCaHRqOR1JyDwSD279+PyclJDueX2TqxJH/nzh3o9XoqsD0eD2w2G9xuN/bv34+JiQns7OyAx+OhoqICXV1dcDqdcDqdSKVSuHr1Kn321tYWDhw4gJ6eHsTjcVRXV2N7e5vDmWOwIpbQ2ISd+RoWLmaDg4McqFJxcTFBzgqDQbeA/HRUIpEgEAjQdBfId9hFIhHKy8upoI7H43C5XASdL+Que71e9PX1QSqVcs5fr9dDp9MhEAhQkc6EY2KxGPFDWMHLimWpVIr9+/dDKpVyNn6sMI3H4/joo48gl8tx9OhRvPfee0in05iYmCAYXDqdhs/nQzgcxsDAALxeL27dukWbKyZQxu5VdXU1fD4f0uk0rl27Bq1Wi927d+Pq1ask7LJnzx4q9pkdxdDQECUSnU4HsVhMG4ZQKITTp09/+i588t28aF3nJ+FaPYwPVSiqIpFIONZVz4NK8qxd5y/C/ufL+JsV9/OIH9bweR65/nGN8ed1HL/fj7GxMWi1WsqXhWEwGOgYFRUVRJVhIk5AXqOirKyMqDXpdBptbW2IxWIIh8PIZDKw2WzEW2XqsoXHKizMs9ksxsfHkU6nySqLuTSwQoIVh7lcDkVFRfhbf+tv0f3Zt28fkskkTZr5fD5CoRDxbMfHx7G1tYXi4mKcOHECYrEYWq0WyWQSCwsLkMvlVIzy+Xw0NzdjeXkZm5ubOHr0KD744AMOgkwgEODs2bP43ve+h2w2i7GxMdhsNqJizc/PIxwOY3l5GR0dHUin09jY2EAwGIRer0drayuKi4sJIXfv3j0arLCi+9ChQ9ja2kJjYyMcDge2trboezeZTJS7mBUe24uYzWZkMhlsb2/Tczo0NET3Mp1O4+jRow88F4UbeqFQSAUpE7piz0BdXR35NzNx0kAgQJNvBmUG8vuyiooKVFVVkZ9zJpMh4bf5+XkadDBE18bGBpqbm1FeXg6r1UqcdyCfCw8dOoSioiKOCnthE/r69etEKUgkEnA4HFhcXOSIzLHmt0KhQHd3N4aHh8kLWiAQ0OBEIpFAqVSSC8rg4CCMRiMOHjyIubk5bG9vY3l5Ga+88gpNnMViMYqLizEyMkKwZZ1OB5lMRgrem5ubHModewd+GXM9n88nKlZdXR3i8TiJh1mtVvB4PPp3rVb7XKhaz1owP0xs7W9avJAF88rKClZXV9Hc3IyKiopH/tznSW7ZbBaLi4tkR3O/99f9x3kWXhMzUne5XKTG/LDgVZQjo9OBv72NxFs/RNBggGJnB1qvD165HMWrq0jduInMJwl1/ugRbHV1otdcgVqhEHa7HX0/eAsAkPjgQyj+2Z9A885PkbXbITp0EPM6LarLyiAuEP2anp4mgSyz2Qy5XI6GhgZIpVLii6fTaUgkEhiNRtTX19PLzWwsxGIxTTNNJhMt2lqtlrqpi4uLSKVSmJ+fx9raGs6cOQOZTIatrS1aKCsrK4k/tbS0RB1WphLd3d2N2tpasiryer1wuVxwuVxQq9XYs2cPLl68CJlMRpAVn89HUOXe3l7qxNrtdppwA/kCTSwW49atW+ju7sbU1BQ++OADhMNh4hmLRCLYbDbU1NTQIsw6skqlEnV1dbTxicfj1AkViUTI5XL0bLlcLsTjcUxOTiKZTHJgw4zX6/F44HA4qJhsamoiqI5KpcJ7771HHons2Tx58iRcLhesViskEglWVlbA5/Op4WEymZBKpYi7/PbbbyOZTJIic09PD5RKJX784x8jnU6joqKCrqGuro7jdchUxtn3ywRaQqEQ4vE4Kisrsbq6St7RBoMBPp+PnoOZmRm43W4OB02v1+PAgQMYHR2F0+nEyMgIZDIZKWIGg0EoFApoNBriOGUyGXR1dZE108rKCkwmE0QiEfEGlUolVCoVdnZ2HvDdZBuYX5au86Oi0LqqqqqKfLCfNx/qWTQcwuHwlwXzl/HY2NnZweTkJIxGI1FaHhYsBz+reM9nNcZZfJ7muNVqxfz8POrr61FVVfXQY7BNZTQa5QgYqlQqaqAy/mdhkeVyudDU1AS32w2pVAqHwwG/349IJIKXXnoJTqcTJpMJU1NTiMVi6Ovro9+12WwEVS4uLkZ9fT3UajXOnTuHtbU14s7KZDJIJBLs3buX3nWXy0Ve0iqVChKJBB0dHaR5IZfLqXG5s7ODlZUV3Lt3D3w+H6+88gr279+P9fV1JJNJRKNRmEwmojIxq51QKES8V4vFgt7eXmQyGdTX15OAYygUIlcMBtsuLy+HXC5He3s7TTvr6+thNpuRy+XQ0dHBsaySy+VQKpWYmppCV1cXFAoFbt++Da/XCz6fD6lUCqFQSNBmnU4HgUBAzWMej4e+vj5qtsfjcSpkmW4K26+GQiH4fD4S2ywUW2OUIZ1Oh0QiQQJYFosFHR0dAPL5iSHQCifnBw4cQDQaxebmJng8HoLBIMbHxyGXyyESiWAymRCJRNDZ2YnOzk7cvHkTwWCQUApsL3X16lXY7XbI5XJ67nQ6HVmRAfmCfGdnh0TGeDwePa9OpxN1dXV0/cyOCvhUOPbOnTuorKzknL9EIsHx48cxNzeHxcVFTE5OwmQykX+zzWbjDC14PB42Njawf39eKLe8vBzz8/NQq9XQ6/UEWxaLxfS+abXaB5BmL+qE+WlzqkQiIQh6NpslC1CbzYa5uTkoFArK9c9K1XpWRwyZTPbC3ePnHS9cwby9vY2tra2HwqXuj2eFaSUSCYyPjyOVSqG/v/8zN3XPUpjH43GMjY0BAAYGBh6r2sbP5SD4hEM61tMN66mTKPF6cWxgALX/+7+CVKeD6OABiI4dRdbhxOpAP3ICAaYHB2HcuxcnTpwAX6tD6L//d+C1VwEAwqZGoClfkMVbW5FrbEQ6ncbly5eRSqUIsqJQKKgrxOPxsLS0xOEUHzx4EIuLi3jrrbdQXV2NQ4cO0QKbTqehVqtx4MABjpJ1oUhWZ2cnLaqRSARvvfUW0uk0ysvL8corryCVSkEsFlOXuK6ujhQcq6qqsHv3buRyOVLjNhgM9Nl8Ph/JZBJ8Ph9f+cpXsLa2hvfffx9isRhHjhyBVCqlYgIAFfiMS8SUNK9du0bnXiiIwdS7BwcHEQwGsbS0hGg0CovFgpKSEvJ/5PP5JN7BoERqtZr8p4VCIZxOJ0G+WTC1aYFAQFxt1qCYn5+HVCqlohfIP7esk11fX09WGk6nE1NTU0gkElCpVPD5fLRwKRQK6t7KZDIS0AFATQWXy4WzZ8/ScUQiEVpbWxGNRqkZ4Pf70djYSIqFLDo7O+FyuUjEgp1vMpnErVu3wOfzicedy+Vgs9lQUVGB7e1tmozb7Xbs2rWLOvY8Hg8ajQYNDQ2k5FpaWgqtVgun04lEIoHR0VGaGP/kJz8h38Zz586htrYWyWQSbrcbRUVFEIlEpMrKkgm7Py9i1/nzTIQL+VC5XI5jXbW6ugqRSMRR43xSPtSzin49L0j2l/E3LxKJBCYnJ9HU1PRAQ+v+YBvgp30On6YxDjxbrmcCik6nk4Q8HxV8Pp8z7QTyaxATHYvFYjCZTOjs7MTq6irRcFwuF4RCIQ4ePIiioiLcvXuX+MOMLwzkJ5BMKGp4eBgbGxvo7OyESCQiziwLn89HjV7gU22Qn/70p5DJZHjllVc4GjFSqRR9fX2c/ZJarabrKOSRMnGocDgMsViMr33tazT9ZNaBNTU1mJ+fp8nst771LQAga6P776NUKoXb7cbZs2fhcrkwNjaGUCiEAwcO4MSJE0gkEjCbzXRPi4uLCbJdXV2Nvr4+/PCHP6TPK7SsyuVyOHToED744AMAoPyr1WpRVlaGnZ0d5HI5ogwwkdFYLAaRSIR9+/ahuLgYQqEQyWQSH3zwAYcuaLfbsXv3bni9XrS1tSGVSoHH40Gv10Mmk1GDmUUh/chkMlFhtLKygkQiAavVCpPJREMBZkmYzWYxOjoKgUAAjUZDnOdMJkPCZYVFcS6Xw969e7G5uYnm5mbYbDYS6hobG0MgEKD3rby8HAqFgvZAhc8GG3js27cPer0eOzs7cLvd6Ozs5OgARSIRRCIRlJaW0tQ4k8mgtbUVgUCAiuLS0lKoVCpqCLz++uskTMeGJc3NzTTx9/v9cLlcMJvNSCaThHBjTeIXdcL8MJ/zJw02FFGr1bTnYdPnQqoWuw9PStX6RdOvXuR44Qpmk8n00A7Rw+JZklshZKq3t/cLOY7X68X4+DhKSkrQ0tLyyIcv+t3/iORHH0P4W78Jxz/+I1i8XkRra4BAACG+ANH/7c8gmplBGoDzpz+F9+//ASwWCxr+wT/EVk01apaW0Fhdg/T/9mcQ/fZv4dLAAGJOJwamp2Guq8Pq6irBnbPZLJxOJxWvTLkxHA5jbGwM7e3tEAgEJP7Eglk3APliUiwWo6enB1KpFEqlEgsLC8jlcqisrKTp7/b2Ng4cOAClUomSkhJUV1dDq9Vifn6eim0mwMEmtgxeajQaYbFYYLVaYbFYqFhOJBJ45513yIKCQW5HRkbA5/NRW1tLtg4AyC+QJV0GGSlMwqurqzh06BBkMhnBi9g5NTU1oaamBnw+n2BQExMT5Ifc3d2N69evU5fT7XZjz549VOwbDAYolUpks1nkcjmOh7HBYEAkEoHf70dHRwdmZmYwOjpKU4V9+/ahpKQEYrGYszlcW1ujJMq4/UB+gsC66Kz5IZFISCytubkZXV1d8Hq9xMlmPxMOh6mTzj5vZ2cHqVSKEjubTgiFwgeQFolEAvv378fa2homJiZgsVjg9XoRjUZJETabzcJoNMJut8Pj8RAPS6lUIhgMEuePHT+bzRK8/tVXX0U2m8X29jYhGABwNtgMllhbW4toNEqq4kxNs7m5GTU1NZxOLNv0BYNBaDSaF6Yz+iyF6aOCx+MRH4ptLJj/9dPyoZ4VpvWrkES/jGcLiUSCgwcPPlHTpnDT/aRNnqdtjLPjPA2ajDXGc7ncI+HkQH4QMDY2hsrKSqhUKrIXYmv+jRs3aEp59+5dlJWV4dChQxgdHaUJZ2NjI+bn52lzvLm5iVAohKNHj2JlZYXoOczmkSkoz87OQqVSwePx4NatWzhz5gzS6TSnYATy6wVb66PRKD788EMcP34cAwMDyGQyVDRKpVK0tLRgZmYG29vb6O/vR1FRESorKzkaEwxFxIo/luvVajXMZjPKysoglUpx584djpgUn8/HpUuX4Ha7odFoCD1z69YtzM3Noa2tjVPor66uoqamBmVlZTQFTaVSUKvV1GDe3NzErl27UF5eTr7KbF/X2NiIqqoq6HQ6lJeXY3t7GxsbG/QcnD59mhq+MpmMLI2sVitisRh5d7Nc7/f7ab9YUlKCWCyGdDpN3s6Tk5NwOByIRqNoaWmByWSC3+/nQIgZGo09O6zJ7XA4qEERi8VINIqpyKfTaezbt4/E5QpdTqLRKAmJsRwTi8UwMjKCkpISaLVavPPOO4hGowiHwxxhL/ZMHDhwAG63GzMzM6ipqUFrayuh4oC8RkBtbS0V8kNDQ3QvCm2rCilqjCr3+uuvo7+/H7FYDB9//DEV5DqdjmMtubGxAZ1OB6FQSCJ0rLAuLi7GgQMH4PP5aPosEomQyWQQCoWeuLb4ecSzWDU+LsRiMQmsMktNj8cDp9OJxcVFagDpdDpoNJpH5vNntZD8VUCTvRhPTkHweLwnfqCfRvSrkEv8OMjUw6KQI/pZx9jc3KQFlVkPPPRnE4m8uBcAz8WLWOjugvLUSRwoL8f0v/pzGK9eQ1YmA4RC5NJpXM1kkBwexubGBvQmE/rjcRj+wf+CwOmzQC6HcCiIWE8e9uO+PYitnR3yT2QCHa2trTAajQiHw5xk6XA4MDc3Rx68TICrra0NiUSCo865uLgIs9mMiYkJmgTG43FIpVKywlGpVBwfv42NDczNzdH3qlAooFar8Vd/9Vfo7OxEKBQiC4pgMIj29nZsb2/jwoULaG9vJ0/jQoXl7u5uSsi5XI7Ddy4rK8Po6ChisRgsFgtisRi2t7chEolw/vx5EvBgipkDAwO4ePEiLewvv/wyh4tRWlpK4mdAfuHXaDT42te+hvHxcRJ4YbBnt9sNi8VCi3wsFqPNi9FohNlsxr1797C2toZMJsOZzgP5ApgV2DU1NQRBLvSgZElMq9WitLQUW1tb4PF4KC0tJWXRwcFBpNNpDA0NQS6Xo7S0FIFAADabDXw+n1TEI5EI7t27B7lcjmAwiHg8jnQ6jYWFBVgsFlLgFIlEZH/FoNizs7NQq9XER2c8xGw2i/X1dcjlcmQyGUqowKde2hKJBLFYjAQ/GIfc5XIhl8shlUohEonA4XCQoAiQRwZYLBb6c0dHBz0jrKmya9cuesbtdju6uro4nVhmezIzM4NcLked2F+EZVNhfJF+kUxtlFFDGB/K4/E8wIdiDSkWz1owP27a9mV8GWKx+DMFW4Cn1xJ5lsY48HTN8ccJed4fExMTJIooFApRXFyMXbt2IRQK0VrP7IZYsSMUCqHVamEwGNDT04N79+6RzRwrphwOB1ZWVkhTo66uDslkEnV1dWhpacHGxgYnN/r9frz99tscq0KJRILGxkaYTCYsLy9z9DA2NjYwMzODcDiM0tJSKswMBgNmZmbIQ5fpW3i9XkxPT3MEylpaWvDmm29Cr9ejrq4ON2/eRC6Xw/z8PL7+9a9jenoaY2NjsFqteOmll8Dj8Ygy5ff7UV1dzVHfLaTzKJVKRKNRfPTRRyR8uL6+jkwmg0OHDlFhz2JgYAA/+clPqOjct28fampq6N+rqqpgs9nomWS0sNdffx1LS0sYHR1FIpGATCbDvn37yFqxUJhtdHSUGgR9fX24cOECDSbYxJftC4PBICH6GD3O5XJxniVWLEskEnR2dmJwcBC5XA4lJSUwGo2oqanB5cuXEY/HKed2dHRAKBRSfquqqkImk0EwGKRpMJB//+LxOBX/Wq0W0WgUQqEQcrkckUiERMW8Xi/m5+exuLiISCQCl8tFKC+73Y54PI6KigqC8AMgbRKBQACDwQCr1UpDD2Y3xq7PZrNBp9PhwoULdP8rKysxMDBA98tkMuGrX/0qAODSpUtwuVyc++/z+eiZrKiooOnzzMwMeYqr1WrK9T9vy6bC+CJzPdvLK5VKVFdXk44MG5okk0loNBrK9TKZjOMc8yx6JYWf8Tc1XsiC+UnjSZMb67a63e7Hcok/z3HYMTweD/r6+jjQJ87Pra8jPT0D8YnjKHr9NSQ/voj5xgZEMxncvXwZb7z8Mpo+voicz4dcNoucUAjlf/kvKPK6kQyFkJuYRM1//s8Q1Fkg+KN/hOVXXkZAJEJvYwO6L3wIv1qFlldfxbVPEk46ncb29ja2t7ehVCrR0NCAubk5RKNR8Hg8VFVVQS6Xw+v1kndvMBiE0+mE0WiEWq1Gf38/BgcHAeQTVDwep4QYCATw1ltvobS0FCdOnIBUKkVpaSldbyAQwPDwMDKZDC3yOzs7WF5eJkGNQhsJZnLPNgRzc3NwOp3Ys2cPenp6MDo6imw2i62tLXR3dyOXy2FychIejwe1tbVobm6GUqnEm2++CSBfrLMCjdkwHDt2DNvb2zAajVhZWaFuKJBfoAsLpunpaaytrUEkEqG+vh6pVApLS0t47733oFAoOJuR6elpnD9/nji/zHKB8WsYRLa0tBRisZgm50B+s9Te3k5q3iyRTE5OkrjK/cqPJpMJ+/fvJ7GYXC6HiYkJAHl/R41GQ4iBdDqNsbEx2mxks1lEIhHs2bMHqVQK29vbsFqtEIlEBBEzm800AQbynXx2L1kTJpvNwuv1UlGt0WgQCAQIcscEP1gCZB1+Pp+PRCKB6upqLC4uYmdnBzdu3IBWq8WRI0cI+j0zM8MRGztw4MAj4ZvpdJrOjwmZra2toaGhATabDT6fDw0NDRCLxdDpdFheXsb+/fsJ7ra9vU0iNT9Py6bC+CKT6P1xPx+KWVcxDnghH+pZC2bmpf5lfBmfN54kD3+exjg7BtvAP8kxHiXkCeQLna2tLRiNRtTV1cHn80EqlRK9h9n7sc+MRqNob28nsaxC4SeZTEbTa4VCQd615eXlVPwBIJRVLpdDd3c3TTsZ5LeqqopyeSAQIArP2toatFot9u7dSyrifD4fJSUllJ8DgQAuXboEkUiEV155Bfv27aOJM7vemzdv0vkYjUY4HA6Ch9rtdtoHACCoLLvfbrcbFy5cQFtbG44cOYKLFy8inU5jdXUVbW1tOHr0KK5evQqXywWDwYDW1laUl5fj448/BpAvPgvzcSAQQGdnJ4qLi6HRaOD1euF2u4k2JZfLOTBol8uFwcFB8Hg8lJWVobKyEnfu3MHHH3+MqqoqDhd3YWEB7e3taGlpob9LJBIEfQfy+w2WS7xeL2cf0NHRgWw2i5qaGsTjcXg8Hqyvr2NpaYnsPQvpUzKZDMePH+fsvVhzIxQKobi4GE6nE9lsFul0GisrK2RNBuQbGfv27YNQKITX68W9e/dIgAsArfEM/eXz+eheMpoQa+4XFxcjEolAq9WSq0VpaSk2Nzdx4cIF+v61Wi1xkxlVgMfjkRVnUVERjh49iitXrhAaZP/+/XTOTU1N6OjoeOT7y8RLY7EYurq6kM1mYTAYkEgkMD8/j6qqKtLvEAqFaG5uhkQigcfjIZRVIUXp5z19/nnmeqFQiJKSEpSUlNBaU2hdJRKJ6B6k0+kvIdmPiBeuYH6aeBIOczQaxfj4OPh8/mdyiR8Vn5Womconn89Hf3//I4+RSybhf/V15IJBCL79G4j8/T9A6b/8M1T8h/+AJaEQFaNjSFssyHk8yAEY+dpX4WpsQG8kBKPRCKVSia4beVhq1ulCOBbDQmdeJGK1uRnqvj6sjY0hIRSg1lxLcGW2wEYiEczOziKZTEKtVkOj0TwwTdNoNGTh4/F4MDExAT6fT8qFSqUSFRUV6OzsJCsLIJ9sZmZmMD4+Dh6Ph1deeQVra2twOBxkm5BMJqk45fP5ZE9QXl6OUCgEnU5HBU1nZycpe7pcLly7dg3Nzc2ora1FLBaj4pF5L+ZyOVRXV1Oj4vDhwxgfH6fJtEajgVQqxccff4ze3l5KGix5MmXmzc1NLCwskCAXO99UKsURsGDTT/Z8iEQigpWxxdjv98PhcKClpYXgxxKJBBqNBgcPHsSlS5doulBRUYHa2loOb4l9BkuyBoOBuG2sc3r79m309vYCyBfdY2NjyGazkEqlHGuGwsKbfcfz8/MoLy+HwWDA+vo6FcaVlZWQyWTweDy4du3aA4rSDJbPxFii0SjOnTuHZDKJdDqN999/H0B+ElwIk2f3ua+vD++++y7ZXBT6RUejUTQ1NdEmg6l2A/mGweLiIgYHB7Fv3z7a7GxubmJqagr19fU4fPgwgsEgLBYLhEIhTCYT4vE43n77bQD5TV1PTw+JgPB4PKhUKqhUqgcsm9ikpHDq+izrx5MGox/8IuDhfD4fGo2GlHcL+VAM/riwsEDQvSfhQ/2qwLS+jJ9PfBai7PM2xtkxHpfrM5kMZmdnsbOz85nHuHXrFjY3N6FQKNDf349XXnkFq6ur5CyRTCYfgEVvbGygsbGRaEescE4mk1TAJBIJHDx4EB988AF2dnYe6jnPXDDYRLOxsRGJRIIgvOl0GlKplANvZyrYe/bswfb2NtLpNPh8Pvbv3w+Xy0VIs2QyCavVSqgids82NjZQXFxMlogMVZTJZGhayXRPpFIpiXvt27cPV65cQSqVgs/nw+3bt8mK0W63o7W1lWg9DFrM4NNAfmp8584dEolk0FTmyGEymTgQX+ZJzArkw4cPA8hPs1muUyqVnEZtIaWK6YwUFRUhHo9jbm4OyWQSS0tLKC4uhtFoRCAQAI/Hg0AgwLFjx/D++++TPopEIkF9fT0dq66uDm63m5rryWQSRUVFeO2112C32+F2u8Hj8XDnzh10dXVh7969iMfjWFlZQSgUgkKhgNvt5gwxGPWK5Xqn04n5+Xl0dnYiEolQYVxUVISOjg6C67PJPoNPA3nRVLvdjtXVVUQiERw5cgTxeBxyuRw/+9nPEI1GUV9fz4GLA59acd65cwc2mw3z8/P0HLBcv729jfr6ekxPTxNCE/hUjPWHP/whmpqaCMIdDAYxODgIpVKJ/fv3w2azoaqqCgqFAgMDAwCACxcuwO/3w2q14ty5cwA+Ff2SSqU0fWaWTaxonJmZgVqtplyvUCi+0InpLyrX83g8yOVyyOVyDgec6ZwwYdVUKgWtVvtE1lW/Krn+l7pg/izlTKbAWVZWRqIaz3qcRyVRj8eD8fHxz1T5vD9uGgzwXrqULz5ffRVl//PvobjcBPG+fZD+3u8iveOGs7Ee4PGwPjyC8ldeRg+Pj/Dt24hXVUHwz/5XqGUy8tcrLy+nhLa9vY1wOIyioiLs3bsXt2/fJisJ1rHM5XJU/JWVleH06dMIhUKoqqpCR0cH8R8YXIhxmHZ2dkjoo7i4mArmrq4u6s7xeDy88847yGazUCqV2L17N+LxOJxOJ8FlGhoaSGkzk8kgm81ibW0NqVQKu3bt4hQmTNyAKUNGo1G8//77yGazOHz4MM6dO4dMJsPZvDArBSBfpO3btw9vvvkm0uk0xyaCfX5PTw/ZUCwvL8PtdqO4uBh1dXXEIdva2kJ9fT1cLhcSiQTC4TBEIhFOnjwJjUZDn3fjxg2Ew2FaZJxOJ021zWYzYrEYcaKAfAFqsVgInphKpahQLysrg1KpxOLiIu7evYvq6mqyDmJTeKPRiNbWVgD5wjuVSpHdEAtWLPP5fNTV1WF4eBh8Pp8WueLiYtq8bW9v49ixY6itrYVMJsPk5CQEAgHUajXi8TjKy8sRjUbpnfD7/RCJRBCJRGQpAeQ3VsXFxQgGg/Szy8vLpGbNYOxqtRrNzc2Ynp6GQqGASqWCTCaD1+sllWzgU4Vu9l2wgnlmZgbBYBATExP4yle+whE1icfjEAgEdL+2t7eh0WhQUlLy0CRwv2VTKBSC1+sl+wyZTEZwruc9fWbPw/Owgfq8UciHYpMjlUrF4UOxjvSj+FDRaPRXouv8ZTx7FPr+flY8rkH+PBrjwONVsp9GyLMwkskkPv74Y4jFYnzlK1/B3NwcJBIJDAYD9u/fj83NTeKpMnTXwMAALl++DB6Ph7q6Omg0GlRVVWF2dhZVVVVwu92EqGHrc1dXF1ZXVxEMBlFXV0fqxgqFggool8uFo0ePIhKJoKysDCKRCC6XCyKRiASvxGIxCWOOj49DqVRCIpHQPqisrIzjk33v3j3E43HweDy8/PLL4PP5BIuuqKiAyWSC3W5HJBKBz+ejxudHH32El19+GclkkvjbQD6fbW9v0/d9584dxONxtLW14cyZM/D7/RzxNoFAQLlLrVbjpZdeIt/e9fV1DkoKyO8HmJXS1tYWIeA6OjowPDxMei9dXV0wm80IBAKUg3bt2sVpUExNTXF0QXw+H44ePUpNVj6fj4WFBcrFfD4fTU1NlOuz2SyhwKRSKbq6ujA4OIiVlRUoFAqivrF3ZHZ2FgcOHACQL7SZBgdrUgPg0J8sFgsmJiaQTqdpLS4U0w0EAsQp93q9+Oijj5DL5aBSqRCLxVBcXAw+n0/Hj8fjyGQypM/C9pPhcBhGo5HsNJnWS+G0UiAQ0F6LqWGbzWZq6iSTSdqTsqEN2xeygnltbY0aufX19bTvYb/PLNL8fj9SqRRGRkbQ3d39UNGvQsum+vp6xGIxapZvbGxAIBBQrn8agcwnjV9UwXx/FF5nfX09hoaGoNFoEAqFsLGxQfeJ5fuH8Zt/VfRKXriC+WnhU8CDQjm5XA6rq6tYXV1FS0vLZypwflY8LImygnNpaQlNTU2kzvi44InF0Lz9Y6SnppBJp4BQKG/vs7ICxfw8UvPzWH/7bfgOHURLSwta/+SfwSUUwuJ0oqGzE9H/4/9EksfD1b/1DWTW1rCHz8fhw4cxPT2NTCZDi4pcLidvxqmpKSpMChf2QuhJe3s7nE4nKisrsbW1hdu3b6O4uBjHjx8nz8CSkhJIJBKCidlsNvJqZt64p06dgkKhwPj4OKcgHRsbg9PpBI/Hw969e7G8vIzt7W0MDAxgc3MT5eXlBCUGgPfffx+JRII27Dqdjopri8VCCyyQF5Uwm83Q6/UEc2YCG6yTvr6+jra2NnR3d2N+fh6RSARisRgikQiNjY3Ewert7cXw8DDBkdbW1vDyyy9TYtLr9RgZGaFuKlMALSyWfT4fdXoNBgNSqRTC4TC2t7dJSIXxkZmNh8/ng9/vh9FoBJBPSgwGx6agQB5yzBJ3MpmEQqFAOp2G0WhEKBTC2toaDAYDhoaGOLBCpVIJPp+PVCqFw4cPUwOATXUZ5ykWi2FtbY2EuZgHJJB/x5hVCUsoEokEIpEIlZWV1OkuLi4mX+Xl5WW6DtZZdjqd2NjYoA1MLBZDLBbD+vo6zp49i1gshtHRUWrUsG68x+NBW1sbtre3sbOzA4vFgvX1dUilUlgsFoyMjBDvmk36Z2ZmMDk5idLSUpw9exaXLl2C3+/H8PAwTp069ZnJqnD6XF1dzZk+369C+Tymz+y5eRGSaGGw86qpqQGPxyM+lMfjwfz8PFKpFMe6inGZnlfX2ev14vd///fxs5/9DHw+H2+88Qb+8i//8rEJ+vDhwxz1ewD47d/+bXz3u9+lP29ubuJ3fud3cOXKFSgUCvz6r/86/uW//JcvjCjMl8GNRzWun1djnB3jYXolTyrkWRj79u1DZWUl6SWk02lSVo7FYhgaGoJer0dLSwuEQiGWl5cpRwYCAVo7l5aW4PP5cOrUKUIzVVdXw+12QygUEiVneXmZGpkjIyNU5Oj1evoshqRSq9XI5XLU2D516hSOHz8On8+HyspKGI1GOJ1OiMVi4gAzcSqPx4NsNouzZ89idnaWmuZsT7SysgIA6Ovr4yga8/l8aqAC+fX13r172NzchFwuR0tLC+rq6vDee+8hk8mQBRW7jvn5eUSjUZSUlKCoqAhSqRSBQIAKGp/Ph0AggLW1NTQ1NSEYDJI+hkwmQ2VlJSorK2EwGGgqy+C7AIhXzvZ0IyMjUCgUMJlM5LXMcjSQz8GsEc28iz0eD4m7Xb9+HUVFRXC73eDz+dDpdCQQyjj5AoGAmhPpdJpTjLDcy9BlHo8HlZWV1PRXKBTY2NiAzWbj/J7ZbIbD4UBvby80Gs0DquxarZZodow2UF1dDafTyUG4VVVVwePxYGdnB+FwGCqVCjqdDtFolITDKioqsL6+DofDQe8ny/XxeBwTExMcoddQKITp6Wm88cYbyGQyWFpaoiaUQCBAQ0MDXadYLMb8/DzZVzGO9MLCAjKZDCYnJ3HsE6tUl8uFy5cvQywW49SpUygqKsLy8jIWFxdRVVX1RLZSUqkU5eXlKC8vp+mz1+vlCGSyXP88ps+f1xHji4pcLkcIF0bVYjons7OzUCqVVECrVCrw+fxfmVz/S70zeJhyJlP1DYVCT2RN9aTHKUzUmUwG09PT8Hq92LVrF6dg+szPqqmGoKYax8NhWK3WvHeq3Y6EXAbkgJsActPTcNpsMAkE6LPUouSf/jF4PB4k3/omgssryIjz1xoaGsJoJoP19XUsLi5iz549xJdiE9BCgYzCl5Nt9hUKBe7duwefz4fl5WXEYjGkUim4XC44HA7cvXsXuVwOR48eJbGFxcVF2Gw2aLVaxONxglJNTk4SB5R5Gh4+fBhOpxNbW1uQy+W4efMmgHwXtLq6GlarlYqvgYEBmEwmgs86HA5IpVJUV1fTd1AofGU0GtHT04NIJAKbzYahoSHqUnd3d2PPnj24desWRCIRJBIJGhoaAHxqgTAwMMDx+VYoFJxpB/OL7uvrw9TUFIaHh8naad++fTCbzZxOO5DvtkejUfD5fBw7dgw/+tGPkEgkMDc3RxsF9j0UFxeTwNXKygoJlhQ2eMRiMbq7u6FUKqFQKOj+VVVVoaenB0C+wLpy5QrcbjeWlpY43p51dXWoqKiAXC5HOBxGMpmE0WjEzMwMJBIJ2UAxPvv6+joEAgF8Ph/u3r0LPp9PkOnLly/j5ZdfJtg74155PB6ysigs9hlHKplMUqJlE/T+/n5sbm5SYezz+RCPx3H58mW6T0VFRTh9+jSnENXpdAiHw3j//ffpnTxy5Ah14VlyBj4Vh3G73TTFHx0dRVVV1TPZTNw/fWYojMLpc6EK5dNu3F/Ugpk1JNn9ehwfamVlBd/97ndRVFREXPXPG9/61rdgt9vx8ccfI5VK4dvf/ja+853v4Pvf//5jf++3fuu38Kd/+qf050KIZSaTwdmzZ2E0GnH79m3Y7Xb8nb/zdyASifBnf/Znn/ucv4znH/dDsgsb462trRw+6uc5RmGufxohz/uDrTlVVVXQ6/XQarUoKioiuCtrIC4tLUEmk5GNolQqRVFREVpaWjA7OwsABJdkKtZA/nlubm6GQqGA1WrlwIYLeacej4csjxKJBH2m0WikImpjY4P0RJi3czabpQKUFXcs/y4tLdE0UKPRIBaLkW3X1NQUBAIBR6iRTe/Y73R3d6OyspKm4JFIBOvr6+jo6KAJYTwep8mzSqUi8TaXy4VLly4hkUggl8uhvLwcAwMD+OCDD5DJZKBSqVBSUoKDBw/ipz/9KYB8EVnoTV24uWfFq9/vR1tbG4qKijA+Po5kMgmRSIRjx47h6NGjKCoq4tg8Li0t0T0fGBjAxsYGkskkVldXEQ6HibIEgODATH8lEAhgaWmJo/fCCtD9+/cjk8lQI0Iul9NUmcfjYW5ujqMSDoB40QaDASUlJVTMy+VyqFQqQhSwKC8vh1gsRiqVgkgkwrvvvkvqyMyWqaSkhJoMrEnqdrsxOzuLTCYDoVDIESzVarVwuVzQ6/VEhUskEuju7sbi4iI2NzdpeONyubC1tcUZ4hw4cIBzjuw8L1y4QM2Dzs5O4t0XogaYBg97r2pra7GxsUHWnE+b7wunz3V1dbTXYc8wE9BkTeJnmT6/KBPm+6NQr6SQqmWxWIiq5fF4MDU1hQ8//BCTk5NIJpMcod9njRc917+QBfOTwrTYZp4luFAohLGxMchkMvT39z83yfbCrnM0GsXY2BiEQiEGBgaeWVFXoVCgubkZABAxGjH1L/8MR/YfgPzSRYTDYciGh1HxP34AnlyO7De/iTuf8EsG/vc/Q///50/gjsfQ/I1vYEOvx/r6OmQyGYaGhgDkX8SSkhI4nU4S6SotLYXRaKQkxhQTfT4fPVwCgYC4rwqFAltbW/Q9LC0tYXl5Gbt27UJDQwMpY6+urhJki3XRg8EgcXYvXryI119/HWVlZbhz5w5H4MvhcNB9jcfjmJycpA7hxYsXkUgk4PP5oFAocPr0abz77ruw2+2ora1Fe3s7KWeyhbqQs7u2tkZFskajwfr6Ong8HiorK7G9vY1cLseBcNvtdly5coUgcFVVVbh48SLZehRuRra2tpBMJjmCRqFQiCau7Dvwer3o6OjA3NwcNBoNbTZ6e3spOW5ublLDgvG4vF4v6urq4PF4aPrQ1NSEZDLJsYlgNk+F3VO5XI7i4mKCeYnFYly/fh21tbUYHx8nYYxMJgOj0ch5R5hFGOOvs+uoqanB2toa2XWwaxQIBAiFQigrK4PJZML169c5m02dTgeDwQC1Wg2HwwG/30/Q6a997WuoqqrC3NwcxsfHEYvFYLfb6fqMRiP27Nnz0CRXaNvB7sWePXsQDodRX1+P0dFR8Hg8dHZ2EmcJABoaGlBfXw8ej8fxqn6WuF+FkjWNPB4PbSiYaqtOp3sizi+7phdNafJxnfCH8aFCoRDeffddOJ1O/Pqv/zr+43/8jzh16hROnTqFrq6up7rvc3Nz+OCDD3Dv3j3a8P77f//vcebMGfzrf/2vH1skyWQyzkSoMD766CPMzs7i4sWLKC0tRVdXF/75P//n+KM/+iP8yZ/8yXO1+/gyHh3PKvL5RTTG7z/Gkwp5flYIhUJq1gL5ta2xsZEa3Wya5ff70dLSAqvVisXFRXR1dQHIvwMWi4XgsTwej3jQDocDfX19WFxchFqtJvGd3t5eXL58GUA+NzFvXDYRFQgEUKlUZKUolUqpePZ6vbh48SKh8/r7+xEMBpFOp2EymZDL5bCzs0MFi1gsRiKRwL1793DmzBniao+Pj9M1s9zBYn5+Hul0GgMDA7h+/TpcLhd5Tp86dQrvvfcevF4vFAoFjh8/Dq1WS89KNpvlINJ8Ph/u3buH6upqqFQqsm6qr69HS0sLdnZ2OAjARCKBn/70p0ilUjAajejt7cXHH3+MxcVFagCziMfjsNvtHMFNJrxVuCl3uVyor6+H2+2GXC6H3+8n+hOb1mUyGbKLunLlCiKRCBYXF9Hb24vFxUW0traCx+ORpzbT/xAIBBAKhQ9oXAgEAtTV1dFEX6PRYGxsDHq9Hg6HA4FAAAaDAeFwmKaCLFhxD+QbyuyZN5vN9HmhUIgGAkxvRiKRYNeuXbh8+TJnL6fX61FZWUkQ6UgkArfbTRz0vXv3orW1Fe+++y4NCNgaKxQKcfr06YeuBel0moplIL/n37VrFzY3N1FXV0f0uaamJjQ0NEAikUCv14PH4+GNN94A8Gk98XnyvUQi4UyfmT3jxsYGTV3Z9PlJOL/Ai1swPy7f329dpVAokM1m8f3vfx+Dg4MYHR3FqVOncPLkSRw8ePCpUHe/DLn+hSyYnyZYgrPb7ZienkZ1dTXq6uqe66aTHcPtdmNiYuK5QL84MTGByv/fXyEikUCn06GsrAytG5tIAYBUCm8gQIvnyuoqhL/5d7E0Oopl6yZaVUq8/vrrWFtbI2gLU9lMJBKQy+UQi8XweDy0iLOiaWdnhxQWo9EofD4fOjs7qVBmnGiNRkOwIYVCAY1GQwmLQVKZ0NL6+jpisRhNCePxOK5evQqbzYaysjLU1dVBpVLBZDLB6/VidnYWwWAQ2WwW4XAYc3NzOHHiBI4ePYq1tTUSIFIoFGRppNfrqVjO5XK4e/cudnZ2SOFZp9NhdXWVJt2FNgperxdqtRozMzO4cOECXn31VUoG7PNYwc++d3YtQH5qW1ZWRkrSd+/eJSskmUyGvr4+gqszOPHs7Cx1YgUCASf5ms1manQwWxE+n4++vj54vV74/X64XC5S5Tx58iS8Xi9qamoITpJIJIjzzOPxaGodCoUwMTGBWCyGubk5KkbZ5HVlZQW7du0iX0rGA5NIJGTDJJPJIBaLqdsdi8VoozA5OYnFxUXweDzU19fTBqqhoQFlZWXIZrMkqFFoF6dWqzE4OAiz2Yza2lqsra0hFArBbrfjyJEjcLlcUCgU+NnPfgYAOHXqFNRqNZLJJAYHBzkboMbGRkQiEdy5cwdCoRBisZi61nq9Hnv37uW8aoWbrue5RohEIhgMBhgMBuKPezweuFwuLC0tPRHnlyXQF61gfhpvaIFAgPPnz+PcuXO4dOkSvvvd72JnZwcffPAB/uIv/gLLy8tPZTU1ODgIjUbDmQ4dP34cfD4fQ0NDeO211x75u9/73vfwV3/1VzAajTh//jz+6T/9p/TsDg4Oor29nTPhOXnyJH7nd34HMzMz6O7ufuJz/DJ+PsE4rawxLpfLMTAw8Fy5hawB/6RCnk8bbNK6ubkJsVgMk8lEasxA/hpHRkaQSqUwMTGBPXv2YG5ujmDZr7zyCnK5HOltpNNpTE9PU44yGAzw+XwYHh6mfCKVSqmJqlarqUDi8XioqKhAMBjE5OQkFRWhUAixWAzhcBgnTpwgVFNJSQlUKhXC4TBxiH0+H01RWSE0Pz8PiURCe6Ty8nKIRCLcvXsXkUiEIOlTU1Nob2/HwYMHMTs7C51OR0JZWq0WoVCIqB4s2Oczu8Ly8nISrNTr9bQHAgCr1YqmpibMzc3h0qVLOHXqFHQ6HVKpFBXvrMCVy+XEIWd5n6G6zGYzcrkcxsbGCKKcy+Vw5MgR+lm1Wo2SkhIYDAaO0GV1dTWHby0SiQiVB+RRVCaTCRUVFbDb7bDZbBgbG0NpaSn279+Pra0tun9APkewvQSfz+c4VywsLFDBz4oAJgYWCAQQCAQIAl4oNtfS0gKz2YxwOIyamhpsbm4ilUpx0Fp2u52e0fb2dmq8VFRUoLy8HHK5HB6PB4uLi0gmk+DxeJTz2SS+paUFVVVVsFqt8Hq9OHz4MOXDy5cvIxKJYNeuXairqyMHlampKULclZeXo6ysDO+99x7S6TRUKhUhFPh8Pnbv3s1511gezeVyyOVyzy2vMmoBa6AlEgm675ubmwS/ZxPqRxVkT5NXf57xpI4YPB4P3d3dZPFaW1uLvr4+fPjhh/jN3/xN/MVf/AW+/vWvP/Fxfxly/S99wczn87GysgKPx0OQoC/iGB6PBzabDc3NzRwY7/OIxD/759AtLSGyvALTX38vX1Dt2gXX3r3ImCtQ8okXYygUQmVlJXGKcrkcpqensbi4iJMnT8LtdiMajUIgEFDxIhAIOAUfg4MxC4lYLAan00lFXmHnlkF5Ojo6MD09jUAggPLycnrJ+Xw+8X1FIhFOnz6Nrq4uXLhwAfF4HLW1tTCbzfjoo48A5Au1b33rW8hmswT/4fF4mJycJBsLlUqFq1evEjSLQa92796N8+fPIx6Pc6YJzKIDyHN1jx07RnAllpzvD6ZWGYvFcPHiRZpQTk1NIRqNIhAIQCQSoaqqingsALB//37q/gJ5m6VCSFI0GoVer8f58+dJaGplZYUmy8zaoDBYcSeVSnH06FG8++67cLlcGB4epsTLuNhjY2M4evQop+Bm4mYMCRAKhTjcNT6fj1gsRhZh7JixWAy5XA7Dw8N0/yQSCRKJBOrq6iAWi0nchMGmgfxkgPkisqmpQCBATU0NeXDX1NRgfHwcZWVlpFZaaGHmcDjg8/lgtVqxe/duxGIxZLNZbGxsoLu7G7W1tdjc3KQCPxgMkiJ44XUz/hLjoKXTac7k/e7du8hmsw+1Nvq8HefHBY/Hg0KhgEKhyFMuHsL5ZY0mxvkFXtyO87NYSgH596+urg6vvfYavvOd7zzT5zgcjgfWdOZPWyhuc39885vfRFVVFUwmEyYnJ/FHf/RHWFhYwI9//GP63MIECoD+/LjP/TJ+cSEQCOD3+7GysvKFNMbZMVKpFG7fvv3UQp5PErOzswiFQsTNPHToEMRiMeRyOYLBIFQqFRobG8myKhAI0Hrudrvx9ttvY//+/ejq6sLa2hosFgsVDUqlkpqhqVSK06Dcu3cvWSC98847yOVyHDisQqEAn89HQ0MD+Hw+ZmdnUVNTA7FYTHsGr9dLjdndu3dj7969uHXrFtbW1lBTUwODwUBw73g8jsbGRqI5ZTIZNDY2ktoyAOL5VlZWoqKiAkNDQ7hx4wYqKipw8OBBtLW1cSDQQF4PhUG1jxw5gmQySRPR+3N9UVERVlZW6P7dvXsXAoEAfX19qKysxObmJtLpNGKxGDVuWa6vq6vD7t276bv3+Xx0bSxisRheffVVslO02WyE7GJ858Ji3+Fw0D5nYGAA4+Pj8Pv9uHbtGjKZDMLhMA0F/H4/SkpK0NDQQM84K7JZscrQYADIHsnlckGpVFJRGwwGadhx7949gixLJBLweDzo9Xqo1Wq6z8zpAsjvb9heoBBJqdFoSGm8s7MTU1NT4PP56OzsxPz8PDUvampqSLOEnaPX6yVerMPhgMVioXNi9zkUCuHDDz+k63U6nXjttdcgFAoRCATo/KLRKNRqNQKBABWqhcUWC/b9f1G5lTU9Cu0ZWfE8OzvL4T4XTp9fxHzPUAzP4sOs0+nwxhtv4I033qDPeZr4Zcj1L2TB/KSQbCZ9HgwG0d/f/4XImjNbI+ZZe/8C/nkjl8sh2tqCoqUl8PbuIehWIBrFB9s2wL6NgfV1MogH8pBexgNJJpNIJpO4cuUKTUkLO4MKhYJTMLNCen19HSMjI1AqlTh//jyAPATI5XLRhv/IkSPEz66uruYUGa+++iru3btHAlJ8Pp/UNl9++WUsLS1ha2uLuq9+vx9KpRLb29soKSkBn8/HxYsXSeXRYrFwit90Os15mJ1OJ1lOAXlVxkAggNLSUhLTCIVCWFpaQltbGzKZDGw2G1wuF4xGI8FpmPrj+++/j1gsxrGNamhoINGTe/fuQaFQoLy8HDdu3ACPx+MkP2ZLwbhJer0eVqsVH3zwAfr6+og7zdRDWYJmGyFWbLKCm01u2VRAKBTSe1BWVgaHw4FoNIp3332XLClYR78QbmY2m7G5uYmioiKOv7TD4cDa2hpKS0tx6tQp/OxnP0M6ncbOzg4V5Oy5sdvtaG5uxsLCAnZ2dtDZ2Un+2Zubm2hvbycla/ZdDQ0NQSgUor29HePj43A6naQ0yp5zhUKB1tZWTExMYH5+HmKxGPfu3ePAq7e3t2GxWFBRUYGOjrxlWnFxMU05WLhcLtjtdkItzM7OIpFIIBAI4LXXXsNbb71FVh8PK5if94T5cXE/55dNn3d2dkjxnImGvWjTZeDZCmbm810o1lH4Gf/4H/9j/Kt/9a8e+xlMuPBZ4jvf+Q79f3t7O8rKynDs2DGsrKzAYrE88+d+Gc83nvR5Z1OySCSCrq6uL6Qxnsvl4HQ6kUql0Nra+kRCnk8brPAQCoXYtWsXqSXfuHEDyWQSy8vLePnll8kqMJPJwOv1EnILyAt5MphqIU+YiT+yEIvFSKfTcLvd+MEPfoBsNoszZ87g5MmTmJ+fp8Yx08ko5CAy2hCQz/ULCwsciDWDKg8MDKChoQFTU1NIJpMkDCYQCOByuUhde3JyEnNzcyTs5PP54PV6SRBTqVTSNTkcDpriAfnczDbTDQ0NmJycRDqdxujoKE6ePIn29nZYrVasra1Bp9OhpKSEeOO5XA5XrlyB3W4nqPW1a9fQ2NhIk8D19XWEw2Hs3buXRDlZsxn4VMyMOTtYLBZsbGzgzp07OHDgAEZGRoizC+Snrk6nE3a7HXa7nQYsTKyUObvIZDL4/X6IxWJqqrP1MhaL4ebNm3A6naQBMjY2BqVSSfnaZDLB6XRSU5xRqkKhEG7dugWxWIyXXnoJ6XQadrsdXq8Xer0ekUiEqFwej4dsplgTh03lmZBoY2Mj5HI5oRMZGqGnpwdut5v2MFqtlvaXuVwOu3btgt1ux40bN8Dn8zEzM8PhHdtsNlgsFhQVFWHfvn1wu91obGzE1NQUB76fTqcxNTWF7u5uqNVq8vfe2trCqVOncO3aNTgcDiwtLaGnp+eBIpQVbj+P3Ho/55dNn71eL6xWK3g8HtG0XsQJM9uLPe153e/DzJAiwN+sXP9CFsxPEj6fD+Pj48Tj+CKK5Wg0itHRUWSzWRQXFz/3YpktBM6XTsDV2QGVWo1z6XR+QfT5gE9e8PjIKPBJwZzNZrG4uAitVotDhw5hZGQEsViMungAVwGbTbMymQx51NrtdqyvrxP82Ol0YnBwELlcDhaLBV1dXQ+o0jGIDZCfUN69e5e8CplS8YULF4g7ypLrzs4OXn/9dUxOTmJ6ehoXL17EmTNnOJwkxt9i587URJVKJfFomAI4s+hgKtxtbW04fvw4Lly4QMIWMpkMTU1N1HkuKSnhTHYzmQyKiooQi8VIzISJZASDQfJnFgqFOHnyJE6fPg2RSEQwcCAPDWOT146ODsTjcWxsbCAajWJjYwOZTIYWH4FAgOLiYmxubpI/pdPpRHFxMeRyOW0UeDwezp07R4kql8tBJBLhwIEDWFpaokkCayqwzVchvzocDuPQoUP0s6zwZs9EMBiESCRCcXExdnZ2oNFoUFFRAY1GA4fDQWiNwcFBuj6Px0MwK/adsyKZBfv+rFYrcbMlEgnKysrIQzQej+PNN99EaWkpDhw4gBs3bgAAxyucCc/odDrU1tZCKpXi2rVrxDmur6+nyQifz8fw8DAH4raxsYGWlhZ0dnZibW3tgYk+i1+kB+Kjps8bGxtIpVIYHx+njnQhT+4XFc9SMLOJQeE7Uxj/4B/8A/zGb/zGYz+jtrYWRqORI1wI5NdNr9f7SM7Sw2LPnj0A8k1Bi8UCo9HIoWoAn75HT/O5X8YXH4lEAuPj40gkEkR7eN7BhDw9Hg94PN5zL5ZzuRzW1tZgs9loLQ6Hw8QrZetXIV8TAK0J58+fx8bGBhwOBwdOyyx/mD2R0WiEz+fDnj17oNFoMD8/T9M8IK/tsbGxQa4Pu3bteuj9LJysfvDBB6ScG4/H0d7ejkuXLiGbzaKzs5NQaVarFa+88gpKSkpw/fp1DA4OIpFI0GQbAEFtC0Mmk1HBrFAoOFPCu3fvkgVjcXExzp49i2g0iuXlZVRWVtJkk+WEXC7H+f1UKsVZQ3k8HsRiMVwuF9LpNLkdMLus8+fPE+2LRSAQINRaZWUl6uvrKQdvbm5y7BuBvMI0y52sUE+lUg/sUQ8ePEicZoae6u7uRlFREdGR2HHcbjft11iEw2G0trYiGo1ifn4e2WwWQqEQarWacnYmk0FJSQnsdjuUSiXMZjMqKiogFosxOjqKdDqNDz/8EGKxGKFQCB6Ph/y3+Xw+PRu3b9/m+DwD+X1gX18fRCIRstksJBIJ+vr64HQ6IRAI8Pbbb4PP5+PUqVP46KOPkEgkSA+IFevDw8OU68xmM5aWloj+xdS+2V5sZWUFVquVGhNMSb65uRnRaJSeh/vji54wPy4eNX22Wq3IZrOYmZlBSUkJKU7/ohvmhXvWp4nH2Ur9Tcr1v3QFc6FqZUNDAxwOxxP7OD5NMKsKk8kEhULx3GF6rBgXi8XQ6XRwOp0IBAIEXz58+DAOer2ILC6j4bc/7aDMzc1hcnISAMjyaWlpCQaDAXw+H9XV1chkMlQwNTY20nRudHQUpaWlKC8vRzKZxNraGpRKJQfiHI1G8dFHH2HPnj0PteMKBAIkHsWsh9rb22kTwFRzWZSUlJCHL4uPP/4YnZVVOHTwIG7eukUwKB6Ph9bWVkxPT2NnZwdGoxHFxcWwWq1wOBxQqVTwer0cy6pYLIZoNIrz588jFArB5XJhe3sbTU1NaG9vJz/lwuv72c9+hkwmQ0rTH374IbxeL+LxOEGVgfzicf36dVRUVJBtVSaTQS6X40ybt7a2sHfvXgSDQfD5fNhsNohEItTV1aG0tBRqtRoSiYQgW3fu3KGF6dixYxCJROSJKRKJIJfLKWkwTmt9fT0d/969e8jlcmhtbaVuOwsG69u/fz9mZmao+9ve3g6v14vq6mrOZH1rawvpdBpyuRwnT56E1Wol9dGSkhJKvEB+Y3PgwAHcvXuXA9OuqKhAPB5HMplEeXk53aNYLEa+jpWVlfD7/cjlcnA4HGT9BOQ3DqFQCCKRCCUlJQT9Y36/bDOpUqnQ0dEBiUQCjUbDQSSwrnM4HMbW1hZaWlo4G7X743lymj5PFE6f9Xo9lpaWoNVq4Xa7sby8TNNnrVaL4uLiX4gNxbNCtAA8spHJrvmzor+/H36/HyMjIzR1u3z5MrLZLCXGJwnWwGMqrP39/fgX/+JfwOVy0abw448/hkqleuxz82X8fIM1xtlU5v7i5HlEoZBnb28vNY+f1/rAinGfzweLxUJ7CaZ/sWfPHuzatQvT09McX9loNEpNRb/fj56eHhI1VavVKC8vh8FgoD0DWxMTiQRu3bqF/v5+aDQalJaW0tS2rq6OcgKbbNfV1VFDujCSySTu3LlD67/X60V5eTkJf7FzZMGsngrXisnJSbhcLuzZs4fsAwFQMSYUCrG1tYVoNErXt7q6ioqKCuRyOSqWARAias+ePejq6oLb7cbo6Ciqq6uxd+9eLC4uorS0lNPgY8314uJisrRkfHCJRMJB4zEHBb1eD4lEgqKiIhLMYlxlm82GAwcOoKOjA6FQCOFwGAKBAAaDgezGDAYDgsEg5ufnObD3vr4+NDQ0QCAQoLy8HAKBACaT6YFhB/OSDofDmJycRDgchsViIfVtFgy1Z7FYwOPxsLq6SnacZWVlUKlU0Gg0ZMnJuP9AnsNpMpmI+lRZWYnZ2VmIRCKk02nkcjn09/eTNzNrzjMRza2tLdTV1UGhUBCN4e7du0in06iqqiLkIwDaF2UyGTQ0NMBgMMDv96OqqooDX+bxeBxBUfYdJ5NJmM1m4u2zJlMul8PMzAz6+/tx9uzZB55fFj/PCfPjonD6XFNTg6tXr8JkMiEQCNB+iq1zOp3uFyI8yZB3T9tcYPakD4u/Sbn+hSyYH/VgP0y1slDh73kE6wSvrKyQSqTdbn8ux0i89x6i/9f/jcxXv4oxQwl4AIzRGErKTVgpKoJOpyPYjtVqReMf/iH9bjqdfuBBzuVypMgbDochFAqxvr4OlUoFg8GA+vp61NbWEoQrl8thZGQEANDa2op9+/bRYssmm1evXgWQ54UWFsyRSATj4+MIBAJoaGiA1Wolz2GbzYajR49icXEROzs7cLlcZI/BCqjKykr691Qqhdl7d2G7dxderRZyuRwHDx6EVCqFVCqF3W4ne4KZmRlqksTjcayvr6O0tBTpdBoGgwFzc3MkXsWaBEC+s8yu3W634/Dhw6ioqEAqlaLvcmNjA83NzTAajVhdXUUmk4FUKiVujFqtRltbG/x+P8bGxhAKhWjxHRgYgFarhdfrhclkQlFREfr7+0mgBch3mgttEpRKJXWKgTynJ5FIoKenB4uLi1hZWSG/v4GBARiNRlJ85PF4qKmpwZUrV+j81Wo1FcvMDiIejxM3iD0jAGijAYDT4VcoFPD7/RCJRCgqKoJSqUQikaAFcNeuXeDxeLhz5w4ikQjGxsboGS20GTpx4gQJpMnlciiVSoTDYTrXQCCA6upqRCIRpFIp5HI5nDhxArlcDtvb25idnYVEIsErr7wChUIBlUqF5eVl2uSxZ/+jjz4iX83CRojFYiEud2EzIx6P49KlS0in0zh27Bh1QV9E/hCbEBRaeTDfUyam8jC/4y86nnXCzJ6pzxPNzc04deoUfuu3fgvf/e53kUql8Hu/93v4xje+QaqZNpsNx44dw3//7/8du3fvxsrKCr7//e/jzJkz0Ol0mJycxB/+4R/i4MGDBPN/6aWX0NLSgr/9t/82/vzP/xwOhwN//Md/jN/93d/93Of8ZXz+uL8xzigtzzPXA3hAyJOtp8w251nD7/djcHCQLG3C4TA0Gg0kEgm0Wi34fD5NOebn53HkyBFCwzCNj/vfuZmZGSpEDAYDVldXafJrNBrR1dWF0dFReDwe6PV6apRbLBb09PSgsbERYrEYJ0+ehMPhwOzsLBVlhQVzJpPBxMQEHA4HQZPdbjfRpBQKBdrb2zE5OYnV1VUMDAwglUrROi2RSNDW1oapqSmk02lsbW3B4XDQ5HLPnj2UM+fm5rC1tQWNRgO73Y5cLger1Qqr1Uo6GNFoFAaDAZubm/jwww/R2tqK5eVlgvdubm7i5ZdfxtDQEPn17tq1C8CnvGafzwebzQaDwYClpSWyPGRuHyqViqhcS0tLuH37Nng8HrLZLMGUZ2ZmUF5eDh6Ph46ODvj9frz77rsA8s2KwlxfmIMKxeqYxdLKygrtaQ4ePIjDhw9DLBZTMWgwGDhe3MXFxdQsYig8pvthNptRVlZGsNb19XW8+uqr4PF4CIVCHJtJVryypvPm5ibBuJuamlBRUYGbN28iFovh9u3b0Gq1yGazdB+z2Sx6e3vR29uLQCCAVCoFk8nEER9zuVxUNHu9Xni9Xpw6dYqg+myPyQp7g8GADz/8EMFgEPX19TCbzYjH47h37x41lwqh3Ewt3uPxcO55LpfD4OAgtre3sWfPHkKJvCgFc2EUuoEwUTnWPNja2sLc3NxD/Y6/6HiWXM9oZo9Ckz1p/DLk+heyYH5YFHaBC1Ur7/dN/DzBINKBQAC7d++mqejzOkbkz/81slYrktYtiP+Pf4319XXYAHT/+/8vdF//Krq6upBKpZBOpznCYh6PBxcuXIBQKMSZM2fQ0dFB0CK2GDJxr2AwCLFYjBMnTlDC7+jooEkr80admZkhlcxYLIaRkRGUlZWhpaUFGxsbHHGrWCyGH/3oR8jlchAIBNi3bx82Nzchl8uRSqVQWVkJHo9HUB2/34/GxkYS+0gmk7DZbAQD5mUysNy4ie1Pklomk8HFixeRSqXQ1NSEnp4eEnaRy+XY3NxEW1sbPv744/x9jEQwMDAAsVhMSaJw6gzkk0Oh6MD09DRmZ2exe/duDqRqcHCQBEsYHKStrQ2dnZ20wMrlco7gFJDfvCiVSpSVlaGoqAgbGxvUqWUCFIVdtZ2dHbK22rdvH6xWK9bX13Hr1i0YjUbY7XbiLAeDQUxPT6OtrY26jMlkkkTWAJBgR3FxMWKxGBoaGjA3NwexWEyNDovFQglxaWkJDQ0N5L3N5/MhFotx9OhReDweGAwGjs8pE3NzOBx45ZVXoNFo4Pf7IZPJUFpaSvztTCZDfuLz8/NwOp0oLS2FXq9Hd3c3rl+/DiD/bm1sbFDinZubI9EuNnVghTS7X+xcBAIBjh49inA4TN9DLBaDQqEAj8dDSUkJysvL6Z0pTCxut5tgbA6HA3V1dQC+WNGvZ437i3ihUAi9Xk9cvPv9jhk6RafTfaHT52fhWoXDYcjl8ueySfne976H3/u938OxY8fA5/Pxxhtv4N/9u39H/55KpbCwsEDTLrFYjIsXL+Lf/tt/i0gkArPZjDfeeAN//Md/TL8jEAjw7rvv4nd+53dI/+LXf/3XOV6OX8YXHw97Ph5l53S/D/PniVwuh/X1dSwvL3OEPNk79LSCNffHwsICXC4XXC4XiR85nU4sLCxAp9OhoaEBOp0OVquVI+KYTqfxzjvvIBwO4/Dhw9i3bx9ZFr3//vsAuOJei4uLOHv2LE13mpqa4PF40N/fj3feeQfZbJaoSUqlEuXl5RgeHgaPx0NzczNGRkZQWVnJmaj/5Cc/oUKtt7cX4XAYYrEYAoGAChTGB2Zq242NjcTNZXScwmDfG7OEYs2E48ePIxaLobS0lHQ9zGYz5ufnSdm5qakJ3d3ddB1sis6C7dPYd2a323HhwgU0NTWhv78fV65cAZDnfg8MDKC0tBQ+nw+BQAAlJSU4ceIEZ30bHx8njRAgv0lXq9VobGyEWq2G3W5HMBhEdXU1LBYL3G43Z7/E+NVA3jFCq9Xizp07WFhYQDabpb0Hi5GREfT09NB1ZDIZjrUjkH9PGHe6uroadrsdiUSCeOdMjTmZTJJdFWuQFBUVIZVKobe3l6xDlUol7WnT6TShDsrKylBdXY25uTmy6nG73WQdxiy7ioqKMDY2BolEApPJhL1795IjRzKZRCAQIAG0xcVFdHR0kF84C4YcY0KrQH7vePToUSQSCczMzFDBbLfbIRQKIRQK0dLSQirphU2tTCZD03rWSAA+zfUvYsHMnjsej0dDGuYMU+h3zGxQWbP8i2rqPiuv+nGQ7KeJFz3X/1IUzIXwaCbWwIJ17z5vsOmZWCymYozF8yiYM5kM/EcOoejtn0Lyzb8Fk8mE9fV1CGMxjH3ldSCTQfXFi+g+fBijo6PY3NykjjObomcyGVKgPnToECV3Ho+H4uJiEvzo7e2lhWR2dhb37t2DSCTC17/+deh0OmxtbdG1CoVCzMzMYHt7G9vb2zhz5gwWFhZw69YtqFQqFBcXY2xsjMMD2djYIM6qWq3G+Pg4pqenYTAYsLW1BalUitnZWdTV1UEoFOL69evY2dmBXC7Pw+g3N5Hdvw/7B/bBplRwRB5cLhdWVlaQSqXgdrtx6NAhFBUVQavVoqmpCfPz87ShOn36NHbv3o2JiQniNJWUlMBkMlHyKfTqY/eDiVGEw2Ekk0mEQiHs2rULH3zwATKZDEG6JRIJwX6Y31xlZSVWV1cRCARQVlaGxcVFjkBFQ0MDJfTZ2VnqchVOlgOBAPSf+GcrFAr6rpiCYjAYxOzsLHGfSktLSSRLrVYjGo2ipKQEExMTUCqV8Pl8BNMvnKCbTCYMDAzg1q1b9Iwzrmw2m6WJfSEshfl3snMtKyujjjbwKacOACm7sq48K0zZ5CQQCJAACp/PJ+g9+55jsRikUilZWOn1emxvb8PtdqOuro447FNTU2hsbIRSqURnZyeuXLmCXC5HNhMejwc3b97kwJlYQjEajTStLeQl/jxFv540Hjf1fpjfMRPOWVpaIqXWQu7z84SUPsuE+XnpSmi1Wnz/+99/5L8zQUIWZrMZ165d+8zPraqqoiLky3gx4lGNceD55XpmxeT3+zmNceDTDeznOU4ul6Pz1mg06OjooDUXyBebExMTOH36NILBINbX12EymUi8ieXxsbEx+P1+NDQ0cMSezGYzKTY3NzfTe+bz+fDee+8hk8kgm83itddeg9frxdWrV5HL5SCTyWC1Wkml2mQyQSQSkU1Ta2srCWCxiMViVOTo9Xq4XC689dZbpDLL4/Hg8XhQUlICmUyG+fl5jI+Pg8fjoaGhAS6XC5lMhiymrFYrIZQCgQAJW83Pz+PVV19FfX09FQQ7OzvIZrOYn59HZ2cnjh07hqGhIVitVuh0OkJwsSl4f38/rl+/TnlodHQUL7/8Mmpra+maV1ZW0Nvbi6GhIRIKZecPfNq8lUgkMJvNcLvd8Pl8UKlUcLvdHIj1+vo6RCIRAoEA7t69S8KsiUSCGsMsl7GCjT0XPB4PBoMBXq8XNpuN9ESYi0Q8HqfmrlAohN/vJwHRwoKbTZ0lEgnOnz+PH/3oRwDy8GuHw0EwbSDPh96/fz/tN+rr67G5uUnPG7MfY3SwUCiE2dlZ5HI5JBIJKBQKhMNhzM/Po6amBkAewbW6uorV1VV0dXVhenqa7hWLTCaDzc1NVFdXo6KiAv39/RAIBBCLxRgZGUFVVRWqqqqwsbFBlLry8nLSIUmlUlCr1eTEce/ePajVasp1rDErFArR0dFB+zcWL2quBx7Nq77f7zgYDNKzMjc3B4VCQdf/PKfPz+qIEY1Gn0vB/KLn+heyYC70T1tZWcHa2hpaW1sfalz9PLrOOzs7mJiYQEVFBdkqFEahKNGzBPN0DA8MwF5Tg+LiYpyzWFCi08H1s3cxiPwDkJ2ewcQnMHOPxwOfz4eioiKyCGCCX+ycCxM940JVVFRwHlxmQZVKpRCNRokLaTKZkEgkkMlkYDabsba2BoPBQH8H5KFijOfc1dWFra0tNDU1wWAwYH19nWAxLNjvsYm1UChEfX09vYCs8wkAs3o9TJVm+FZXYTabsbq6iuLiYjQ2NtIUMRQK4Sdvvw3weKgAcPjXfg1isRhLS0toamoCj8dDNBqlhBCPx0nEi/35/sYHs4Lau3cvhoaGkE6nsba2BrPZjD179uD27dvwer3Y2NhAY2Mjx06itLQU7e3tZGMUi8U4xTIAzvmsra0hEomAz+dzlJoFAgHBnwKBAHXAe3t7UVZWhrfffpusJZjyM0tabLLAuvJsAg/kId6lpaUckROmvMwUU5mXokwmIx69Xq8nyNv169fB5/MhEonQ1dWF+vp6EuICuJOX6upq+P1+2Gw2snNix4zH4/B6vTCbzQTlYzC4aDRKzRp23g0NDUgkEvjwww/pWbJYLBgfH4dcLkc4HMadO3c436fL5cKBAwfoWfF4PNje3sb8/DwlFL1eTzZYhfHLMGF+XAgEApo+A/nnjnlBrq6uEryPTZ8/D7z08xTML9pG5ct4ceNxjXHg+TSu2ZonEonQ39//wKSGqbs+63Gy2SxmZ2fhcDggFAoRiUTA4/Hwla98BVarFYODgwDy6/fq6ioJeDHhyb1792LXrl3wer1UWDocDhJwYn/u7OxEeXk5B8XE6FlAXvBm165dUCgUeO211xAMBiGVSiGTySgn6HQ6DvqGNV37+vqoKK2oqEBlZSVnYgjkcxsr4Ofn5xGJRHDo0CGOsnQh9UcikcDpdEKj0cDtdlN+YfcDAHFU+Xw+vv71r+Pw4cO4c+cO+RAXoth8Ph85ijCkU2EuZs2HH/zgBzSlTyQScDgcWF9fx7Fjx/Dmm28iHo9jenoaR44cAQAMDQ0hlUpBLBajt7eX+OGF6uOFLi7snvj9foyOjiIcDqO9vZ2eIWaL8/rrryOdTpOYV0NDA3bt2oXbt29TMX+/4BFrVPD5fPj9fjQ1NdEzwSbHhXtiPp+PoqIiJJNJlJaWEv9TLpcjEolga2sLMzMz6OzsJMeNdDoNkUgEs9mMvXv3IhwOU8EMfLqnKy0tRUVFBcbHx6FSqTi0MnbfbTYbOjo6aLrOjguA9iQ8Ho+m8RcuXKD9A0MtsqbCtWvXEI/HOc98d3c36uvrEYvFKNetra1BJBJR8djY2MjRAWDP4oua658kPxZOn2tqah46fWY2lYXDgmeJz+OI8UUIL79o8UIWzEC+wJucnEQkEsHevXsfiY9nieZZIpfLUXfsUQU5O8azJlCv14vx8XEYDAZaZHw+X56PqNVC8+t/B/z/9t+wtbgE4ZkzqC3Rw+PxQKFQUCdRJpNRAqqoqIBMJkNbWxv9ey6XQ3d3Nym+JZNJzM/PQ6fTob6+HhMTExCLxVRI83g8DA0NUeL62te+Rvwtg8GAvr4+WjhZd4sR6W/evImzZ8+SUNPly5fpWhUKBUeUZXh4GNGhu+gNhzFWX4ftTzYHYrEYFosFg4ODCIfDUKvV+OY3v0nnzj4nnU5/qhRus2FzcxOtra2ora3F1tYWRkZGOAtxKBTCvXv3sLCwgHPnzuG9995DLBaDwWBAf38/bty4Aa/Xi3Q6TUrYLJh4hFKpRCqVIn4ygy9ns1malB46dAgul4vuX+EGT6/XY2VlBYODgwiFQpRow+EwmpqaIBAIyN+YdWxZCIVC8Pl8nD17Fl6vF4uLi2Sz5Ha7ORPaUChEHUf2u8xirXARHh4epmKb3adcLkdwPFZMs88E8gtgWVkZ1Go13nzzTVqAeTwe+vr6sLCwQNAsBu1iSR/Id6qZmApTnQXyojBHjhwhWBkT+ABA3pqskNdoNNBqtWhtbUVdXR1u3bpFqAb23dhsNg4HTaVScaavHo+HLDDuF9N4UbvOzwqrlslkkMlkdP2M+7y8vEzTZ3YPnraQZZ7pTxO/Kgn0y/h8wdajz2qMA5+/YP6sgvzzHicej5MgZm1tLcFJPR4PamtryVN3ZGQEer0eZWVlkEqlEIlEVFxGo1E0NzdjeHiYeLGNjY0cugrjKwMguk02m4XFYiHfYVZMAvnilok9nTt3Dj09PbDZbMhmszh69Ci2trbgdrspHzKrKqfTCYlEgl27diGXy+Htt9+mc2BWjixsNhvef/99sn5i11NUVASVSgW73Y7l5WUAwBtvvEHwa5vNhvX1dU5xxQYDNTU1OHfuHKxWK4aHh4n7zYrAwcFB8Hg8vPrqq5icnMTKygokEgn2798Pt9tNe5bh4WEOhHtpaQk1NTWoqqrC1tYWKisribIml8vh9/uRTCaxvr6OgYEBQrytra2hpKQEHR0dyOVyMBqNiMViZNHIGusejwctLS2IxWKE3pJIJEilUrTusty3Z88e1NTUwO12Y3p6Gmq1GhqNhjMZTiaTHGVl1pC+v1k/NzdHv8OGLbFYDDU1NZifn0c6naZcHo/HadAkl8vR1NSEd999l4YO2WwW7e3tNO1morQstzJqWCqVomfB5/NxUFyHDh0iKl6hEnsymSTnEL/fT5P1trY2GAwGOBwOagwwMc9oNIqtrS1yzqioqIDJZEI6naZmeWGuK0Ravai5/lmL+Punz4XDgoWFBcjlcsr1arX6qY7zRThi/E2KF7JgDgaDGB4ehlwuR39/P2djfX8IhcIHDOufJNLpNCYnJxEKhbBnzx6OUvT98awJlPnuNjY2wmw2k/+dwWDgQM22qqqwAWBjeQnGcAjf+ta3MD09TQJdACjZBAIBeL1eBAIByOVyGI1GtLS0cOTRx8fHMTc3Bx6Ph7q6OkilUiQSCezs7NDCxZJdKpUi0SUgv/H2+XyIRCJobm4mZedCGMTs7CxNpBkHurq6GpWVlZieniarqkwmg7lYDIG5OWwr8pvnrq4utLW1Acgv2uFwmNMlF4vF5AFsMBgQXF6GYGUFLosF169fR2NjI5aXl+n7MBqNeOmll3D58mV6DtjzUgjzvnLlClpaWjA0NAQ+n4+amhosLCxQgbazs4OxsTG0tbVhaGgIFy9eRCaTIW4RSxB8Ph9msxlKpZL401KplJMQmHc1OxfmcSyVSuF0OkkRkVl9nThxAsCnZuoSiQTZbJZ+jglnFN6jZDLJ6fiz5Mfg4MzaiiXQoqIijjelUqmE0WgEn88npEJjYyNcLhdsNhtxgVKpFN1HJqh17tw5/I//8T/ofvB4PBJQAUDWEjMzM4hGo8Q3EYlEuHjxIhKJBDXCCp9Xs9mMs2fP0r368Y9/jHQ6jVgsRtdaVFSEjo4ODA4OkpopC5vNhhs3bkCpVOLUqVMcOFOhmAaDMAmFQuLu+Xw+SKXSB7h3P894Xr6MAoGANgwAONzn+zvyTzJ9fpZC/n5fxi/jy3hYpFIpjI6OfmZjHHh2NFmhkOfjCnIWbGL5NMGEIXU6HU24mCvA/T7wiUSCYLivvvoqstksfvjDHwLI72cYDJblnJs3bxLdyGw2cyZoNpuNprQWiwVarZZoN4wOVOhoEAwGSQU8k8lALpfD4/GgtLQUEokEPp+Po3wdDAbxox/9CCKRCO3t7djY2IDRaER7ezsWFhbg9/upkLs/T+l0Opw6dYoUnJeXl6FQKDjNt6amJvj9fqhUKshkMni9XggEAoyMjJBOA5u8smby0NAQ5+8EAgHlnng8jmvXrmHv3r0Qi8VIpVJUdLEiJZFI4KOPPsKJEyfgcDgwPDxMP8fcHIB8vtJoNOjt7cVbb72FTCaDWCzGEZqSyWSU4wtVtyORCLxeLy5dukTUpe7ubpw5cwZ+v5/DmTcYDESDymaz1HzO5XLUVA+FQlT0sWPkcjl4vV7abxU236uqqtDY2EjWZfX19YhGo4RI0mq16O7uJtg/27cVBrPVvHr1KkKhEBKJxAN7q9bWVpSWluLWrVvg8XhEx+LxeJiamoLVaoVEIiERMrvdjmvXrkEikeD06dNoaWmBQqHAjRs3sL29DalUyskbbW1tiEaj1KBgEY1GiUJ3/PhxahA9DGmlVCrpeRcIBIhEIshkMo/d83/R8bxER3k8Hg0LampqkEqlKNczyzStVksF9Gftb54l17OC+VehQf5CFsxMeY8pOD8unqWYDYfDJFjQ39//mdOTQu+4J+lUMViWy+VCb28vKR8qFAqCkBZG4YSc2f00NDQgHA4jHA5zYNKZTIaKkPr6eo5gBTs/tuAIBAIO32VhYQGTk5OoqKhAX18fZmZmUFtbS4VHOp3GxMQEQVgOHjyI1dVVyGQyqFQqStqskPf7/eT55/F4CALLbLJ4PB5Mc/PY6vpUgXN6ehrxeBx9fX0YGBhAd3c3dZtZTE1NIR6PIxgMoqioCIkC83GmDslCKBQSbIpdcyqVgtPpxMGDB2kCzrwoy8rKqJPZ1NSEVCqFa9eukbDJ6uoq5/Pn5uawf/9+rK6uQqVSEW+0MGkWbjDS6TSpQLJGycWLF8na4n5blOvXr8NisUCv15OKaDqd5vxcoaBZa2srPB4PvF4vOjo6EIvFIBAIyAsTAC5dukQbF/YsNDc3c54NAByVaXYvu7q6CD5dXV0Nq9XKEUC5du0adu/ezfFCBIDdu3fD5XKhtLQUIpGIoEJer5cW6aKiIk6nnyUNtvmx2WykJssWbqYOz+xQ+vr6UFZWhtdffx33h9PppAK5UBSsUEwjkUgQ5J5x6ID8plIkEuHll1/+hdg5AF+ccjebPldUVND02ev1YmVlBbFY7KF8sMJ4lkI+Go2+EB7SX8aLHdlslppgj2uMA8+W6x8l5Pk8j8MacfX19aiqqqL3hyk1F0Zhrmf6GcwPeXNzE5WVlUSbYfoUQF474uzZs7SWsvWYaRWwKT2L5eVlcj/o7e3FrVu3oFAoUFlZSTZTbrebimlma5XNZkkHRK/XU/GYSqUQi8VIiEsul9O6wbxy779vPp8PH330EY4cOYLa2lriTBduyBcXF+H3++H3+1FUVET8awAkGMpCLpfjww8/5PxdUVERVlZW0N/fTxPSVCpF/rYVFRWoq6tDMplENBrF4uIilpaWIBQKSTiLhcvlQkNDA5qbm5HNZqFWq7GwsACTyQShUIhEIvHAVPfWrVuIxWLQarU4ceIE3nrrLUQiEYTDYaJSsVw+PDyMhoYGlJSUIJlMcvLhw2y6GE97fn4eZrMZOp0OqVQKU1NTdJ9v3rxJhTZ7to1GI/0/mygz/YvCaGpqwvLyMsLhMMxmM3lCs5iYmIBGo6H8zPZWbW1t1Kior6/He++9x6HFsZ9l7wFTGxcIBDR8icViWFtbI64xe/eZK0YgEEBNTQ1KSkoeahkVCATomIXWofcjrXw+H7a3t5FOp3Hjxg3IZDJSlz9y5MhT+/A+r3hezfH7g9HySktLkcvlEA6H4fF44HA4sLi4CJlMRsJhGo3mgXN4lglzNBp9Lo4YvwzxQhbMer3+iRIb8PTJzeVyYXJyEmazmSBSnxWFQiCfNY1JJBIYGxtDNptFf3//A8Xgw+LAgQO4fPky2RUkk0n8+Mc/pgUhFouRqIFOp6NFtauri85tbGwMk5OTUKlUeOWVV8Dj8bCzs4O1tTVSRI7H49je3obNZsPLL7+MkZERTE9Pw2Qy4bXXXsPY2BjxcwUCASYnJ6nrWFZWhpWVFUilUuzduxczMzPkoQjkp56jo6Nwu92QSqWoq6uDw+GAb/8+ZD85X6lUilgshvn5eXR3d2N+fh5WqxXd3d0oKiqCf2kJBokUzc3NmJiYQDabpXvA5/MhlUpJPVsqlZJydGEwa6PR0VFYLBYcPHiQIFmxWIzQBAsLC2RDVVpait27d6O0tJSgXAKBAA6HA7FYDLdu3YLBYCBYG5Dv5jPoEoO3Ma4Rm3Rvbm6io6ODzlWn05H4C+OLMz/H69evk+JoKpVCZ2cnRCIR8VNYI4WdFwCa4JaXl+P111/HxYsXEQwG6VyYnQmQh+VVVFRgaWkJ4XAY3d3dSKfT0Ol0nHeAIQMymQzsdjttXkwmE7a3txGJRB7qSb61tYWBgQHY7XbMzc3RBkCr1UIkEqGpqYn4R263GzqdDqOjo5DJZOjq6iK+1ejoKI4ePQo+n4/y8nKsrq7CZrPhlVdeeegGtDCampqQSCSg0WgeOd0sKipCWVkZwuEwcrkcDAYDNRvYtMtoNEKn01HB/fOKn4fVVeH0uZAP5vV6afpcqMbJhJa+nDB/GV9EMAuiJwmhUPhUjevHCXk+LliD/LMim81iYWEB29vb6O7upund46K5uRl+v5+Ur0tKSnDlyhXiq+7s7FAhVVlZSRok7e3tVCy7XC58+OGH4PF4eOWVV3D8+HFsbGyQtQ+bWrICmnka2+12jI+P48SJE1hZWaHCHMijmNg5lJSUwGazIZPJoKOjA4lEAul0Gj6fj+672+0m7Qxm6ZdKpSjfsFzPbCYFAgHGx8dRW1sLs9lMOaSmpgZWqxWpVIpTPJaUlGBnZwcqlYpypEaj4eRg4FOROOY+MTU1hZ2dHWQyGdTX16OiogJerxcXLlxALpeDSCTCgQMHCBHmcrnI2jCbzeL69evo6enB6OgoFhcXSSxNIpEgEokgkUjQcCCbzdI983q9yGazKC8vh9VqRWlpKaLRKMLhMCoqKuD3+9Hc3Ez7pEgkQnoelZWVBGs2m830valUKuKlMwEvsVhMEHQGxWcaH6yRsLOzg62tLSSTSUJVMMHQwqZULBajPLi1tUXFbuFEfnNzkz6XNclXV1fx+uuvk9d0ofCYSCRCfX09WlpaIBQKYTKZUFxcTMrGFouFtF3GxsZIM8hsNmNjYwORSARqtRpvvPHGY9+j0tJSGngUKpQXBtP5YFo37e3tVCwD+cFMKBSCTqd7aPH4RcbPI9fzeDwolUoolUpUV1cjlUoRVY09V4XcZ4lE8gt3xHjR44UsmJ8mnhSmVciTamtr40wIn+QYwGdbTQQCAYyOjkKr1aKtre2JN5nMgL6qqgrl5eUP2CaUlJTAYrFgYmICwWAQNTU1iEQiiMfjNMVhk2Smpnf37l0AeUiLQqHA9vY2KisrYbfbUV5eDpfLRdczOjoKr9cLlUqF3bt3E+yKFRJyuZwg4Tdu3MDhw4c5gh7l5eUoLi6mn4nFYvT/wKcehWVlZRgeHiY4Ekt+t2/fpkVXu76Opr4+TqMhEolAJpNRMnY6nUgkEshms9Dr9airq0Mmk+GIVfj9fgwPD6OkpIQWAKbAqFKpqABl3xsTQRsZGUEqlUJ/fz8l3nQ6zYE7sXOorKwkVc2lpSV4PB5OQ4VBlV977TUkk0n85Cc/QSaTQUNDA3bv3k0/V8hXYrG4uAiTyUT8Y7lcjlwuh+rqathsNkSjUVqgEokER32zuroa8Xgc5eXl8Pl85J9dqCC6s7ODZDKJ1tZWdHd303Gnpqbo/00mE8G6GeIhm82ivr6emgDT09MAPi3ImY2UXq+nDWpXVxehLIqKiqDRaDA9PU3P7LFjx1BSUgKXywWdTofZ2VlSggRAat7MQuNRsbS0BJvNxoH4PypYx1uj0WBgYABLS0uQyWQQi8UEaSwsLlnx+EXG5+EwP2swPlhFRQWy2Sxxn9fW1sgTnFmFPGmhAjw/m4kv48tgwd6NJ2lcs8b4o4Q8P+s4n9WETyaTGB8fRzKZRH9//xOjKUKhEMRiMSoqKtDW1kaFKAu5XI79+/fj2rVrWFlZQUNDwwN5ZW5ujnL38vIyVlZWEIlEUFJSgp6eHoyMjMBisWBra4u4oix/LS8vY2FhATweD/39/eTUwHK9UCikBrDb7YbRaCQPeCA/wWtoaKBiGQBnsq1WqyGXy9HT04M7d+7QxOvKlSvUmGONaiAPHVYqlYjFYhCLxQgEAtTsB/L7GavVCp/PBz6fj/b2dgSDQXJZAPJTtdHRUfD5fJSWloLP5yMYDGJpaYlyICuSUqkU+WEPDg7C4/Ggt7cXkUiE0FLsXrHficViaGtroz3V1tYWFhYWoFKpOM9JOp3GwYMHkU6nCbWmVCpx+PBh+pl4PE6uFSzn22w2lJaWwmKxkINGIBCA2WymCbpKpUI0GqWGCFuHzWYz1Go1JBIJlEol7ty5g2g0imvXrtHeOBAIIB6Po7i4mDOtZSgwIJ8Huru7YbfbUVNTA6FQiJ2dHZSVlaGiooLDEWaTevb8q9Vq2q9ZLBZUV1fT+dXV1ZHXOZDP/xaLBZOTk9BqtXA6nbhz5w5nvzc1NYWDBw/icWG327G2tgaj0fhElCI+n088aYVCgUQigeLiYvh8PszNzSGdTj9QPH6R8fMomO8PkUgEg8FAekps+ux0OrG4uAipVErq5U9zfqxg/lWIF7JgfppOxZNYTTypgNij4kmsJmw2G1kpFS4YnxV2u50gxQqFAsvLy9ja2kJdXR0kEgkqKiqgVqvxk5/8BMlkEtlslhb22dlZ7N+/H0C+c804VIUw7NXVVUSjUfD5fBw4cIDEPQrhuEyB2+/3U1JgAlfZbBZNTU0Ewy4uLuaIfQB5BcNiux0H//Lfw/qNr2Ou5NNOO5ual5SUQCqV4uWXX0bWbkfqf/wANSYTtgoKVwDIiMQY83gQ+2Qhb2trI3jOrVu3kMlkIJPJOLz1UCgEp9MJtVqN1tZWiEQikpr3er2c721iYgIulwstLS0IhUIQCASoq6ujbjGDMk9OTuLVV1/F9PQ0MpkMqqqq4HK5sLm5SXCgvXv3wul0IhaL0SZAr9ejqKgIAoGAlDf5fD7u3r1LjZ37FyKRSEQKpnq9HgsLC4jFYojFYgSHYrC7W7du0f3fs2cP0uk0KisrYbPZqBiemZlBKpWC3W7H+fPnsb29DYfDAY1GA4FAgHA4TOeytLQErVaL1dVVuFwuSibM11goFOLixYscHtzKygoV2XK5HENDQ8jlchyonEajgdfrRW1tLedZS6fTxKthgmNqtRqVlZUwmUyoqKjA+++/j2w2i2g0SpvXhYUFTsHMYF1SqZTetcXFRaTTaaysrJAlx6OiUDlTJBJxrLVMJhOneFxdXcXMzMxnQpc/b2Sz2c+EpX6Rwefzie8E5DeKXq8Xy8vLWFtbg9Vq5UyfH3euX4p+fRlPGoWqw48LVjCn0+lHbpKfVMjzs47zuFwfDAYxNjYGlUqFnp6eJ26kpdNpUibW6XSYm5vD3bt3UVpaisrKShgMBpSVleHatWuEIrPb7QiFQrh79y6tf21tbbBarRAIBFAqldRsLnQZAIDu7m5sbW0hkUjQ1DqbzRKsmBVuwKcqxswGMBaL0XUVruuxWAxbW1vUEEsmk5x/N5vNqK2tJR0J1sguLS2lpnwhz9ntdtP5l5eXQ6VSkV0jo3yxhgJTMN/Y2IBQKER3dzeqq6vx9ttvA8ivn0x1HMjvyT788EP09fXBbDYjHA6jsrISMpkMiUSCuMJDQ0P42te+hrm5OXi9XphMJuJTb25uIpfLQa/Xw2w2w2q1UlOZrZehUAg9PT203lmt1oeisIBPC/ZkMklIOpaL19fXkclkSHn63r179J3J5XLs2rWLhM/YHs/2iRgqALz++utoaWnB8PAwJBIJysvLsbKyQvoijGcvkUgwPj5OiIiioiJ0dXUhm81ienqaFN7T6TRmZmZw9uxZmM1m1NfX070Oh8P0PiqVSirIzWYzx+UmFotBLpeTendJSQmJjtbX1+PKlSuIx+Mk1sVUs5PJJAcREo/HOXD+9fV10mrZtWvXY3NRYa7n8XhkiQWAoMuRSARut5uKRwZdfhbhrCeJX0TBXBj3T5/T6TShzPx+P65fv85pIDwOKcvWgi8nzL8E8VnJLRwOE/TzswTEHhWPs5oohGV1dXU90XTr/s9mkUwmqTAJh8MQiURwOp1YWFggZWCJRIJkMolUKkViIrFYjEQl2tra8M477wAAR4iJJRMGuWaCYbFYjAquQlgPkE+em5ubsNvtOHv2LCYnJ6HT6VBXV0fCTZubm3lxr3QaVV4vav+f/4am2zexs7OD1dVV4sAsLi5CLpejpKQEut//A2B5GbpzZ+A/fhwVFRUIBoNI2+1ora3FhFqF2CeFIptgso7r+vo6FYxisRh79uzBjRs36Gdu374NjUYDjUaDYDAIjUZD9gRCoRDhcBibm5sIBoPEz3K5XNja2kJPTw9t3oqLiyGVSmG1WhGNRrGxsYGKigqaRlZVVUEgEDxQvAcCAezbtw/ZbBaTk5OQyWTY3t6mTUpRURFnomu1WnH9+nXkcjkIhULO5L5w6szOi50zkId8NzQ0kDgKC4VCAZ/PR1NptiFhlg2tra2Qy+W4dOkSkslk3vLsk646K7oLu+ss2LNXyPthyqzBYBASiQSnTp3C8vIyidN5vV6o1WqUlpZifX0dIyMjSCaTOHLkCN544w0IhUJsb2+TMmssFqPpSUlJCSmGNjQ0IJVKkcjY3bt3sba2hpqaGhIP6+rqwvLy8gO2EoWRTqexs7ODVCr1WM5NYfH4WVYWn9e2icUvOoneH1KpFOXl5WSxxmzk1tfXMTs7C5VKRQU08xBnwbzCv4wv43kFn89/rCDX0wh5Pi4et6ew2+2Ynp5GbW0tamtrn3qTyH6e+QsD+fzDUF+sQcrgrcCnvE4gvy5brVZYLBb09vZyEEGF6JTC5jeQL0bdbjdMJhMJexVaJRmNRrK5On36NKampsDj8Uj0KhAIYHl5GblcjgQYE4kEjh8/jmw2i5WVFVoDh4eHIRQKodfr4fP5sLa2Bh6PB61WC7VaDa1WS0JfSqWSpo8MlWa1WtHX14fh4WEaDvB4PPT09NA5p9NpjI2NYWpqClVVVdjc3IRcLodEIoHf74dcLicrrOHhYTpnn8+HxcVFnD17lpS5pVIp+Hw+wuEwNjY2sLGxgZKSEuzatYu4v8XFxVCr1QTBZt9FRUUFqqqqCP23vb3NWcP37dvH+U6uXr2KcDgMHo+H6elpKpZ9Ph89c8zxghXLQH6qbTabYbfbEY/HKT8rlUr4/X6yaWT3h3Gum5ub0djYiKtXr8Ln8xFqKJPJ0D1h51BozSWTyRAMBjkNJ7lcjsbGRmo0nD59GktLS3C5XPB4POQa0tPTA5fLRRS9lpYWvPbaa6RH8sMf/pAa7Ox85XI5WlpaMDk5SeKnTNNlc3MTg4ODkMvlOHv2LDmNhEIh4sU/LNizyqzdHhVM20WhUHCgy263myOc9Txsm1i8aLleKBSSL7her0dpaSk8Hg9cLheWlpYglUo53OfCteZXSa/kb0TB/ChIttPpxOTkJKqqqlBfX/+5OiAPS6LJZBITExM0bXyWiYrRaMTJkyextrbGKU6EQiGpMHd0dGBra4vD8zly5AhJ+M/Pz1OyYcbwCwsLsFgsxPHh8/nUKWIbC3achoYGbGxsEL+zrKwMer2eEi6TrLdareTPqNfrUVFRQfCtSpUKH/2//ghSsRi7PlHiZHY0+/fvRyqVgnt9He5wGJFsFnIAsw0NiH5iUcC6qk6hEKf37MHs7CzZBgH5xMDgzyxSqRQcDgcOHz6Mjz/+mO6f3+9HWVkZUqkUPB4PlEolJdKioiKIRKIHvsvNzU3EYjG89tprNElbWVkhFW1mK2GxWKhAu3nzJvGZClXHh4eHH+i8sw4dE50qKSmBx+PhmK4zNUggX/Q2NjZiamqK+DoMmjc0NEQNEIfDgVwuRxAihUKBl156CX6/H1qtlrq8AKhw93g8+NrXvgaLxYKlpSXU1tYil8sRZzscDmN7extjY2MEjWMKoGwCwILZkwH5DY9Go0Eul0NLSwtdm1gsxvT0ND1zQH7Sf+LECQiFQk73sqysDE6nE9FolNRXz58/j2w2i2w2S98bO69CaH19fT3q6+vxuBgcHMTW1hZB0J40CqHLj7JtKrSyeJa15hcByX6SYFMPlUqF4uJi1NXVIR6PE8Ryc3MTAoEAWq0WsViMpjmfBaF/kvB6vfj93/99/OxnPwOfz8cbb7yBv/zLv3wk3Ht9fZ0zQSiMN998E1/96lcBPBzF9Nd//df4xje+8bnP+cv44uJRxezTCnk+Lh5WlDP7ps3NTXR2dnJcEZ40hEIhzp49S03fQs4w8641Go3g8Xg0dQPy4pF9fX0A8sU1KzBVKhVaWlpIt4FNpxOJBEpLS2EymWC32+F2u+mzDh8+jLGxMQQCAVRUVMBgMJCyNgDi6DKYtUwmg1arhcFggNPpJC5xKBQisam7d+8iHA5DJpPh/PnzJO7kdrtpOpzL5ajhyJBrbrcbBw8eRFtbG2w2G/1sUVERNRMK7//29jb27dsHn89HaszMgUKv12NnZweRSAQVFRXY3t6GTCZDKpWCQqHgOErEYjH85Cc/wblz5+B0OiGVSrG+vs5Ze5n+S29vL4A8Um96ehpFRUXkr53L5TA5OQmv18tBYBWG3W6HXq9HJpPBxx9/zOFps/8XCATo7e3F5OQkRCIRIdfUajVu3bqFeDyORCKB27dvI5lMgsfjUeOYFeRSqRRisZga35FIhIrR6upqdHR04ObNm9BqtWhubsbMzAyKioqwvb2NTCaDjz76CJWVlQDyiCtmT8ksMIFPXV+A/J6TDXE6Oztx5coVakLv7OxwhFiXl5dhsVigVqvJ9zmZTEIul6OyshIOhwORSAQjIyM4f/48PR/sP5bjI5EIiXnq9XqcOnXqofecxcrKCu7duwc+n/9Uuehh0GW3243t7W3Mz89DoVBQrmeOG08bL3Kul0gk1ECoqqoi2ojH48H8/DwhVFmj4nnplfwy5Pq/EQXzw5Lb8vIy1tfX0d7e/lyU8O5PoqFQCKOjo1Aqldi7d+/nmjAZjUb4fD6EQiEyn2cdm6KiItTV1XFgQLlcDi6Xixa40tJS8Hg8yOVyKBQKeuEBkAgVe/FfffVVTExMkI0Un8/H1NQUTRZLSkrI/qG/vx8zMzMQi8VwOBzEyZ2dnYXdbodMJkNTUxOqq6vzBf3EBFLIL1TsXjE/vexP30HR//ufQNO/F+l/9A+R+q//D0qlMjDWMetsptNpjI+PY2trCxaLBSqVCh6PB01NTXC73Zypay6Xw8TEBNll6XQ6SvRtbW2YmpriJA52r9va2mhyrVQqaeLIkmShsIhMJoNSqaTPKFTJZFCo+yHqVVVVBO9hwSasQF7FmimJF0ZNTQ01PqLRKEZGRpDJZKjrxyBUYrGYilGFQoFQKETnFQ6HcenSJZSVlWFychKNjY3YvXs3/H4/+Hw+ZmZmUFVVhUwmg/X1dWSzWaytrSEej6OqqgqHDx/GO++8g0QiAavVyrHrAPITaKZUvr29TRA4tiilUin09fVBJBLhzJkz4PP5iMfjtKFgk3KPx4PNzU2CbDMImMfjIQ/tZDKJQCBA7xYT/Mlms9i9ezdWV1dRXV39wCbicQmMPT+fR6XyYbZN91tZ6PV6aLVaFBcXP3Fi/KKUMz9vPEz0i0H+ysvLiSbi8Xjwb/7Nv8GPfvQjEqIZHh5GT0/PM1/Xt771Ldjtdnz88cdIpVL49re/je985zv4/ve//9CfZ1OYwvhP/+k/4S/+4i9w+vRpzt//1//6XzmbrkI7uC/j5xdPCskGHp7vn0XI87OOUahXcj+l6/NsDtVqNUwmE/x+P6GTysvLsbOzg1wuh87OTmpUs2v1eDwEQ2d81WQyCYPBAKlUioGBAQCgAiMej2NxcRHHjh3DysoKhoaG6Phut5szJWWQYyaYmM1msbGxQZZMiUQCV69eBY/HQ21tLfbu3YtcLoeLFy8CyGtXsCItGo3SNI/ZJHV2dtLxPB4PnSMLZmekVCqxZ88eOJ1OUvG+XzfEZrORwFdfXx+sVitCoRDMZjOnsGLHi8fjeP311zE2NkaiTul0mnLYzMwMVlZW6Hx4PB4qKysprxcqRrO8nEgkOHsQvV7/AJKB+QvncjlMT09T06IwGE85lUohk8lgZGSEGttFRUWkHn3+/Hn86Ec/Qjab5ShWs3O+cuUKLBYLPB4PSkpK0NbWBqVSCbVajZGREcjlcqhUKoyNjdFU+d69e5BIJBgYGMDg4CBsNhu8Xi/tOQttJO12O2prazlWk8Cn+5ne3l6oVCqcP38eoVAIcrmcY4cK5AdLU1NT2L9/P4RCIbRaLRwOB7a2tnDmzBmMjY1hZmaGxOXY+8Ua5M3NzcjlctBoNPRcPkmuZwOLJxHwe1QUQpdramqQTCbJtolxwAunz0/aqPtlyvVCoRAlJSUEp2eWae+99x7+yT/5J6SY/8EHH+DQoUNPJHT8sPhlyPW83JNmqp9z3C+C9KiIx+O4evUqTp48SQrDExMTiEaj6OnpeW7CMzdu3EBTUxNKSkrgcDgwNTWFmpqaJ7K+epJYXFykxZOpXff391Mx4XA4aJrDLJt+7dd+DbFYjDqpzNS+MGw2GyW33bt3w+PxQCwWQ6PRkFATg8MyiBKQf0mOHDmCjz/+mD6rsrIS+/btw5X33oPjPs8+1nFKp9NobW3F9PQ0UqkUent78x7U//AfYc7pxPxLec9hjdWKpluDmPmt/wnJZJIKYwZNTqVSEIvFEIlEiEQi4PP52LNnDxYWFpBMJimZFnofsim1WCzGV7/6VTidTqytrWFjYwPpdBoymQwHDhzA0NAQQZtZocaiqanpge52YTQ1NZG35tWrV2lRZtd+/PhxjI+PY2dnB0qlEqlUCiqVCkePHoXT6cS1a9c4Czg7ZwBkf8QUSoF8Q6OtrQ0dHR3I5XIk4c/g7tFoFLdv3wYAmoYXXhfbjIpEIrz66qsQiUTg8/lYXV2l3yu8B9/85jextLSEmZkZ1NXVQaVSweVyIRKJwGazAcg3HQQCAWw2G+RyObRaLSkudnR0PLDgvvXWW0gkElAqlejr68Pt27eRzWZx/PhxDA0NEaeacXjPnDmDTCaDlZUV1NTUEKeWRSqVwocffohYLIZDhw6RDVXhUsbgm/cnpWg0is3NTYTDYRiNRhKge17BrCxYAZ1MJp+YCzQ6OkoIjxclcrkcrly5goGBgScWQtnY2MBrr70GlUpFdIGTJ0/iT//0Tx/ZEX5YzM3NoaWlBffu3aMJ2wcffIAzZ85ga2vrifmp3d3d6OnpwX/+z/+Z/o7H4+Htt9/Gq6+++sTn82V8McFy15NEYR7+IhrjQP654/F4aGpqIkqXXC5/IuurJwmPx4Pp6Wk0NjbiypUr4PP52L17N8rKyiCRSBAKhbC+vs4RVTxx4gRHN4DZEhWub+l0Gn/9139Nas0MYllbW4ulpSUolUpYrVYO/5TlmdOnT+Py5cu07xKJRHjttdcwPz/PQQaxfysvL4fH40FjYyMcDgc8Hg9qa2vR1dWFtbU1yi2FUVxcjGg0ColEQkKChfmbcYQBoL+/H0tLSxAIBNRYLrRhYv7EAHDu3Dnyr2brLuM4R6NRUhq/P9c3NjbSxJRFYfOmtLQUer0eCoUCDoeDCkaWZzs783aZExMT4PP5lO+PHTuGbDaLwcFBDl+7MBg9bXt7m/YQfD4fer0eJ06cIGVnsViMra0tZDIZmEwm/OhHP6LfZ3s1pkheGEeOHKH1MR6P0+8VXt+xY8dQVFSE69evQ6VSobOzE8vLyxx0o1AoRHt7OzUqWHNCIBBweNssbt++TZDt/fv3Y2FhATs7OxgYGIDX6yVxTeYrvX//fpSVlWFubg4ajeYBz3Igj2JbWVlBb28vampqHpnr2f+zYPz5eDyObDZLvuTPK5iFJXvmQqEQlEolZ/r8qNpgfX0dkUjksfSxX0SMjY0ROuVJwu/34w/+4A8wPj6ObDYLp9OJI0eO4O///b+Pl1566YmP+8uS61/YCfPTCoEwU/mxsTHI5fJn5is/7jiZTAZLS0tYX19HR0cHcS2eR/D5fPIPzGQyiMfjHA6g0WiE0WiEXC5HKBRCTU0NhoaGsLi4iJqaGggEAiwvL6OlpYVjv2MymdDX14f5+XnYbDaYTCZ4vV4MDg4CyAt2icViEqEYGRlBLpcjf+XCsNlsWLx1C+3/9H+FpqMdyydfAks/DALs9XoxMjKC7u5u3Lp1C2MXLkCzbYf0t7+D6Pvv02cllEpMnz+LcMH0t6WlhbpGS0tL5DkNgBIQu1d9fX3g8Xgcxc3CKfXo6Cgt+nK5HHq9Ht3d3SguLobBYKCCmSVQrVZLgiIMesvErPR6PYLBIJLJJBXTS0tLxGWpqanBnj17yDeSdbqTySTBQtgxjEYj7HY7R7WTRSAQIFEsFtlsFltbW+jo6MD169dhtVppk1FXV4fm5mZ6B3p6enDz5k3w+XzU1NRgaWmJM4F+5513YDAY4HK5CIHA7iXjZfP5fGxtbSEajZIvp1wux8svv4wLFy4QYoElSoZ4YArehcVyIpGASCSCXq+HzWZDeXk51Go16urqCC7INhTMtiqVSmFrawvNzc0Eh0ulUkilUtQB9/l8HP65wWCgJMp8PAsnGawbzePxCBUxPj7+hXR4mZWFXq+nBofH48HOzg6HC/QwK4sXjdcEfNqdfxr4WFVVFTQaDf7wD/8QX/va13Dnzh1cuHDhqSkrg4OD0Gg0lEAB4Pjx4+Dz+RgaGsJrr732mZ8xMjKC8fFx/If/8B8e+Lff/d3fxW/+5m+itrYWf+/v/T18+9vf/pUQLvllDiby+XmFPB8XbBLJJteVlZWfm9JVGGwvMTo6SsVSoTKvUqkkNejC9f4HP/gB2fDdvn0bxcXFOHfuHK0ZQqEQx48fx927dyEQCBCJRFBeXo4rV67QsZldp9lshtfrRTAYhEAg4ECEgXxeHBwcpIlmYbGaSqXA4/EQCoUwPDyMY8eO4fr165ibm4PH40FfXx/Kyso40x8ej0eQ62w2i7q6OhiNRuRyOYyNjSGRSBAaDQB9t0AeLSaVSrG4uEjnwP4NyO9hWNOfx+NBp9OhubmZBMxYwcxyvVAoRGlpKTY3N6HT6VBdXY2lpSUEg0Go1WqyoHQ6nVSss72eQqHAuXPnkEqlIJVK8eabb9I1HTlyhDMdNRgMNM2+PyKRCFKpFIe2xabkyWQSm5ubGBoaovsul8tpXfX7/WhtbcXU1BRisRj+/+y9Z5hc13Uluirnqg5VnXPOGR2QAYIkAOYgkSNpxtLY8hvbkse2PB4/v7E9kj3ykz3WaOSxrWdbGku2OLYkBhEkARIAkTM651TdXZ0q5xzfj8LZrNvdABqNBgVKWN+nj0J3dd1bt+49++y9116rtLQUExMTkEgklDifO3eO9npSqZTuoYaGBlitVkgkEmRlZWFychJerxderxerq6vg8XjUnWPq0an7EYlEArvdjpqaGs56zj5jZmYm9Ho9NBoN8vPz4fV6UV5eDq1WS0UUFktYwau4uJiKD/F4fJ2IFGMBMC0N9joW6xOJBB0/lWnGBF2ZZs12g8fjUZOjrKwM4XCYkuelpSWa22fxPjUfeRhjPXDvVPG0tDRqrPzv//2/MTExgRMnTtwz4/aTEusf2oR5s2Bf7srKCiYnJ1FSUoKKiopt3/jw+XyiGm9ngPb5fBgcHCT6U35+Pux2O4RCIS5evIienh76jD6fDwsLC6ipqeGIezEvQQCcoAMkq4vhcBhyuRzl5eUoLS3FW2+9xXnNzp07MTo6CpvNhueffx4ejwfZ2dkIh8M0S6XX6xGLxTC4tIQn/X6YamsRRTKQKJVKFBQUYHFxETabDWq1mgKNWy7H4s1erDTUo/DJJyGy2xEIBBBLT4cpxU7DYrEQJbqyspITEKVSKeRyOdlDxONxCpAajQYulwt8Pp8q6qxAkHqNfT4fjh8/joyMDGRnZ1NVViqVori4GOFwmGypVlZWsH//fuTk5MDr9SI7OxvT09McEZV4PE7ByWKx4ObNm3A6nTSDxpQgGTweD44fP0704VRqIdsErhXoYt+p2+0myjjwEfvC4/FAo9Fg165dZPcAJCvO8Xgc5eXlaGlpwfXr17G4uEjz04xuzT4HE+tiXd6MjAysrq5SAPb5fIhGo2hsbMTNmzeRnp6Ojo4OzM7OwmQyweVywePx4OzZs3jhhRfg9XoxPDyM2dlZZGRk4MknnyQLtA8//JAKIiwBZt0cgUCAUCjEqTKHQiGiiO/btw+FhYVkJRYIBGg2iQWfVAu41ICaSrtjM1IPOjliYxJsVit1FmgjK4uHMYimMh3uBUwlWygUYvfu3aTmfy8wGo3rZkVTKX2bwXe/+13U1tYSbZXha1/7Gg4ePAi5XI4PPvgAv/7rvw6v14vf/M3fvOfzfIT7w708hywRZEq2210YB5L3utPpxMrKyj1bUN4J8XgcAwMD8Pv9CIfDkMlklMBeuXIFO3fupH1FPB7H1NQUsrKy0NHRQSNZfr+fYrzD4UAoFCLWSiwWg9frhVgshlwuR0dHxzrf4rKyMhL92rdvH/x+P7RaLQQCATo6OuDxeDA5OUniYmw9DYVCEIvFKC0thUwmg0KhwNzcHMRiMSV/QPKZPXfuHK3TZrMZEomEY0MViUQwPj6O8fFx7N27F263m2KdXC6nOMDAuuwsiWLF2aWlJRQXF3Oo02zc5+LFixCLxaioqCD7ID6fj+LiYmg0GgwMDABIzjO3t7ejvLycRrt8Ph/effddTsOGFQ6CwSCuXLlCVo7MXjErK4uSZTavzGjYazvAbM+Smiynnj8TK2PXnZ0nkBQRW1pagkqlQigUonU5Ly8PLS0tRFuPx+Nwu93w+/20LwCSRXxmc8XETdl+JBqNUte0pqYGy8vLlHQqlUqaM7fZbLh06RK0Wi2kUimmpqYwNDQEPp+Po0eP4sUXX4REIiHrKXbfMeTn55NQW6o7BZBM9JeXl1FdXU2Nn46ODszNzXE6xKld5dQCearOCXtdLBb7WAqhYrGYGGLs+rPRs/HxcRLJZDPtD1usBzamZN8NLNbzeDzU1tZy9r2bxScl1n/iE2b2IExOTm5ZjONuYHOwMpls2wM0M6AHkp2Zffv2YWxsDDdv3oTD4UB5eTkF7PHxcczNzWFubg7FxcXYtWsXpqamUF5eTt1vNvsCJG/+N998k7pz+fn5AG5RZYaGoLx6Fdr0DDi9XkpYy8vLSWqfKR4yAaZIJIKKqioo/uavETKbgFuz1CaTCUKhkFSms2MxpLvciGZmQvWvP8LMoYNwB4Mw3rixjhYlk8mgVCopGZRIJBxbLABEqTl48CCuXLnCCQAsoMTjcZSWliIYDOLq1asoLy+HUqlc935MuRlIVsc6OztpdpYhJyeHZmmUSiVmZ2dx/fp18spmARwAzTezGSer1YqioiLk5ORwBKhSvSxZJxRILgqsEsvOITs7m+ODHY1Gcfz4cezatQt6vR5GoxHhcBh1dXVkAQCAZpx9Ph/Ncufm5qK9vR02mw0CgQC1tbWcxB8Azp49S5sKZv8AJMXm3G43dDodIpEILl26hHg8TmILZrMZpaWlWFpaoucjHo/j+PHj9L3Y7Xbo9Xq6FiqViubfq6qqMDAwgGg0ig8//BB79uxZR8ligidAcoNYWFgIPp9Pwmu3w9qAmtp9ZoWgeDxOSpzsbx4kNpoFSrWyAEDP0oOwstgKtpIws892u6Li7//+7+Mb3/jGHd+DsUPuB4FAAK+99hr+8A//cN3vUn/W2toKn8+Hv/iLv3iUMD/kYLZxJSUl29r1TX1/JjrY3d29ZaXtjZBqSaRWq/H444/D7Xbj7bffhsvlwtTUFLFqjEYjdUYzMjJQX19PBba8vDwIBAKyamQ4ffo0VldXIRKJaDSmoaGBxkQEAgGys7Mpidbr9Whra6NnnHXvmOJxWloauru70dvbS51P5j989OhRem8gKbhoMBgQCoXg8XhII2UtSkpKSMuDsZlSE1MW2w8cOICRkRGOqCPzggc+Sk70ej0yMzNRVlYGgUDAmUkOh8Oc89izZw8VgVnizSyPxGIx8vPz4XQ68f7770MgEKCpqQmDg4NUzGaxPnWWNycnB7m5uWhpaaGfmc1mzswyi1+sqM/UrOPxONRqNaqrq9Hb20vnferUKTz55JMQCAQ0L1tdXQ2hUIjTp08jGAwiIyODXs8+o0QiQXd3N1ZWVuBwONDU1ISrV69y9luTk5M0H86K5UztOz09nf7/O++8Q7ot8/PzcLlcUCqVyM3NhdVqhUAgIAFS9n2yWey9e/cSRR1IFrmKi4thNBqJRVleXs7xhGZge6DU/VhVVRWqqqo2up3ouq6N9Sx5ZiwvAJuefd4O8Pl8cmspLy8nMT2WQCcSCchkMpjNZmRkZGyLy8Z2YCuJvM/nuy3b9uct1j8c39IG2Awlm6lUA8nN/YNIli0WCwYHByGRSJCfn7+tyTLbsAPJLiqr0uTn59NCbTabKWHOyckhOxe5XA61Wk1JEgAOz5/ZLrD3T+2yabVaOEbHYBufgOD6DeTeUvjm8XiYmpqCSCQin1wgmQRWVlaitraWAvRBpxN9fX1U7WbWEbOzs5hNJLDz77+L0n//BchtdoSnZ+C+dZ6pizfrsup0OpSVlcFgMCA7OxtisXhdUhcOh5GdnY3nn38eJpMJ09PTMJlMpFDNGACMqmswGHD06FFMTExQIs2uJ4PT6SQ1Rz6fj/LycszPz2NlZQUDAwNED2HdWI/HQ8kyo9s0NDTgwoULREtmx2ZqphKJBH6/n+ZZWFVXIBAgGAySlUXqNTGZTCgqKsIrr7yC119/nYRKvF4vgsEgVZsHBwfR2tpKHdPS0lLodDqoVCoS+WA0Z7/fDx6Px9lA5Ofn01wyE6tIrexPT09j//79CIfDWFlZoftHqVRiYmICNTU1yM/PR1FREaqqqpCWlobR0VH6jtn3e+PGDWJ9ME9mt9uNgoICZGdn49ixY3R910Kj0aCrqwsej4dTDLoXpHafo9EohoeHIRaLkZmZeVs614MOqBtZWVy5coXEaB6ElcVWwCrO95qY+P3+21Kwv/KVr+Dzn//8Hf++rKwMOTk5nOcVAPlFbmZe9Sc/+Qn8fj/+3b/7d3d9bVdXF/7kT/6EPGsf4eECU6n2eDzIycm54wZ6q/D7/ejr60M8Hkd6evq2JssASFOCx+ORlgRTnnc6nbBYLMQyYbaGkUgEWVlZkEql6OrqovdKZWww72lWCE6NRVKpFJmZmcS4YqNdrHA8NzeHoqIiWu+cTie0Wi06Ojpob3HgwAEMDQ3Re7jdblKNZtDpdMjNzaVO8kYz6Wx2ec+ePTAYDODz+aipqYHBYFhHW/b7/XjyySdhtVrJDlOtViMUCiEYDMLj8dDew2KxoKurC0tLSygrK6MZbRbbgOTan+pIwcZ4rFYrzp49i+eee47ei3XLh4aGqCDALCyZajW7vkajEUajkXRHWMLBZozFYjHy8vJINDW1W6ZQKMiK6tVXX8WHH34Io9GIeDyOxcVFEnxLJBKYn5+HTqeDWCxGMBiERqMh0VeDwQC73U7dX8Y4nJ6epuuanZ3NmQVndl1sL7G0tISGhgaIxWKYzWaOPZXJZIJOp0NdXR3dm1KpFGazmeORnUgksLS0BIvFguzsbGg0GvB4PLouL774Il5//XVEIpENYz0A7N27F/Pz81t+vlNjPbsGdrudutNru88b6Zw8CEgkEuTl5SEvL48sR6PRKObm5jA6OgqNRkOxnu3FfxbYaof5dlpRP2+x/qFNmO8Gt9uN/v5+qFQqqhBuJxKJBObm5jA7O4v6+npSsdwuMHEyIKmE6Pf7aYFPS0sjEayRkRGa7ygoKMBnPvMZ8hS+HVjgF4vFRLtiisiRwSF4QyFcVquAQ48hkZmJrsoKvNDUiB/+8IfJpOzUaeyrroagrg7ut97C+cqkB2Q0GkVnZyedY09PD86cOUMCazQjFAzi8q/+CgAgs6MddR+chLmrE16JBGq1GmlqNdwrKwgKhfDcotdlZ2djdXUVq6ur6OnpwYsvvoiBgQESkMjKyqKFbXZ2lgJzKBRCT08PJewMGRkZuHTp0rqHkKGqqorjecy8JJnlFPMszMzMRHV1Nak8M8GPxsZGlJWVobe3F/X19QiFQpifn4dSqSRKvdfr5XRajx49CqVSievXr0MsFqOmpoZo9QBXyCRVAC0ajUKtVqO3txfRaJTmmtgs+tNPP41QKMSZefd6vRgbG4NeryfqM1NKZ9ezu7ubPKw7OzsxMjICqVRKFT+73Y6TJ09ScGMCWbFYDI2NjVSgYp0LvV5P93R9fT0kEgn6+vpQUFCA1dVVXLhwgQouzI5k37592L17N7xe74YJ8erqKnp7e7elChuJRNDX10fMCaaGeyc618cVUEUiESnRsk4Gs3PbLiuLrWArARS4cxBlXfa7oaenB06nE729vdR5+/DDDxGPxznJw+3w3e9+F88+++ymjjUwMID09PRHyfLPAHfbHKYKeWZlZT0Qz0+r1YrBwUHk5eVBpVKtG226H6SKkx06dAhqtRoXL15EIpGAQCBAYWEhWSUxRwSZTIaXX36ZqL+3QywWw8jICBwOB3bv3g2XywWXy4V4PA6v1wuXy0W0WOAjl4iTJ09SvC0oKEBnZydGR0extLQEn8+HxcVFmhsUi8Vob29HOBzG0tISioqKoNPpqFALfDRSxV4PJJOtkpISrKysQCAQwGazIRgMIisri4rETMl6aWmJZlxFIhFZZno8Hoopdrsdhw8fxvj4OEQiEcVGhUJBsS4VLInTarXweDyctd1sNpNSLuucs05oX18fiYdGo1ES4urt7UV2djZyc3NJCM5ut0MikaxLAFtaWlBXV4eRkRHYbDY89thjOHv2LP0+tQjp9XoxMzNDBRWhUIjFxUVKaoVCIQKBAM6fP4/nn38ebrcb2dnZtC5nZGTgww8/JFFYtk9lCbJMJkNXVxfGx8dhNpvR0tJCjMGlpSUEg0FEo1GcPXsWfr8f8Xgc2dnZJGSal5fHUZ/PzMxEIBCgvQP7/cWLFyGRSCCRSPDWW28RxRtIenNnZWVh//79MBgM5CueikAgQEXjrdB6U5FIJDA5OQmz2Ux+2qlMM1ZU+lkUy/l8PkQiEdLS0lBSUoJAIEBMgrm5OYhEIor1TPT348JW4v2diuM/b7H+E5kwr66uYmRkBGVlZSgrK8PFixdv68W8FUSjUYyMjMDpdKKzsxMajQZ2u31D/8etIFV5s7u7m3zpUquydXV16O3t5fjgAcClS5cwPz+P5uZmDg2IwW63o7+/H7m5uXA4HDh79izKysqSweXGTfi/8O8Rlkoh+r//MyLxOLS//muAXI5EPE5ehkGlEt4PTkL4ve8hvrwC2W/9JgJKJVSBIOdYMpmMxKjGPvgAPf/rb3D4v/4xZiNRMBK0t6gQI595FQ4+H7jlAaybnELT938AV3Mzpl96ASqVijPPs7y8jCtXrkCtVmPPnj3Izs4mqvDAwACnI2u1WknURCKR4NOf/jQlkxtRPaRSKWpqamAymZCXl0cPOvMQZh1jJvjB4/GIJqxUKnH06FHyEOzr6yNvarZ54PP5eP755zE/P4/Z2VlOID158iRUKhXsdjv4fD6mpqYgFAohFAqp29zd3Q2v14uRkRHOBoD5XgJAeXk5JiYmiKGQ2gnp7e3FwsICysrKKPhWVVXRAnH16lV4vV7IZDKqRgPA+++/j3A4jH379iE7O5uCe35+PnUWfD4f0biYz7RYLCb2AuuiM99Dl8uFpqYmVFZW4oMPPiDxLkb/Zt7iJSUldP5MGZQFicXFRRLg8fv9W1a9D4VC6Ovrg1wuR2NjI4eGnUrnAnBXMZEHFVDZ/cPj8aBWq6FWq7fVymIr2EoAZQKM9+tQUFtbi8OHD+OLX/wivvOd7yASieBLX/oSXn31VWLTLC8v47HHHsMPfvADKuYByef5/PnzeC9FaJDh2LFjMJlM6O7uhlQqxcmTJ/H1r38dv/u7v3tf5/sI2w+Px8MR8pyZmdm2OAwkN9YLCwuYnp4moSij0bhtx2CMFrfbTdonbE1h3cjS0lIsLCxApVIRAwdIFoYvX74MrVaLo0ePrissBINBUi/Oz8/H6dOnoVAoUFpaikgkgmPHjiEcDtNzWFxcTPOTrEANgHzpU0eXZDIZEokEHZPH46GlpQWrq6uYm5vDzMwMioqKoNFoiGYOgAREgWQiajabifXFNv+pdlGRSAQ/+clPIBAI0NLSgvLycojFYvD5fExMTHC62LFYDMePH6d1+ujRo5BKpXA4HJwZaYZEIkHiaQKBAFKpFOnp6RgbG0MikUBXVxdOnTqFUChE4qFOpxORSAQCgQB79uyBTCaDXC6H0WikArvT6SR7qeeffx4OhwPDw8NwOp10bswpY2VlheyZmICmz+dDLBZDWVkZ+Hz+On0UPp9PyTJjozGKN4/Ho7VvcXERN27cQH5+Pu2PMjIy8MQTTyAYDGJhYYH2SiKRCDMzM0gkErh8+TIVqJ977jn8+Mc/RvzW/o+93uv1QiKR0D3g9/shl8upYywSiWg2u6ioCAqFAtXV1SgrK8PY2Bh9xzk5OTAajfD7/TCZTCguLiY7RrbnZQUhq9VK+yWj0bhlnaB4PI6xsTE4nU7s2LGDivS30zlh+5ePs1ieqlcik8nIojEWi8HpdMJut2N2dhaBQABpaWkU69l38CDArsO9xvvt8GH+pMT6T1TCzIQwlpaWOPPKG3kzbhV+vx/9/f0QCoXo6emhKsR2HYNRvNd6RqZWa91uNykjr02YWeV7eXmZkzAHAgFMT0/DaDSipqYGRUVFJO5lsVig0Wjg93rQ95lXIQoEcCQ/H4mWFmg0GoSHhxH64WuoOXgQFgDuvFyYWlpQdOIE4oZFHLx+E76RESgcDkTffB3ChgbO+cTjcTiVSoQkEqiOn0DJjRsIHNgPf001JFVV67zSJrSZMHzhl1B34SLcbjcFB0Y9Z11Zt9uNCxcu4IUXXkA8Hsc777xDC3ckEkEikUB+fj4t8pFIBD/60Y9IKVMkEkGhUCAYDEIgEBAFjomTMdTU1JDfXkZGBue74PF4NKPj9Xpx7tw57Nu3DzweD1lZWZiYmIBGo6EOa0VFBS5fvkyJaGdnJ0wmExYWFkhdFPgoOYtGo5xiD5tzXQtmtcW6i/v27Vs3s+73+6lIMDU1hUQigUgkgtXVVZSXl3MWQ4vFgrq6OjoftsmxWCxoaWlBQUEBAoEAcnNzKWEOh8Pw+XxwuVxIJBLU+VxZWUEwGMS+ffvwwgsvkMosm632er0UCHNyctDc3IwbN24gNzeXk+wtLCxQF/rZZ5+FSCRCdXU13G43UZW2gkAggL6+Pmg0GqKVbYS1s8wfd/f5dqJfYrGYqJSpVhZLS0sYHx/ftJXFVs9pKwEUwLYII/7whz/El770JTz22GPg8/l46aWX8O1vf5t+H4lEMDk5ydE1AIDvfe97KCgo2NDaQiQS4a//+q/x27/920gkEqioqMA3v/lNfPGLX7zv832E7QOzb0wV8hQIBBuKJW0FsViMxC537NhBHUcmFHS/SGV69fT00FqXur7EYjFMTU0hLy8P7e3tnGeN0XetViui0SiNg8ViMej1ehgMBvLeZd63LBljjg1Akk3E7Pf8fj+GhoY4G9y0tDTodDpS8Q+Hw7BarRgbG+PY3thsNo541eLiIuffxcXFnGI2O3cGr9dL4pW5ubmU4FmtVhJEk8lkKCsrw+XLl4k1JpFIEIvFoNFoKPkGgPfeew98Pp/mmVUqFZ0PS5BZYZYhkUhQh0+pVBItmoEVqWOxGM6fP0/K12lpaXQe5eXlGB4eRkFBAZaXlynZLi0thUqlIhsun89HRe6NKOperxfNzc0cphvwkSK55BYjr76+HqOjo9BqtZwYePnyZUQiEU6hY3FxEXv27OH4UgcCAWIqBAIBEklbXV1FR0cHGhsbSReH2VyxgkA0GsX4+DgWFxdpvMxsNqOurg7PPvssgsEgVCoV3nzzTfh8PqyurhJNWyKRoKurC9evXwefz+eI53m9XrzzzjuIxWJ44okniNJfWlqKaDRKdPN7RTwex/DwMHw+H3bs2HHHLuKddE5u57KxXfH+drFeIBBQLK+srCSXDZvNBr1eT6NkrPu8FfbX7cC67luhZP+ixPqHNmFeu+lj88qMgpu6cDCV4fuFzWbDwMAAcnNzUVNTw7mhBQIBxwLoXsHmUGZmZlBfX7/OVyw1IR8eHuaIe6VSsnbv3g29Xs9RF4xGo3jjjTcQjUZRWVlJi82uXbswPTGBnH/6IWQ3b2LpT/8EllviS76qKuSo1Um15z/6r4gND0N65SoU//HLiEQiyOvcAcWhxxD/yu/APTCI681N4MeieMzjBXs0oqOjKHnvOHzNzUj3uKEsKkLiC7+ESzvaERSJEZeIgVvJsoDPR+HgEOYbbyXb6ekwff6XkEhRymaJdUVFBUKhEJxOJ82d9vb2chQj9+7di97eXigUCpSXl8PlcnFmuFIDtVAoxP79+yEWixEKhbCwsMBJmJeWlhCPx2n2mFX9vV4v0ZoYmLdzdXU1BgcHkUgkEA6HsWPHDlJ1TLW6cjgcqKiogM1mg0QigVQqJWsIiUSCuro6EoIAQB7FQHLuyGq1orS0FE1NTURRHxkZwZEjR0jtEsA61WdmacFUr99++2243W6UlJSQcjpTQ1Wr1dTBZlRptslYWlqiAkJFRQWGh4cRj8dRW1uLrKwsLC4ukuDZhQsXUFtbS5sXRpljc+bBYBAdHR1IS0vD0aNHsRbsO2EBXiQSQaPR4NChQ+teu1n4fD709fVBq9VSYWSzuF1AfRB0rs0Gq/uxstgKtiICwgLa/VadgSTd8LXXXrvt70tKSjYclfn617+Or3/96xv+zeHDh3H48OH7PrdH2B6sfSYTiQSmpqawuLi4TshzuwrXwWAQfX194PF46Onp4cRYNqpxP0hleq3dS7DPyzQmWJFTp9NxfMrZKFZOTg7nOT516hSMRiOUSiUOHjwIHo+HxsZGxONxUrlO9ZcXi8XIyMhALBbDxMQEJWg5OTkwmUyora2lOcJEIoE333wTACjxAUC2TzqdDiKRCIFAACUlJSQuCYCTLKf6BAPJZJK5UADJYgBbTwsKCijeiEQiTExMULEgkUhgx44dGBsbg0gkQnNzMyXSdrsd8XgcwWCQ895dXV3Izs4moSWj0Uhrtd1uJ+ePDz74AH6/HzqdDunp6RxhTiAZhwYHB3HgwAFMTEzQ/qO4uJgow6wozD5TS0sLlpaWSDRUIBDA5XIhFouhpKQEGRkZVNxgRQ9G+2bCWo899hjm5uaILZaeno49e/bQcVisF4vFiEQikEgkyM7OhtFoRElJCS5cuICFhQUSnXK5XJicnEQgEIBAIIBMJiPRsdXVVaK89/f3E3ssKysLXq8XbrebhEPtdjs+/PBDAEmhJnYPiMViKJVKGsNJS0vDwsIC2traoFKp8Nhjj2EtPB4PfSdOpxM6nQ5CoRC7du1a99rNIhaLkeNMR0fHPTGv7tVl436T5806YsjlcsjlchQWFtKooM1mo3t1bff5frBVRwzWxLpffBJi/UObMKfC5XKhv78fGo0Gra2t6zj99xtEE4kEDAYDpqamUFNTQ/MzqbifqnNqJZtRvBmmpqYwNjaGsrIyeihzc3MxMzOzId2ysLCQc36RSIQEnth5GgwGOBwO1NXVIZ/Hh9njRpHHA+3wMORlpSTOJVpYQHpVFYQ7OhAbHoZ3Zw9KS0tRXV0NKY8H72c/h9jKCsx/+ifwZ2YAABz5efAZjejt7UXWhYsoOPE+Gs6dh6y5CZGREdj+9Ufwd3ViLdLCYWT190M1OwvzZ/4NBGlpyCsshH1kBIFAgLNBkUgkVEmuqqrCu+++C6VSiby8PKI/T01N0ZwuA+uKxmIxzsxSPB7niHsxmhFLUNLT0xEKhWhWCABnIyAQCNDT04ObN28iFovRBo51Tf1+P95++20cPHgQSqUSbW1tuHnzJgk7jY+PQ6FQcJLv3bt3o7i4mDZPg4ODHGobABKBWVhYgFgsJhENhULBqeiNjo6iv7//I+p9NIrCwkKUl5cDACYmJqiKbjKZKPCzLngqRW5tscFoNEKhUKCrqws5OTkkUMWoZCUlJaiursbk5CSi0SjRqoLBIH02l8uFZ555Zt09sRb19fUkuLMdyZbH40FfXx/y8vLu22ruQdO5UqvZ94J7sbJI9bbcLLYqAiKRSB4a5c9H+OSAFcaDwSC6u7vXrQPbURx3OBzo7+9HVlbWhoyT+91PGAwGTE5OrttLWK1WXL58mfQ44vE4p6jFqKoMbCSJIZFIYHZ2llMYdjqdmJubQ3l5Oaqrq3Hs2DESs8rOzobdbofH48H4+DhycnKg1Wop2UpLS0NLSwu0Wi36+vowMzODhhT2GIuHFy9ehN/vp3jX0tKCgYEBuN3uDa9TarKsVqshlUqRkZEBj8cDh8NB6yYAojsDyVGja9euUUGWdWotFgt9ZvZajUaDnJwcBAIBRKNROh7zbWVgrAQGrVZLjQ/2eVLnrwGgvb0dS0tLMJlMVHhI/f2xY8ewc+dOFBYWoqmpCaurq4hEIigtLSXbxdnZWYq5FRUV6OzspPssIyMDJ0+eBPDRus+sIx0OB65du4bKykrSU0lVIDabzTh9+jRUKhXkcjl8Ph+ysrKwd+9eAMnkkxUuWFGeWYQB3PWcz+dz9iSMkdbW1oaamhqyQdRoNJiYmIBOp8OuXbtw/vx5xONxmM1miEQijI+PU9fabrfjueeeW2ftsxY5OTlobW1FJBLhWE5tFUzkFkh+f/cbe+7Ufd4OptlWLCQFAgG0Wi20Wi2pfzNF+5mZGRL4y8zMRFpa2pZGqdhxNou7OWL8vOGh39GsrKyQDH1paemGGz7WhdwKYrEYxsbGYLVa0dHRwZkhWnuMrVSd2ZwRgHWVbCA56xIIBDA1NYWMjGRSWlZWhoKCgrs+iH6/H729vZBKpSTulZeXR1Rs1+XLmJPLgcNPIpCbi7rDT+KlxqS41/z8PPxTU+j87a9A8b+/C//587haU43EyEiyEyiRInozWQnNGRxCXl0tBAIBcnJycPHECTjcbjga6jFZVwtRPI4DZ85CBEAzOQXpvr0Ih8MoKSmBSD8HQzwGm1CIwMsvIc/rhcnvB/x+2O12vPzyyxgZGSFhErVaTdQ44CPJebfbjV27dkEsFqOwsBDRaBROpxP5+fmYnZ0lhUYGdp+wLi3D2u8wFotBrVajoKAAfr+fqq2pyM/Px5UrVyAQCNDV1YVz584hMzMTHR0dGBgYQCgUgtvtxvLyMkpLS7G4uEiCXUajEa2trevmqVUqFZ1jIpFAMBikDczIyAjR1EQiESKRCKcwUFFRwSmkMMo4q2wDH3lPp3bSeTwempub4XQ64XA4kJGRgfHxccTjceh0OoRCIUxOTqK8vJyEp1jhgiXZbGFkFCw2V7KysgKfz4fa2lro9XrYbDY6l6mpKXg8HvLmTEtL2/C+Hhoagl6vp079/YAV2YqKim67btwPtpvOtdWEee053cnKIpXutVkRta0kzF6v92eq9PkIn0ykCnn29PRseH/ebzK7uLiIiYkJVFVVoaio6Lb7ia0cIx6PY2JiAqurq2hvb6d4zjA1NQWHwwGHw0EFLrVajVdeeQWxWOyOHbFYLIbh4WG4XC7s3buXLPY+/PBDuN1uTE9Pg8fj0Ua8sLCQZnSXl5dJUPSJJ55AdnY2zGYzJiYmsLCwgJdeegmTk5OIxWJYWFhAbW0tLBYLqqurMTU1tY5lxTrPzOHCYrEgLy8PQqEQFouFkleVSgW32w232w2z2Yxnn30WoVAI77//PoDketXY2EjFbL1eT4m0RCJBQ0MDhEIhioqKsLKyAplMBr/fT2JmbJSLfYdCoRDZ2dkcdexUJhCQ7Bq3tbUhEolgaGhoHb1fJpNRvOru7sb09DSmp6fR3t6Oq1evwuPxIBKJYGZmBnl5eZifn6cEnHXrmb0Vw1qRRq/XC7VajbKyMgQCAUxOTiIcDhMVe3Fxkey21oomrays0Jwr6+r5/X5Eo1Gak5ZKpQgGgyguLkZBQQEmJydRWFiIgYEBEv4sLCyk5kN5eTn8fj8x/NxuN1Hds7Ozcf36dUxNTYHP5+NTn/oUSktLMTs7i9LSUvLjZs+q1+vFsWPHUF5eDq1Wi8zMzA2fY4PBgNHRURQWFt43rTgcDqO/v58YCNtJUwbu3n3eCtNsK6NOqWCNE4VCgaKiIipu2Gw2TExMIBKJENMsIyODYz93OzA22b3G7TsJfP684aFNmBOJBMbHx7GysoKWlpY7qp9ttep8t2Q2FVsJoi6XC319fcjMzER9ff2GDwhTUqysrKSOXyKRwPnz57GysoLu7u4NJfYZ5SsvL4+sEerq6iCTySARixEKhyE7dx6CJ55ATMCH99BjiOXkEEXXarUiJFcg7PdDfOJ98PRzkLrdCKSlQTYwCN5zz0L0zNOIz+ohf+YZHCxO0ryDf/8PyP3p27A++zSU6Rmwh4KI8PmI/6ffhfXKVSTq6hCcS84B8Z1OVHz1awgeOYyFzh2QFhTAJ5EQTZvZ+mg0GgpObCaGBfVUCoZer8fs7CwWFxchEAgQCAQgkUjQ2NhI1WiGRCKBlpYW+Hw+UhwXiUQQiUREy2JJCvO7BJJ+kjMzMxAIBERfYlVx5jMYCATg9XpRXV2Nnp4eDA8PQygUQqvVku81AJofdrlciEQiqKyshF6vRywWg9FopI4Cs8kCgGvXrlGXWyaToaamhu5R1hWXyWRwOp04c+YMpFIp8vLyEAwGUVtbS5uUiooK/PSnP6UNAetomEwmoj2dPn2aPncgEKDjsoDJBMn4fD5n88eUVIFkh4DRtdPT08Hn8ymBZ5sphkgkQpTujIwMpKWlceaYp6enEY/HMTMzc19VZ7vdjoGBAVRUVGx5FupesB10ru1ImNdirZWFy+UiJc7NWllstcO81XnzR/jFBCuMMyHP223atlocj8fjGB8fh9Fo3DCZXXuMe431TJAyEolg586dG25Qy8rKsLy8jKysLIonQNIb98aNGygpKcG+ffvW/R2jjwsEAuTm5uLUqVNIS0tDXV0d1Go13G43h9HDXDZisRi0Wi1H8ZtRlBl4PB6sVitaW1sxNTWFuro6ErlkIoPAR+4QQDIuVVdXU3cRSHZr/X4/fabUrjKQZMJIpVJEIhF0dnbCbreTEnRNTQ3HAglIJoEsLlssFng8HggEAuzatYsSbgY2m8goyqyLzmaYQ6EQJ6llBYCKigqKVTweD3K5HHw+nwoC4+PjlJTPzs7i4MGDuHHjBhWGT548ySnG22w2jI2NweFwoLy8nOyZlpaWOCN0V69eRSKRwMjICOcz79ixAxcvXgTwEaORxVdGH29oaIBcLkdmZiaamppgMBhI+JY1DFgMMRqN2L17N0pLSzE+Pk57qVTdFJfLBY1Gg2AwCIVCAb/fz5k19vl8RHdnTg5ZWVnQarUoLCzEsWPHEIlEEIvFKOEPBAIQiUSYnZ3F8PAw0tPTiRHAEiu9Xo9wOIzZ2Vl0dnZuOXkMhUI0mpcq5vkgsbZYvhWdk610mO8Epn2j0+mo62uz2WAymTA1NUX3TGZmJjQazW3PaSvfw/2IsX7S8NAmzKxL1dPTc1d+/FYCnNPpRH9//x2T2fs5BtsAVFRUoKSk5LYbgIaGBjQ0NMDv91Mgi8fjpK64tLTESZiDwSD0ej2WlpZQW1uLwsJC/PjHP6Zj7tixA88/+yxMn/kcFMPDKDtwAIlnX8TU1BR8k5MQ/cV/R0VtDaz19XAV5MP0hV9CxnPPIXruHA6MjMI7NgblqhHBuXkkVlcRGxtD6B/+AcI/+Vry3FZWkDM5iZxvzoD3/HMYdzgg9XhgyM/HlEwKzOmhUang8nigdzhQrNOi/sT74B08gPlbtCqmRspmYFPngADg+vXrRMFiiR6joQDJBZ8lgvPz81TBFQgEEAqFEAgEqK+vRzAY5AhipKK1tRUTExMc0RLgo9kqNg/udDpRWFiIubk5TuAFkvQo1hlXqVQ4fvw4/S51g8H+K5VKKTGy2WyIRCLrbEPYfcI6y4yOzSqxarUa5eXlOH369LouMhPjYNdoo/uVx+NR0trQ0IBAIIBIJILW1laIRCLMzc3BYDBwNj4vvvgiUf2vXr3KEdJoa2vD4OAgJicnSd059RrPz8/DZDKhqamJFnO3243z589jeHiYqPZarRZ1dXVYWVlBY2Pjht/ZZmCxWDA8PIzq6mrk5+dv+X3uB/dK5wKSiSnrRD+oc0pPT0d6ejoqKio2bWWxlcDOEuZHHeZH2AxcLhfGxsbuWhgHthbrQ6EQBgYGEI1Gb5vMpoKN7Wz23mejH2q1Gm1tbbdlbuTk5OBTn/oUABCtFQDRZdl/GWKxGAwGA+bm5qDT6VBfX090Y6fTiXA4jP379+P8+fMkANbW1kY07LNnz3LmiKVSKQoLC2GxWOB2u5FIJOByuXD27FnU1NRQh7+wsBB8Pp8jrlNaWkoJbCwWo7iam5uL1dVVeDweskUsKiqCwWDAwsIC0d5zcnIQjUZx4sQJEt6Kx+MYGRmhkSDG4hOJRByKJ+sYO51OLC8vkyUTE/IsKChAaWkpdao3uu5yuXyd7ZTD4aDEsaKiAl6vlxhQFouF893LZDK8/fbbSCQSEIvFOH36NO1H2BgUANq3eDwespti87ossWBFn9T1USwWY3h4mKjyWVlZFJfn5+cpMe/v76d9w759+4gRmbovSS2+LiwswGw2o6KigpxT2BjV2NgYVldXqWgAAEeOHEFmZia8Xi9OnTpFNG0AaGpqgtFoxJUrVwAku8SMeVZdXY2MjAwMDQ2huroaVVVVqKqqQiAQwMDAAK5evQqRSIS8vDxkZWXR+FxRUdGWk+VAIIDe3l4qHn0cyfJabBTrWfJ8p+7zVrRBNgs2CqhUKlFcXExUf5vNhtHRUcRiMY7OCdvP3Y8jxi9KgfyhTZhLS0tRUFCwKdrgvQpyMXXZyspKzhzp3Y6xmUCdKliymQ0AQ2qQZjOz7D0YgsEgfvKTn5APLpuP2r17N2ZmZkhRW6pQoOj//BCxlRXwb81GZ2Vlwf83fwv16BgUCwaIa2sRi0Qhffc43tPpgH/7OezcvRuDr70GXjCI3WnpwLlzAIDYxATcn34V/MwMSP/oDxFfWUW8rBSXKsrhs1rRs2rE2ZQqtu7SJbiampCIx6F643XIE0BiZhq4FRgZdQrgzs/m5OTA4XBwPAorKiowNTUFm82GsrIyiMVi8Hg8WqhZ0ggkFyx2H6TOa6aqXjNMT08jkUhAJBKhqqoKFosFarU6STm/VeVl1fNUle/29nbqOqcKjaTaR7EKv9/vp5mpUCiEqqoqqFQqXL58GQaDgeaJU1U79+3bB4vFgqGhIXg8HgrAJpMJXq8XPB4P6enpKCoqovPSaDRwuVwwm800Cy0Wi1FXV4fp6WmkpaVRVV2pVBLtXCKRkOL1jRs38MQTT6wL5CKRiO7N4eFhspNSq9UoKSmBQqHgbEBZRb6wsBBZWVkcwR7gI9Eq9r3L5XLk5+fDarXCbrdDqVTC4XBAKBQiIyPjnhZwk8mEkZER1NfXb8rs/uPAZulc4XCY7tOPI/BvZGVhs9nWWVkwhfl7waMO8yPcC9LS0rB3795NifTcK5uMjWakpaWho6NjU/dy6rN6t2fRZDJhaGgIpaWlKC8v33SRKDUmtbW1kRp4Kk6cOAGr1YrMzEw0NDRwxL10Oh0VWvfv3w+n0wmVSkXnm0rDZp0/JnQVjUbR09ODvr4+AMlEms3b+nw+XLp0CR6PBzt37kR1dTX8fj91sJn3MEMqpbmxsRFarRZOp5NELCORCPLy8sDn8zmxPjc3FzabDUKhkCjELIkLh8OIRqOQy+VIJBKcovbY2BjHYQJIxiiJREJF5rWw2Wzwer0QiUQoLi6mwndTUxPOnDlDFGsAnO57dnY2HnvsMVitVjgcDkqQUz+zWCxGfn4+FQzUajVMJhOam5shk8lw/PhxBAIBvPvuu/B4PBTrxWIxdu7ciWg0ivn5eczPz9P7pto9KhQKzhy8TqcjWvb09DRu3LiBRCKB1tZWeL1eiMViUsIuKiqivUwkEiFtkYmJCbK0WitGx5KniYkJTozWarUoLS3lKIqz/YdMJkNDQwMkEglHtI79ju3VWBPCbrfDZDJBKpUiFotheXkZWq32nnxxfT5fUkcnKwvV1dUPRXH2XnRO1oq0PkiIRCLaizFKvs1mw+rqKiYnJ6FQKIg6f697j+10xPgk4KFNmIVC4YaKaBuB0XPvhtQZo7a2tnUiG3fCZkS/otEoBgcH4fP5NhQsuRPWBunKykpU3lK0BtaLe6VeG0ah8Xq90Ol0yU6VXA7BLSuheDyOkpISxH7tP8AzMAhXRRnShEI0fvNbsJWUwJ1IAH4/xv/1R3BptQAAcziMsr/7DiInTyERj8P3v/8R/FgMgqoqRD78EPbpAtjyvwAoFLC9+AIUej28Xi80ajUyB4ehmpqBrKUJV3NzIRQKsWPHDrjdbvIsrK6uhkQiIcpXZmYmLBYLYrEYCgsLScSCqTIyI3qWWGg0Gvh8PojFYqqEM8oyAFy8eJEWanZN6+vrIRaLYTabOdX8iYkJxGIxmM1mVFZWkqpz6nfDrvvg4CBV0tva2tDX10eWH0yxUiqV0oZBJpNhaWkJSqUSIpGIMyOfen7xeBwOhwOXL19GUVERfadKpRJ+vx/Z2dlkFXXy5Elob31P5eXldK7hcJgCP6M7BYNBWCwWui4+nw8CgYBUmdnPeTwe3n33XaSlpeHw4cNYXV2FTCZDdnY2lpaWEA6HOaqpHo+HlEJTZ87Zv9n3ByQ7J2azGbW1tcQW2b17NwwGA+rq6pCeno78/Hy6BlarFZOTkwiFQkhPT4dOp4NWq71jZ2h5eRmTk5PUyX5YsRGdKxaLwWQyQSKR0CZwq2IiW0HqbDMAjpWF3W6nouVmrSy2w5fxEX6xsFlF23vpMG9G/+R2xwCS3ZPbFewTiQT0ej30ej0aGxvvuUCXup/Q6XQ4ePAg571nZmZIPyJ1c61UKtHY2IjV1VWyHuLxeEhLS6O1JCMjA3v27MGZM2do1jUcDpNQEJCMj+z4kUgEzc3NpMjLPIGnp6cp5rDYyoSF2IgTS/IEAgEsFgsmJyfR3d2N8vJyzM7OkkdySUkJhoaGqLvs8/kQDAah0Whw+PBh+P1+TqdzdnaWzpVRuwUCAYlLpWJiYoJmsBmqqqogl8spQWSJNIuPAEjBfHh4mAoYqXsIs9mMkZER2Gw2FBcXU2Ga3YOsu80614FAAKurq4hGoxAKhZyiPTvveDxOcb+3txc5OTnIyMiA3W4nX+O8vDxysOjr64Neryf2VmpSyUaY2P9PbR4AyYSWnXN6ejoV+Hk8Hk6dOgUej4eDBw/CYrFAJBJBq9UiFArBbrdzrpPf70dpaSnEYjEUCsW6wsThw4fpvFwuF6anp1FcXExxuLW1lQoLqfaIXq8XFosFy8vLGBsbg1qtJlGrO9kjbqeY54PE7ZhmFouFhFPZfna7batuB2afqlKpSMCVxXqr1YpYLIaRkRHaD9xtXWb32y9KvH9oE+Z7wWaCKBMGYNXVe5VBv5voF7OvkUql6OnpuWc7l9QH63bvLZPJsH//frjdbo7/rsPhIDpSNBpFVVUVhwbKHkhhWRkU7x5D749/jEQ8jvm//AvkSCTQnj0LXiSK3MEhuPbvBd/jRdqbbyLxzW9CUF0NR3ERTuu0EEajOFJVBfB4SDOaoJRI4L21wD4uEuG03Q4XgIFf+rd42miCYd9eGG91acvLy1FZWYnr169DKpUiGo1CIpFAoVDA6XTC6XTSd+h2u0kts7q6GteuXYNcLkdjYyN6e3shEAjIFiH1e2eqkcBHyShDPB5HTk4OKX+m3jOp6oAXL16kbrFEIkEkEkFDQwPZ9jCxMSAZ8NjfqtVq5OfnQyaTcTrPrDLt8XgwNjZGHV+ZTAaZTEbBlgVss9lM1WUgGYSVSiVaWlpQWlpK81vsHBYXF2nTolarUVlZiYGBAajVapSWlmJkZAQ6nY66DXq9Hq2trRgaGiJ/ZrfbTarirOrPkuGZmRlcvXoVADiBMi0tDV6vF+fPn6drzubRmU81kHzuzp8/T/ZbPT098Pv9GBkZgUAg4HQi+Xw+LdRVVVXw+/2wWCwwmUyYnJyEXC6n5Dl1DsdgMGBmZgYtLS13nE182MCey9nZWZojFAqF9yUmsh1ItbIYGRmhY27WymK7bCYe4RcD97Lh3Uysj8fjmJqawtLS0j2xvFLPh8fj3fY4TIDL6XSiq6uLM4ayWdxuPxGLxTA0NAS3240DBw7AbDav69odP34cwWAQq6ur2L9/PyfWszWCz+fj8ccfx/vvvw+LxQKFQoG6ujoMDw8jGAwiFotRgubz+WA0GiGXy5Gbm0vXWKFQkBVjRkYGbDYbPB4PduzYgYWFBQSDQUQiEZSXlyMvLw8XLlwAkIwZtbW1mJubIwpzLBajTTWjggPJvc3IyAhWV1dJ5CuRSKC5uZnox36/H5FIhJOkpSpxb3Qd2ajP6uoqZzwqFaurq9RRViqV8Hg8yM7ORlpaGmZnZxGJRIiZlSriJZPJkJOTg8zMTE4RORKJcEbFLly4QBRrtVpN+iXsfmcCcAyBQAA8Hg8lJSWora2lgofX66Vrxq6bWCxGVVUV+vv7kUgk0NTUhL6+PiiVStINcbvdaGlpwdTUFKamptDc3Ew+y+x9bDYb7SV9Ph/eeecdJBIJEv1k1HelUonTp0/DbDbTc8F8llNj+JUrV2C1WjE/P4+XX36ZZrWtVitntDA1cWP2iFarFVarFQaDAXw+n5LnVOEwNkpZUlKy7rl4mMFiKBPlamhogFKpfGC2VZuFSCSiIsbKygqWlpYgl8uJhatSqSjWb1TE8Pv9v1COGD8Xn/JuNC23242+vj6kpaVtWXL+ToGa+Tfn5+ejqqpqSzf67RLm1Pe+HfWEUZgZxZh1rpjpfCKRQENDA838sCCoys5GaUMDChUKBN98C97f+S3UmPDjbAABAABJREFUDA9D/eZb8NbXQ/TFXwUAmL/6x4gLhQgLhXB6fRD+5EeQSCTgT04CtxLm6N/9AzIqyuDu7oZco4Fl927kpadDfWvmiPn67d69G1arFW+99Rby8/NRUFBAPoVAcr5Zo9FQksYCqM/nQ0ZGBsrLyzEyMkKfPbXTrtPpiG2Qn59PiThLRpmVA/BR55bNTPX09CAejxOFCfgo6R4bG8Nzzz2Hs2fP0jxSLBaDSqWixJVV6QCQaAoAopaJRCKaHwkEAvR3LAltbm7G4ODguu+fJeivv/46KioqaOakuLgYi4uLyMnJQV9fH1kK9fX1UXKq1+tJcXZychLDw8NIJBJYXl5GNBrFysoKqqur4fP5UFxcDLPZTAJQDKmV5kOHDiEYDMLr9aK0tBQXLlzgUNEBcL5LNsfFNiOsu768vEzX6r333sPjjz++jsKbqgLJKqF2ux0Wi4X8r1lH1Gq1or29nWPX9klAIpHAxMQErFYrduzYwemgb1VM5EGco0qlQmFh4aatLLZLNfO//bf/hnfffRcDAwMQi8X0zNztfP/4j/8Yf//3fw+n04ldu3bhb//2bzlsHbvdji9/+cs4duwY+Hw+XnrpJfzP//k/f2Gq5A8jUjt7dwKL9azruRaptlQ9PT1bGg1InTNci0AggP7+fhqbuhcaaSo2GhNKFffq6emBWCxGXl7eur9l+xcWG1myzJg89fX19LnZmiKXy1FdXY2ioiKMjIxAJpMhEomQ9gQrUOfl5dHnXlhYwIEDB+BwOEgwMBQKkTgnO4e0tDTk5OQgPz8fdrs96Y4hEqG7uxsAcObMGUquUvdR+fn5qKuro7icKvzl8/nQ2dnJidmp140JoFmtVqSlpUEqlWJ5eZlYU319fUQ5B0CsMD6fj6amJhQVFeHtt9+m3zOqsdFoRGdnJyKRCJaWliAQCOD3+6lTCyQZNHq9HjMzM8jKyqIZ5nA4DJVKRTRjFhs9Hg9MJhMJtBUVFXHGrRhYQeDkyZPIyMig9aixsRHz8/PQarVJLRqfD+FwmPZIfD4fc3Nz4PP5aG1tBQBqoJhMJioWMKp2eno6ZDIZ4vE4h+7N3D2AZIMjOzsbNpsNeXl5WFpa4oymAcn9Uep7s3Exq9VKsT5VNOzUqVPYs2fPhtoi7F5nApVOpxNWq5UjHCaXy7GysoLKysqPRcxzu8FGxhobGzmjapvVOXnQ8T6RSEAikZDwYjgcpn3t0tISeDweZ/ZZJBJtmyPGJyXWP7QJ871WnW+nnLm6uoqRkZG7qm9u5hhrA2iqfzMTstoqNgrSzM/xbu+tVqvxzDPPIBgMkgInkPzsTD2adRyFQiGefvppeDweqrwLW1uhbG2FEkBizx7Ev/hFCPoHkLh2HbxEAtGpaRQ5HJD4/TB3tGPcbgOPx0PVre5kMBBA/HOfQf3//DZymppxFUlRkz179uDZZ58FkExqTpw4AQCU2JhMJqyurtIizSif2dnZUKvVCIfDpPApEAhgMBio4yUWixEOh0lNOxaLwe/3U+AzGAy0IWGq4GuvN/t9Tk4ODAYDAoEAsrKy4HQ6oVQqKaBVVFTgrbfeQjQaBZ/PJ2Xn/Px8DA4OrksaGR0bSCa8TFBrfn6eo1gqEAiwb98+XLhwAf39/ZDJZIjFYqR6rdFo4HA46PNNTk7S37LKeG1tLZ544gm6tuxa+v1++v8mkwmNjY1UMJHJZFQ5Z+85OTmJffv2obCwEA6HA0NDQ5yqvlQqhVKpxPvvv494PI7l5WUKoIwiz4KxWq3G+Pg4ent7oVKpcOTIkWSB5tacS35+Pm0evF4vDAYDdbQBEAMglQ4kEomQnZ2N7OxsqrZPTU2ReM3k5CR1n7fiN/xxg7kA2O12dHR0rKOb347OxTaEH1f3OVWc5G5WFqdPn8aVK1fA5/M53qFbRTgcxqc+9Sn09PTgu9/97qb+5s///M/x7W9/G9///vdRWlqKP/zDP8STTz6JsbExmvn87Gc/i9XVVZw8eRKRSARf+MIX8Ku/+qt47bXX7vucH+HB4k50aY/Hg/7+fiiVytvaUt3LcdYmtHfzb74XrI31rHOm0+nu+t5Hjx6F1WpFbm4uZ5N96dIlWhuYD+6uXbtQVVVFIzwymYxj29fU1ASfz4cTJ07Q2A0rXoRCIYor9fX19DcKhQJyuZzYYb29vXA6nThw4ACA5Hfz+uuvIxwOk9BjMBjE9evXOd3J7OxsqFQq0uNI7bbGYjGcPn2aOpxsM69SqWAymRAIBCjWpzoxMMGxtdeadX6ZUveVK1dQXFwMo9EIqVRKybBGo8G1a9coPpaUlCAYDKKurg4DAwM0z83ujVQ2GJBMNEUiEfx+P70nQ3V1NRYXF7GwsACpVAqRSIS0tDSIRCJIpVIkEgnMz88TbZfh6tWrpP799NNP44033lgn8sX2FXq9Ht3d3dizZw9sNhsqKirwzjvvEOsCSD4nVVVV6OzspCKN0WjkFJyLi4tx8eJF2Gw2pKWlcSy85HI5Fa7y8/Nhs9lw4sQJ8Hg8HD16FDU1NRTrFQoFSktLMTc3h2g0iomJCU7CzPYYqYwk5sqRkZFBTLP5+XlK2hYXFxEIBKDT6W5rUfmwYXV1FePj4xuOjG1W5+TjiPWp41ZisRi5ublkged2u8mi8sKFC/jLv/xLVFdXEyvufmyyPimx/qFNmO8Ft0tmmfhWc3PzOvGh+z1GPB7H2NgYzGbzHf2b7wWseno3P8eNkJaWRg8Z8JG4Egs2qXOmPB4PIyMjEAqF2LlzJ20sEuEwPK+8itjkFNR/+9fgvf0Woj4f7E4nPIuLqBwZxYhKBdx6kMO9vYBGg3giAf7Bx6D+7GeRcDiA994DAI5ARGpSWV5ejqWlJZq3mp+fR21tLUZGRnD58mXU1tYiGAxyxDWOHj2K3t6kL3RqNc7v95PQhVAopESaXQehUIjCwkJYrVaIxWLqQIfDYaJ1pc4zs82C3W7HY489RvYcqT7KjN7s8XhQVFSEhYUFErfw+/3Q6XSUTEajUdy4cYO+XwCkes3j8cjHGQDN4bNZLqYc7fF4yEIrde4ZSFaj2Yweo8hZrVbk5+cjFApRJX50dBRjY2Nobm7mBMbUzk48HsfS0hLOnj1Lv9dqtaipqaEZQJaIpib+7Pt47rnnONQpACRUxgKoz+eDwWDA3r17cfPmTYRCIU6V22g04vTp0xAKhXjmmWduS+1lM3w9PT0QCARE52KKz4zOdTvhsGg0isuXLyMcDmPXrl2b8incLiQSCYyNjcHpdKKjo+OOdnbAvYmJbHf3+U7KmWutLNga9M///M+4dOkSGhoacPToURw9ehS7du265zGVr371qwCAf/zHf9zU6xOJBL71rW/hv/yX/4LnnnsOAPCDH/wA2dnZeOutt/Dqq69ifHwcJ06cwI0bN9DR0QEA+Ku/+iscPXoU//2///cNO3qP8PDgdgkzE98qKSnZlrnGtfGeURSrq6tp7b7f92drOJu13qwIqVQqJbE+4KPRDrVaDZfLxdFm4fP5WFpawuDgILq6ujj7gL6+PoyNjaG+vh7PPPMMMXimp6fXff7U9d7v9+OFF15AIpGg5M3n81HXPxqNUkKnUqkgl8vhcDiQn5+Pubk5ZGZmIhAIoK+vDwsLC+Dz+ZzibFtbG4CPYlx6ejosFgv8fj/t4wQCAalZpyIrK4s6zazgHI/HkZ2djcXFRY5dVWphoKOjgwr1b7zxBr0fi8Uejwfl5eUwGAxJ606JBGazGbm5uRzfZ+aakcoCyMnJgUKhwMrKCp0v69CzfxcXF5OOx8LCAmf8if23v78f09PTqKmpgdFohFgsxvLyMuRyOXJycihBXl1dxfXr15GVlQWlUgmhUIhwOMz5TuPxOAKBAN566y36WSAQQFVVFRUy2LPGKOHs84RCIezdu5fus/n5eSrker1eau7EYjHMzs6isrISMpkMCwsLJEwLJDvUb7/9Nil+p+4DUuF2u7G6uoqmpiZkZmbCbrfDarVieHgYsVgMmZmZ0Ol0HMXntRgZGYHBYEBbW9vHLgi6srKCiYkJNDc3b0o3aTtsq7aCOyl38/l8pKWlIS0tDeXl5SgrK4PRaMS//Mu/wGq1oqCgAEeOHMGRI0fw+OOPr9O1uRs+KbH+5zJhjkQiGBwcRCAQuGfxrdshVcWaCXDF43Hs3LnzrhvezUIgECAcDmNiYoKSgc3MAqZK2bPgmfB4ILtwES/s3w9eRgZnITEYDBQAS0tLaaGKm82IjSSDSeTcBcj/6L/AYbFgdXwcEArhf+XTaFapcPPmTUilUqj6B1C/sgJJKIhrWi2sZ89g586dqKqqwtTUFIaGhlBWVgaFQsHp8AYCAUilUrS2tkKlUqGrqwuhUIgCGVNiBkDB6ebNm1hdXYVIJEJBQQHRfCoqKkg4LDWo19TUoLi4GF6vF5cuXaL3ZWIkOp0OQqGQI5Kxlhao1+vJ1ik3NxcWiwVVVVVEY2tvb6eZ4lgsBqlUCoVCgZ6eHoRCIZw8eZKT9LMNQDgcpuOWlZVBIBDA6XSum7tOpZ4Dyeq53+9HU1MTFhYWMDY2BiBJnVvLsFhaWsKePXuQnZ0NsViMyclJRCIRTE1N0SYgJycH3d3dVGXX6XQcT2oAlHwzz2wm+MI2Oenp6XA4HHC73XC73ZienkYgEEBTUxPEYjGys7M5idK5c+dgt9uRnp6Op556CmvhdDrJysLn89H9H41GMTc3h4yMDKyurlKyyRLdgoICFBQUkHAYE6Bh83csgWavN5vN1IlYWFjgaAI8SMTjcYyOjsLj8aC9vX1La8edbKvY/9jr7ldMZLNWEzweD/X19fjqV78Km82G9PR07N69G++99x7+zb/5N/jWt76FV155ZUvnsFnMzc3BaDTi0KFD9DONRoOuri5cuXIFr776Kq5cuUKKyQyHDh0Cn8/HtWvX8MILLzzQc3yEjbFZSja7p5kGBhPImp+f35L41u3A9hTxeByTk5NYWVm5Z6HQO4F1mKenp7GwsLDpWevUWA+AU8Bkllmpewav14uJiQkAScpzand5YWGB/tva2or8/HycP38esVgMGo0Gu3btog5zKgKBAF577TWUl5eju7sbZ8+ehdFoxNzcHMrKyjgik3w+H4FAADt27EBubi7a29sBgOImn8+n8Rzm1Ww0GrG6ugoej4fCwkLyF2adLiCZcLKkMysrCx0dHYhEIjhz5gxHTM3hcFCBYa1tV+r9trS0RC4QzJ85KyuLWFA1NTUYHx8nCnJxcTHEYjGqq6vR1dWFq1evcvYfLB4zO6loNAqtVguFQkEd0lQsLCxgYWGB1lqdTkeiYiKRCBcvXqSElO132GsZm+yxxx6DTCbD1atXEQqFsLi4iN7eXoTDYYjFYjz11FPEVmNd/dR9M7Ma7OzsBJDcH1itVsjlcrjdbpp5B5Lx026303PX0tICPp/P6R6PjIxgeHgYPB4PL730EhVCGILBIO15HA4H7UOZnSq7PyYnJ9Hc3EwsiVTFZ4/HA6vVisXFRYyNjUGlUkGr1UKn00GlUhGTkBUyxsbGPtaEmYmRblVfZW2sB/DAus/3Yiul1Wrx5S9/Gfn5+fj2t7+Nv/zLv8R7772Hr33ta3j//ffxD//wD1s6h83iZxXrH9qE+V4quKkzzF6vF319fVAoFOju7r7nrsbtwG4kl8uFwcFBpKWlEc11OzE8PAyVSoXu7m5OBT1ysxfu3/gShHW1UP/934HHusIbiHsBgPd3voLo2XPgV1VB8+4xzjFyc3OhUCggFAqTfn/nzyPy4Rn4X34JZ/7w/4EkEMATTzwBIElnZvM7U1NTeOGFF1BVVZXctDzzDBzvfwCzXAbzLYrwyMgIKTwzKhSjhbOfWa1W7Nu3D1KpFDdv3sT09DRaW1tRV1eH1dVVVFdXk/CAUCiExWKhjmWqvzCPx1s308ygVCqxvLzMoUzV1taira0NTU1NkMvl5JvMFLdjsRjNRUUiEUrKmcAKkNx0lJSUUNWYbfT4fD5RygwGA8bGxhCNRlFaWgqBQAC9Xs+h+DFKdaqNxdNPP41EIoG5ubl1FDV2bCDZpa2pqaFzLS8vx8TEBNlzMLAgu2vXLrS2tmJ8fBxKpZLoZswKo6KiAvF4HG+++SZRnVI9KpVKJcbGxjA1NUU2AmKxmKryTGQsHA7TOep0OrS3t2NhYQHvv/8+qqurUVxcTIWbteqLk5OTWF5eRmNjIxoaGiCVSilAAsnK/cTEBImi7NixY8NqcqpwGJt9t1qtJBymUChINCw9PR3hcPhj82tO9R1tb2/f8vxjKu5G57pfMZGteDP6fD5UVlbi5Zdfxssvv8zZ4D9IsGdpLR08Ozub87ytZRsxC7PUZ/ERHl6weB+NRsl+r7u7e1utTQQCAUKhEHp7e++peH0vWFlZQSKRWFfUD4VC+OCDDxCJRPD444/T50odywA+evYnJydx48YN8Hi8dZtAhUKB3Nxc2O12mp0dHx9HTk4OrQepXb/y8nJMTU3B5XLB7Xbj1VdfpRhnMBhgt9sxOztLKuHp6en0e6FQSLRlsViMSCSClZUV7NmzBzqdDgaDAZcuXUJeXh7q6+sxNDSE8vJy1NbWYmxsDHw+H2azmcNMY7O2QJLSnCqoycBmHg0GA8UsrVaL1tZWNDU1QSgUUnGZz+dDoVDA4/EgNzcXbrebRM8YZmZmSOsjJycH9fX10Gq10Ov18Pv94PF4VGyYnZ0lPZDs7GxkZWVhamqKU/xmo12px+js7KTZ4KWlJfod29uw5NtqtaK0tBRNTU0YHR1Ffn4+VlZWEI1GOY2iubk5KlhUV1fD6XRCIpFQ4slU0plQ1sWLFzE/Pw+lUknaFIlEAmq1GqurqxgYGKBChsfjQWNjI9l+BYNBlJWV4fXXX6fv5vHHH4fL5cKpU6eg1WqpYA6ARsEYzGYzhoeHUVpaiq6uLng8Hk7BemVlBeduWZpmZmaiu7t7QwYnY1Wo1WqOcJjFYuEIh+l0OpSVlWFpaQnl5eXr3udBYXFxkfa228VATf3vdneftxLrvV4vVCoV9u/fj/379+PP//zP78nid6v4WcX6hzZhvhewhcNsNmNoaAhFRUWorKzc1jlGdiPdvHnzvuehN4LVakUoFEJ2djZaWlrWvXfo3XeRsFgQOWdBfGkJgpKS5EPi9yOq10NYU8P9G/bwxNcLl6hUKgqsiXgczl//EhAKwcDnI1RWipBCAZdcDumtz11RUYHe3l4K2OwhdHu9MOTlJheh5WXMzs4iJycHHo8HGo0GWVlZGBoaosouE96wWCwU2GZnZ4m6wxLE0dFRaLVa+jePx6OZYZlMhuLiYvj9fjgcDoyOjqK2thYGgwE8Hg82mw0CgQAikQg3b94EkOw+5uXl0T3BBFFSLZXY+eTn50MkEtGCu3ajH4lEsLq6itnZWUilUuoURCIR5OTkgMfjQSaTUSV6fn4eUqmU3iczMxPRaHTdfBOPx4Pf78eVK1cQCoXQ2NhINh6MtsWSIKfTiWvXruHVV1+FQCDAxMQEsrOz0draCqfTSWIg7POxDgKbQ6msrITNZkNjYyMdPxwOU/U4Eong05/+NJaWliCVSiGTyfDTn/6Uc77MQqO8vBydnZ0wGo3kQxkMBonu0tfXB5/PB4vFgr6+Pjz++OOc+XmAS1sXCoUcSyr2Gdjzx+Px0NbWRsmmyWQiX8m1lC4ejwelUgmlUsmxULBarRgbG4NcLkdRURG8Xi/NlD0oxONxDA8Pw+/3o6OjY9M2OveKO3WftxJQtzKbtFb0K/U4v//7v49vfOMbd/z78fHxj63j/wifPDBhucHBQXKl2O7niY10paWlrSte3y8CgQAsFgsEAgF27ty57txZ9w5Idqhqamqom2S326HRaDhrVWqndG2Xns/n47HHHqN/nzlzBsvLy5ienqbXpiZ3jB0GfOQNz15jt9uRmZmJvLw83LhxA+np6XA6ndBoNFAqlbSuAiCrJL/fD6fTCZ1Oh4WFBcRiMSwuLsLn88Fut6O3txdHjhwhBhoT0CopKaG9RzgcJv2SxsZGWq8ZFbqoqAiXL18GkEyUs7Oz0dDQAJFIRNcpde1j42F8Ph91dXXo7e3lqKKnXkOXy0XxlCU9LPF0Op2oqqoiYTKTycSxjRIIBCgsLOTYZTEIBAJcvnwZZrMZVVVVlPR4PB6yHIpGowgGgxgfH8eBAwfw6quvwmg0IhgMori4GDk5ORzhMgBEXZZKpbDZbKiursbq6ioKCws5azJLyH0+Hz772c/CarXC5/MhPz8f77zzDsczm2mENDc3o7W1FSsrKwiFQigpKcH8/Dz5h09OTsJkMsFkMmFsbAwHDhzAoUOHoFQqOfd4f38/LBYLLBYLXn31Vc75JxIJTrypqamh6x43mxH4xp+DX1IC6Zd+Y90eeSPhMDZiEAgEyCf943BxMBgMmJ2dRVtb2z3TkzeL7dY5icfj97yO+ny+dcKK7Jn7eYz1D3XCfC80rVgshsHBwW2lZTEkEgmyFaipqbntrMVWwcS9pFIp8vLyaCFIhMMI/vA18LOzIP03ryI6OARBQz14RUW0Afa8+hnEx8Yg+cLnIf+D/5veU/HNv0TkzFmIdvZs/JliMcTn5sEvLYGgrg6x/n6UZGTAlZ+fpFurVETHYqpzIpGI80BduHABXq+XKL1MDdLlciEejxOFGABZCDFVPUZF7ejoIB9kZv+QkZFBCpdCoRCHDx+GWq3GqVOnoNfrYbPZEIvFEIvFMDU1RRWt1EQ4IyODVESZLZTdbkc4HMbly5eRnZ2N/fv3Y3V1FXl5eWSZo9VqKdGWSqUcOwo2H81+ltrNDYfDKCwshMfjQVpaGgX+RCJBiSijM7MCQDgcRl5eHnQ6HUpKSnDu3Dl67djYGAVOHo+H5uZmCAQCLC4uwmg0QiQSYWxsDBkZGXS+rJPLbE6Kioqg1+uxtLQEk8lE14ltalpaWmA2mzE7O4uysjIqEGi1WgwNDWFkZARSqZQTmDIzMxEOh+H1eqkze+7cOZhMJmRlZZHIG0N5eTmpc/v9fni9XkqmE4kEjEYjVCoVWYCkittFo1GcOHECXq8Xubm5KCgoQGtrK2fe+ObNmySMdrfnMtVCgQmHWa1WLCwsYHR0FBqNhqjb2ykcFo/HMTQ0hGAwiPb29geWLK/FdoiJbLXDfLsxmK985Sv4/Oc/f8e/Lysru6fjMbB132QyEcuF/bulpYVes1aohyUiH/ds2yNsDcyqprCwcMuuFHeC2WyGx+NBZmYmWltbt7Uw7nQ6yX4yLS2NsxYYDAZ4PB5UVFSgqKgIkUgExcXFtBEeHBzE6OgoiXyy86qqqoJMJoNSqbytKrjH4yHWzvLyMo2puN1ulJeX48qVKzCZTOQiEo1GOc/w8PAwCUQ2NTXB5XLB4/FQt5bpF7AYwufzST+FUVHr6urg9/sRDoc5BeozZ87Qcbq6ulBYWIjJyUn09/djYWEBlZWViMVisFqtGBgYgMPh4HznYrGYRoPKysogkUiwsrICrVaLM2fOgMfjYd++fcQqcrlcWFpaQkNDA06fPo14PA6pVMpJqll8TqVOpzK+pFIpsrKyEI/HodPpqKjNEn9myzQ/P09UZhZbGB2arUOsaQAk1+yysjJkZmaSSjSfz8fy8jLFEYfDAZPJhLy8PGRlZcHj8aC0tBQmkwk2mw1vv/02FegHBwcBJNc9v9+P4eFhaLVapKWlwWw2Qy6Xw2g04tSpU/Q6liwz32eLxUKxdWxsjFTiX3zxRRKXA4DCwkLo9Xra9xiNRg4Nm82TFxUVwWKxrFO6vnbtGmZmZlBYWIisrCzU1tZyYnron3+I8NtJtqT4icchSGFGrEWqcFh1dTX8fj91n6empiCTyaj7vN3CYQsLC9Dr9Whra/vYnDu2Q+dkK7He7/f/QsX6hzph3gyYdRKAbRPfWvv+w8PDcLvdJDSxXWDiXkajER0dHZicnOR0NIP/8i/w/cmfAgDS3j2GtDd+so6WFb81hxmbm6e/SyQSiJw7B/D54N1G7Mz3O19B5L3jEB09Asmv/DL8f/AHEM/NY/9v/Dp4PB70ej0t/qwax+ZKmapheno6vF4vlEolJY+pglsCgQB1dXWIRqOkbpxIJCCTyWiOuLS0FDabjarazzzzDNGHgKTpPbvmbB7Y6/WisbERIyMjqKqqooSwsrKShCAMBgNEIhH4fD6mp6cxOzsLgUCA/Px8BAIBzM/PY8eOHaioqACQtG7weDzkjxwIBDjJMgtMQqEQQqEQwWCQEygBUJfUZDKhra0NQ0NDyMvLg0qlgs/ng0Qigc1mI9snIBl4i4qKMD09TaqjIpEIpaWlmJqaomvJCgiseOD1esnvkAV31hVhf5MaCDYKCHw+Hx9++CFCoRDm5uag1WqhUqmwY8cOSsLXCqj5/X50d3cjJyeHFtfUea1ULC4uIhQK4ciRIxgfHydlVIaRkREMDg5CJBLhpZdeWreIu1wuouIHAgE8/vjjdEz2c6bqfScVeY/Hg8HBQWRnZ1Pxh8fjkYhFRUUFgsEgCYfp9XqIxeK7CodtBsxXNRwOo729/YF2se+GrYiJ3EkI5Ha4U8LMRMIeBEpLS5GTk4PTp09T0GSe7r/2a78GAOjp6SFlXzZP+eGHHyIej6Orq+uBnNcj3B2bSUrZuEooFEJRUdG2dybY+8/OzkKtVkOr1W5rspwq7hUOhzmdXZfLRYljIpHAgQMHKF6yIhfrjKYKbAHJJM3v999WxGZ2dhZXrlyBTCbDoUOHMDMzg2g0isbGRkilUgQCAWoIpFo7OZ1OZGRkkOAPAJobB5JrCEuufD4fWltbSZxSqVRCIpGQgnMkEkFmZibq6uqIbrtjxw5UVlbiRz/6EYBk8swowyw+RqNR5OTkwGg0Qq1WU2Kcl5cHv98Pu92OiYkJEvQMhUK4fv06gGSCzuKExWKhzXlaWhrS09NpPGdxcZFT/GbFB7vdDplMBq/XS5+FFZ3ZnnNychJHjhzBhQsXIJFIUF1djZWVFeTm5uLKlSsAPhLz9Pv9aG5uxtjYGH0+Ho/H6erHYjHMzMxgZmYGzc3NePXVVxEIBGCz2WA0GjkxNnVmmn0um81GrKC1a3pfXx/m5+cxPT0NnU6H3NxcdHZ2cgoBqVRV1sk+dOgQR2yPffdrO/GLi4vYt28fjdClUv1TXVIef/xxfOYzn1kXV5h4mNFoxFNPPUXFn7jVivj8PATdXcB3vwd+Xh74t4n3sVgM/f39AJJ7R3bejE3G3B2YwN3w8DDi8TgyMzMp3t9PQXtubg7z8/Nob2/fkj/7dmErOidbifWsAbYRfh5j/Sc6Yfb7/ejr66MbfLtpFqnv39PTg0uXLm3bLF4kEiGF5O7ubsjlcqrOJkIhgMcDP+dW5UQiAU+joZs+9O67CP/gnyH95X8P5d/8LwT+6q8h2vcRjTVy5iz8v/t7AAC+Wg3Rgf3rjh+7VS2OTU4CiQTgciPy9ttY/Y1fQyCRQG5uLrQZGUAohJaWFqK2Li0tYWhoCFqtFiUlJVhcXMTKygoOHz4Mq9UKiUSCCxcuAEh6E5vNZhI0CYVCqK2thcvl4ixWjA6bmZkJr9eL8+fPQ6lUIi8vD4ODgzAYDHjsscfI8snr9eLq1au0wTly5Ajcbjc++OADWtAtFguHYgwkg1NlZSU8Hg9ycnIQj8dx48YNZGZmYnZ2FiaTiay3mOp1PB6HUqnkVKpY0IrFYjh06BB6e3s5QcfpdOLGjRv0fbHubk1NDXXRU197+fJlopKz862rq0NHRwfGxsYwMjJCx2SVaubTGAqFkJOTg8XFRVgsFo5SeqqnNFPYLigoQFFREZRKJW2GgOSiajabSfW9oKAAS0tLyM3NxeLiIiKRCKLRKKLRKPR6PWfud9++fVhaWuIkrbFYDOfPnycV0t27d6+7B9mmgZ0zoz0y8TCmWgoAu3fvputjsVhINObJJ59EfX39HRPa4eFhzM/PY35+HkVFRRvODkulUhIOi8VicDgcsFqtmJiYQDgcpo6MTqfbtFAX6wpFo1G0tbX9TJPltdgooLJAyrrPqZsi1jXaDDaiaW0FbGbSYDAgFouRcEtFRQUl5DU1NfizP/szvPDCC+DxePit3/ot/Omf/ikqKyvJaiIvLw/PP/88gKSOweHDh/HFL34R3/nOdxCJRPClL30Jr7766iOF7IcYsVgMIyMjcDgcUKlU2965SX3/zs5Oog9vBxKJBKanp2EwGNDa2krzsIFAgIpVYrGYOrsKhYKeR4fDgZs3b0Kr1aKtrQ2xWAwymYyey3A4jFOnTlHymirqxZBadFxaWiLByfn5efB4PBQVFaG8vByrq6uora1FXl4eAoEA0tLS8Prrr0MoFGLfvn0AktRsjUaDnp4eaDQafPDBB7TGX79+HYWFhSgvL0csFqNCpMViwdzcHEZGRkg1G0iylX7605+Cx+OhoqICJpMJb7zxBh5//HFkZWWRACUrJLjdbrS3t6O6uhpnz54l2rrX66XEnc3dAqCkEEjqtrBiOpu1ViqV5B0vlUpJZNLv99Pegd0DoVAITz31FIaHh9fZVl28eJHcICwWC2w2W3L/pNVyxE6ZQneq5gpzF3jllVdI3Zp9P3a7HUKhECqVCkqlkhoV0WiUEmxWdGGsMQDk/pGeno7q6mpIJBLk5eURtRz4SJ2b0eUZzT8ej8Nut9N+gak7MzCPb41Gw4mD169fh8lkwtzc3IbijqlzrYw5ByT3UqOjozRrbzab0dnZ+RFbMBSC+6mnkbA7IP3t30JaXy8gEoJ3m1hkMBhI5E6n06G4uHjda5h2T6pwmMViIeEwVixjDYTNFs30ej0MBgM6Ojq2VU/hfrFZnZNoNEoiaY9i/cZ4qBPmO1GyrVYrBgcHkZeXh+rqapw8eXLbAhyQXHgHBgaQm5uLmpoaTsflfsGEyZRKJWc+SiAQID4zA9vho+AJhUh7522kHX8PPLUK/JwcusmD3/gLJIxGBP78LyB+8QXEbtxA4MYNCHu6ISgqAj89Hbj1kPNSOu7R/n4E/udfQXz0CBTf+H/h/3+/AdHBgxB1tCO+uITgwQP48NYsUEdrK7r/7BtIGI0Q/95/QtsXfwUAyHLIbrdTgsQCpkAgQE5ODhnee71e7NmzB2q1GgaDAefPn4dCoUBXVxcmJyfJz3J8fBxqtRqJRAIDAwOIxWLwer2IRCIIh8MwmUxwu92c7n7q/NX8/DyGhoYoeKjVarS1tWF4eJhslZggiNlsxuHDhyEQCHD9+nUKPCyJstlsVMlXq9UoKSmhBZgJSrFgw+fzYTKZ4HA4IJFIyDaDUa7C4TCJgwDA5cuXkUgkoFAokJ6ejqWlJRQWFsLr9RLNnIHRr5aXl1FVVYXx8XFkZmZyktKrV6+uC97d3d3o7+9fp7jNhFRYJfGDDz5Aeno6mpubcePGDTp2ZmYmBgYGoNfrEYlEoNfrsXPnThQUFGBkZAQrKyucyjGQLFSliq+VlpZCJpNBo9FQl4IhFovh4sWL8Hg82LlzJ1QqFTIyMjhV3atXr8JsNtPcVG1tLWcBT/1s7L67E3JycqDX65GRkbGppFUgEFDArK6uJuEwo9HIEQ5jG42NAipb9OPxONra2rZ1BnK7sVFAZarkEomE5unYa+80+8yE1rZjw/BHf/RH+P73v0//bm1tBZDcQO/fvx9AssOTqgfwe7/3e/D5fPjVX/1VOJ1O7N69GydOnOBs7n74wx/iS1/6Eh577DHw+Xy89NJL+Pa3v33f5/sIDwaBQIBooD09PRgZGdnWWM+8aPl8Pnp6eiCRSDa0qtwKmDCZ1+vliHuxZ+rYsWNwuVzYu3cvXnjhBfKyZyyy1LlQRqcGkt3EyspK0usIhUKcURXmeyyVSok9JRKJUFJSAqPRCIFAgNHRUQQCAaysrEAikcDv92NkZASPP/44gOSzxRwLUm0hQ6EQ+Hw+pFIp6uvrMT4+jkgkgsrKShQUFMDn8+Gdd95BLBbD/v37aV66p6cHi4uLkMvlZKnIkkMej0fHYIXatWCFzOHhYUpExWIxWltbyWqorq6OhK5mZmZIrG1xcZHoyUwIyOfzUaIdi8VQXV0Nm81GBe1U5hzrXjNtk6KiIiwtLVE32uPx0P8AUEEfSCaZo6OjRP/d6B5ZXl7G4OAgiouLMT09DT6fT10xIJlQXLt2ja5VIpFAU1MTDAYDXC4XZ5/Mkn23243MzEy8//774PF42L17N4xGI/1eKBTCbDajv7+f9gclJSXYt28fbDYbBgcHiZHFIBAIUF5eDr1eD71eT5ZRmZmZMJlM61TkR0dHMT09jebmZuzduxeJRIJTbJ+cnCTV74KCAjzzzDPcgnY4goQn+R0lrDbwJHfu/mZmZlKM34wqdapwWHl5OUKhEDHN5ufnIRQKOUyzjeI4G9lcWlpCe3v7Q5Usb4SNiuUmk4mo/WtjPfv/G4HNvd8vPimx/uHdxd0GiUTS3H1mZgZ1dXX0ZQkEgnWU0K2CzRSvnVfejiDK5nDY/FXqZpvP54M3PgH4fEgAiI6NQfL448mOj8eD8MWLEHV0QPKplxH8u7+H+FMvQ8DOT6mE9wv/HgmXG6p//gHU776TPOfKCnr/wLe+jejly4heuwbpb/1HxG72InazF+Lj70H1xk/A9/nAvzX/IubxkbiVGHpWVnDjwgWkp6ejpaUF4XCYkl1GYT537hyi0SgqKytpw+1wOGgTzgKcz+fDzMwMfD4f5ubmoNPpoNfrASQp9TweD+Pj4xSoWbX0xIkT2L17NxQKBXkIikQi7N27F2fOnEEwGKQKvdvtxvz8PPbu3Yt4PM6hTQ8PDyMajXIsfZjic29vLyXujGrCFL6ZArXFYoFGo4HX60VzczNVwUO3OvE9PT1Uab5x4wZVwYGPkvycnBxKECcnJ2mWjXVc29raIJPJKAFVqVT4zGc+A5/PRzTv9PR0TqeaQaVSoba2FsPDwxwFU9aBEAgEVI12OBxUda6urkZNTQ0GBwdpVo3h8uXLePnll9HW1rbOGoJhcXGRAh9Tej969Cj5XTM4nU4SgTMYDESnAT7qOLOOvkKhQF1dHT0jk5OTmJqaQlNTE81ObWaxZoJgQqHwnimWdxIOY1XQVDqXSCRCNBpFf38/eDweWltbH+pkeSPweDzMzc3BZrPRc5I6D3U326rtElX5x3/8x7v6Mq4tqPJ4PHzta1/D1772tdv+TUZGBl577bX7Pr9H2D7c7rm02+3o7+9HTk4OFc62K5kFkutRf38/tFot6uvrORvE+z0G8xoWiUTo7u7mFAWZgwTr/hqNRpSUlEAmkyEajWJ1dRVyuRzFxcVYWFhAZmYm0tPT6bMvLCzg5s2b6OjowNNPP71OSJF1uwBQcRZIrlUHDx4Ej8fDsWPHKI6yhMntduPmzZuIRCJoaWkhIavS0lIoFAqEQiHo9Xqsrq7SmsiYR6yQ6Xa7qaO4sLBAXV+mjpxIJFBcXEzKxmz8KT09HW63G729vejp6YFOp4PH40EoFEIikUB7ezsMBgPtJZgN59DQEJ555hnSNWEexsvLyzh16hSeffZZyGQyuseqq6sRCAQgEAigVquxuLgIsVhMPs0s1nu9XmRnZ8NkMnHo3UznY9euXQA+Kk6k2laxdUmlUlEXm+0dWIxgyWNlZSXef/99Ys+98sorNK4nl8uRn5+/ToSLnUdnZyfOnDkDkUiEjIwMoo87HA6kpaXRfgdIao3E43Hk5uaiqakJHo+HxNIY5ufnUVBQgJKSknUzxgzBYJD+bmpqCnw+H0eOHEFVVdW6dZ8df3x8HEePHqWfx2IxhMNhTgEp1Tki2tcH/x9/FcI9e6D6p+8jOjQMycsvb3g+qVCr1Xj51uu2MkbFGh/ME5sxzZhwWKpFpVwuJ1u7lZUVdHR0bIuF7ccJpkw/Pj6OxsZGZGZm3pPOid/v35YO8ycl1n+idnKxWAyjo6Ow2WzYsWMHp1qXai21VcTjcYyPj8NoNKK9vX1dhep+AjWzZZiamuIk+kBSgCvwN3+LNIMB4c99Fmm/9O/AE4sh2reP6BO+//z7iL7/AUIVFdAcfxey3/zyR+dVX4fYrB6+/5Dk7kevXYf0V345+d7xOKLXr0NQUgrx4ScRvXYNoiefgKDwVndYLseHU5OwXL+GPXv24AmBAJ4zZ5GXkwP+P/w9ov39GGlrxcLcHNHUGHWXUblSZx8sFgtVuoVCIUZGRiASiVBdXQ2LxUIJlFqtRlZWFic5S09PR3Z2NqqrqxGJRGC1WjE1NQWfz4doNEqKywyRSITUqQ0GA2prazE5OUkL8bFjx+D1eok+5na7aS4MANkrhcNh2Gw2BINBLC0tESWOeUEmEgmIxWKqNhcXF8PtdmNlZQVFRUU097O4uIjq6mokEgmcO3cOwWCQQ8EuKChAR0cHDAYDzSQHg0H6+/z8fJSVlZHSZnl5OZaXl0mR/erVqzAajdQ5ZzN2ubm5KCkpoY0Co56xjQWPx8Mrr7yCUCgEs9mMUCjE6RgAINE5pugpk8mgVqthMpkgl8vv2pllmwK20Hq9Xuqms89pMBiQk5NDGwCmrgkkN67M5iszM5M6y6kb6YGBAUQiEYyMjGzo4XwnbBcd+nbCYfPz8yTIEwqFIBaLSUDnkwRGHzWZTOjo6KAN0O3ERFJtq1gw3a4O8yP84iI1Xm5UuN6O4vjy8jLGxsZQWVmJ4uJizlrDkrGtwuFwoL+/H9nZ2esYMqzgL5VK0dnZCavVioaGBhrhmZmZwfXr18Hj8fD8889zKK7PP/88IpEI3nknWRBfWlpCTU0NxVyHw4FEIoGcnByIRCJIJBJotVrau9hsNrz22muoqalBR0cHbty4AYVCgebmZnJ+YPoVCoWCku7JyUnU19cDAP0sEonAbrdTjGT2fU1NTSgrK4PZbEYikeBQX1nsVSgU6xKTlZUV6gIPDw9zkkQgWYDIzMzE3NwcvafJZEJaWhquXbuG6elpNDQ0ICsrCyaTiXOPGI1GOjYTLAM+sltiPsPs3Fisj8ViaGhogNvt5rhKGI1GmqHv7+/H4uIiZ3+oVCqxZ88eAKC4BiRnXGOxGBQKBRobGyESiWCz2VBVVYW+vj5UVFSAx+OR6BlDYWEhdfW7urrg8/mg0+lw7tw52gexfcb+/fsp0U+dSWZr9erqKjQaDWZmZgAk1242ggXgrmu3SCQiUTP2vl6vl57ReDyO+fl5qFQqNDQ0YGpqCrW1tZzzePfdd+F2u5GdnY3y8nI0Nzdzku3gD/4ZsYkJxCYmIP2/vghpSrf9btguq9dUi8pUphkTDpPL5RAIBAgEAmhvb//EJcsAaDSysbGRmBf3onPyixbrH+rdXGoAY7QsPp+PnTt3rptDvN+qczgcpg35zp07OfQmhq1WnVkizjaha4XJIufOw/8/vgUVAF9pCZR//EcfbUjZ8YK3aKgp4hQAEHrrLcQmpyD5lV+G5Fd+GXGLFeKXXqTfB/+/v0Pwm/8DPLUayh/8IyAWI3L2LGT/8Tehfu9dhOQymG7NCC0tLaH2v/8l0pwuhIwmxP/p+xC2NCPP5cL0wgLUajUVKZiYll6vR2trK6qrqzE+Po60tDT09PSQcjFLDFM7vS6XC88++yzUajXee+89AMkkKVUQSq/Xw+1206Y9HA4TbUwgEIDH4yEYDOLs2bMUGBkNms/nQ61WU9V8enqaqByNjY3Izc3F8vIyJcyM6jwzMwOxWAylUkmzGWwR7+zsxNmzZ+H3+zEzM8MJTpmZmYhEIpwiCFu0xWIxvbajowNzc3McsY6KigpYLBaykrp69SqcTiekUileeuklzjOQuiCz2Wggee+urKwgGAwiHo8jPT2dMzslk8ng8XgwMDCA5eVl5OXlUeXa4/FQUGWdfiA5l6zVakld9W52BLOzs8jPz4dCoYDD4UBVVRWno3Lx4kUSblmrpM3uCfZspaen0+YkkUgQ9Y0VRNZSwn9WWCscxq4xGym4cuUKdDodtFotdYceZrBqORMh3KhLfDcxEafTSbP/j/AIW0E8HsfY2BjpKayNl/dbHGfiiIuLizRTvBas+LcVsES8qqpq3QxlNBolbQeVSkXaDqlzhey4qfOFQJKlNTc3h/LycnR3d8NgMKChoYHzeyasdOjQIcjlcrhcLjgcDjz33HOIRCJ07Lm5OQQCAbjdboyOjqK0tBSFhYWQSqVEec/KyqJ9VTAYxL/+679SQdtkMkEqlWLnzp1E2f7www/pXFgsYXPV1dXVlAzz+XxKvoFk53lubo5ihtFoRGZmJhW/mfBW6pyu3W6nuF9YWEhJ/sLCAiVyBQUFqKurg8lkosK8QCBAcXExZmdnEQwGUVBQQF3SrKwsOBwOtLe3Y3h4mEbBUpWvKysrsbi4yPHzZet66n3Z2NgIv9+P6elpel1mZiYUCgVWV1dRX18Pm81Gv3/mmWfwqU99il67NvlaWVkhZt3Kygo8Hg9mZmaQlZXFKSzweDyEw2HMzMygt7cX6enpxJBKT08nsbL5+Xm6fo2NjWhqakIgECBR1lRRubVYuLUXLC0thdlshk6n4+x9JiYm0NfXRwWf1HsUSBZa2N4sHA6js7PzIwHRwSHEzWaIX3gO0evXIdq1C7yfoXhWKhQKBRQKBYqLi6kx4XQ6wefzcfPmzW0TDvu4YLFYMDQ0REWmtdiMzsnExAQ6Ozs/7lP/meGhTpgZWLWW0YA32rzfT9XZ4/Ggr6+PZl9v1xXaSlKemoj39PRsmIgLKsoBhQKJcBiR4hLahIbPnkXgq38C8ZNPQv5nX4f/P/0eeOlpSHi84KmUiC0twf+f/jMAgCcQQP6ff2/deyduJYqJQACxsXHg1vyKaXgYpsJCVObmoLmuDsapKdTosiB+9VWE/umfYX/lU7j4zjvg8Xh4+umn8corrxAlQ61WQyQS4fjx44jFYpiYmEAgEEAsFqMuMvPEGxoaIol/BpFIhBMnTqC4uBiNjY3o6+tDOBzGtWvXsGPHDng8HlKcFovFHCGTlpYWnD17loJY6neeWvGMx+MoLy+nyvClS5cglUpJqCQVpaWlmJubo6osS0T5fD4l+W63G8XFxRgbG6OkXSKRQKfT4ciRI4hGo1hYWMA777yDoqIiEkHTarWYnp5GWloaQqEQbRoYfZwpSQPJQJRK+wKSRYDLly9DIBBAIBBgx44dWFpaAo/Ho8SbzdwwsEBXUVGBnJwcXLx4Ee+++y79nv2dxWLBU089hf7+fjgcDmRnZ2N+fh7xeBwLCwvw+/3Q6XSYn5/H9evXodPpEA6HUVZWhrq6Ono/i8VCgZhhrYJt6px+KhYXFzE/P4/c3FwolUpkZmZyZrdmZmZw7do18Hg8PPvss2hqasLDiEgkgtHRUSiVSjQ3NyORSMDhcNC1YcJhLIHerHDYxwU2h8WoZZuhVK+dffb5fPj85z+P/Pz8B6aO+Qg/n2BrVjAYpNn/nTt3bvicCAQCjojQvSASiWBwcBCBQAA9PT23pRNuJdZvNhFPT08nYSW2CfV4PDh//jzEYjH27t0Lp9MJt9vNiW8XLlyAz+eDyWTC008/vc6SJbUj7vf7qUi8srICt9uNnJwctLW1ob+/HyUlJUhPTyf7pRMnTiAajaKrqwsvvpgsuPP5fDz77LMk/hSJRLC0tASHw4FwOExK39FolPQcXC4XsrOziY3G4/EwOjoKvV6P7u5uLC8vIxwO4+LFizRffPHiRQSDQTgcDhw9epQKog0NDejv7+cknRt9VrPZjObmZkxNTZF7hs/nQ1VVFU6fPk00bSDJ4lpcXIRGo0E8Hsfc3BwAUMwDksl+Q0MDFeDFYjGpdefk5GDHjh2w2+14/fXXIRaLcejQIeTl5SEjI4MUwUtLS/HjH/8YkUiExq1sNhvR0x0Ox7rPFQgEyLVCIBCgoaGBrBgdDgdnrj31ewaSyXhXVxdOnTqFy5cv033NxEi9Xi92794NrVaLqakp2uswwbSZmRnodDrEYjG88847JHyqVCqxc+dOWuMTiQSuXLmCRCJB8/QajYazJ2exnrGOGFwuF4aHh6HT6ZCVlYVYLIY9e/Z8pMC9sADPpz4NJBKQ/7c/Rdrlj0RLHyawwrLP50NPTw+kUikVVtYKh+l0um21qNwuWK1WDA0Nob6+ntOouh020jn5sz/7M2LH/KLgoU+Y2TxxdXU1CgsLb3vjbbXDbDKZMDQ0hNLSUjI2vx3uteqcKu51x0S8qAgZVy5henISMZmMKs3h1/4FieVlhL73PQi7OxG9dAkAEGpphfjwE+CnpYGn0yFhsXA86WJzc/B95XfBLy6G7I//CLG5OYDPh3DfPki++CsAj4cPAgFERkeTqqBv/RQFx0+AX1gI+YenIP/K78A+OwvcWhjD4TAn0WEV/5aWFgwNDUEoFKKkpIQEr376058iGo1i165dkEgkCAQCNNMai8UwPDyMlZUVTE9Pw263U6Lr8XjIW1AmkyEYDHJEJNxuN06fPk207MLCQlRXV2NqagoOhwNisZiSz76+Pko+9Xo9gsEggsEgVTaBZNeY0bpUKhWHxqXRaNDQ0EAJv1qtxqVb11+pVMLr9UIul0MsFsPpdOLEiRMU0NjmgFGU6urq4HK5oFAoyLKKHSdVwGpxcZGCzP79+8Hj8TA7O8vxguzr6yOlz7WK2wyMeqbT6TgbLmbJAYAKGlNTU5iYmCA18KeeegqBQIBDPWKiIkwpnAnw5Ofnk4WQXC5HKBSiTRLrap88eZKq3gKBYN0M9KVLl2hmb/fu3ZtWL/T5fBgZGYFCoYBQKERpaemG6tcfB8LhMHp7eyGXy9HY2EjBhVWbmRCWxWLB6uoqJiYmoFAoKHm+nXDYxwm9Xo/l5WV0dHRsaSYpGAziM5/5DEKhEHlaP8Ij3AvYPHFmZuYdle8FAgHHBmiz8Pl86Ovrg1wuR3d39x3HNO6VTRaNRjE4OEib6Ns9QzweD0899RRWV1eh1+spZrBEFEgmgLOzsySC2dnZCblcjoyMDPh8vg1FFP1+P3bv3o26ujqale3u7obFYkEwGMTIyAjGx8fR3t4Op9OJwcFBPPvss/j0pz8Nn8+HN998E0AyaUtNflhXraamhlwYCgoKMDs7i4yMDFy6dAl2ux1VVVVIS0uDy+VCKBTCs88+C7fbTeKpTCE6Vdl6fHwcLS0tyMrKgsFg4HS5mMtCalLW0tICu91OYkw+nw/hcBhTU1M0d8z2FEByb8e+w8rKSiiVSrhcLhrNYnFVLpejsrISNpsNFosFJSUl6O3tBZCMk5FIhNSqY7EY3nvvPSpGBAIBOBwOivUVFRVwOp2IRqMkNroRtT/VDrKpqQkajQazs7Mct41UNe3c3Fysrq6uex/2HCiVSshkMjqWTCajfZJQKERubi4WFhYwPT0Np9OJSCSCQ4cOgcfjUaxnI2+sGOL3+2Gz2SCXy1FSUkIjVvn5+VhaWuKousfjcZw+fRp2ux1isRg8Ho9cQRiY48n8/Dyam5vR0NCwPu7xeEnXlpSfJyIRBP/XXyMRDIKXlQXRrp0QbrOl3GaRSCQwPj4Ou92Ojo4OaoBpNBpoNJq7CodlZmb+zJlmNpsNQ0NDqKur25IfcSKRwDe/+U185zvfwcWLFzkq6j/veKgT5unpafI0u5vi3b3StFhio9fr0djYuKkb516ScovFgsHBQRQVFaGysvKuG2K+UgmeSoWAx4NIJAKRSATpv/0s/Ho9RIefhLC+Ppkc+3wIff/7CPzpn0L+X/8YmpPvI+F2g5+iKhl+66eIDY8gNjwC0e49iH6YpFyHW1og+I+/CbFYDPWJE7DZbEnbHlYESCkGlJaWkt3FRt2iVFpXLBbD0aNHiYrNuo02m40W7ZWVFchkMhKlcrvdKCwshFwu51gqnTt3Dg0NDTRHdOXKFahUKhw6dAgGg4HeTy6Xo7W1FWq1GtnZ2fD7/RCJRDh58iRVwBlSuxEsuZNIJEhPT8eVK1co0KdSm5j11XPPPUf/ThU7Yp+P2SKwxFStVqOyspJe4/P5cObMGTidTlRUVODIkSN44403AHwkJMZmwLxeL3bt2oXc3Fx4PB6aCzIajRQYRSIRJczhcJjuK+ZLyWbKo9EoSkpKyAsS+Kja3NraisLCQrz99tuc75R1wllxigmgqFQq6mqz87hx4wYxJ9jnaG5uRklJCQllTU1NrUvoFxYWkJubC5fLRd+BxWJBYWEhJcuJRAIXL16EyWTCzp07sX//frp3GIaHh2kGC0huMvfu3YuPGyxZVigUaGho2JD9kiocVlpaSvP5qcJhqQH147afmp2dxeLi4paT5VAohM997nNwOBw4efLko2T5Ee4ZNpsNN27c2HCeeC22wia7k9jm7Y6x2VjP7CclEgl6enru+vzy+XzIZDJEIhEEg0FIpVIUFRVhfn4eIpEI2dnZyMnJwerqKqLRKN58803k5+dj37598Hq9nHWQdbWA5No6NTWFaDSK3t5e7N+/H2VlZRgeHsby8jLn2U7V8lAoFDh48CBcLtc6VWQGRgMGkiKKjPXFPJSZNQ+QLPyq1WoEg0GUlpbSfG9FRQUWFxeRSCTA5/NpTI2t+wsLCzAYDDhw4ADi8Tgly0KhEE1NTSgsLKQiuUAgwODgICYmJiASiSjes5jICv2ZmZnw+/0oKCjA4OAgIpEICgsLiTIuEAjg9/uh1+sp1gPgJJvhcBiRSAROpxPBYJCSZYVCgaysLOrQhcNh6ogrFAo8++yzxBRg+iIMkUgE5eXlaGpqotlyRulN1R5h31Gq5ghrIqSlpaGgoABGoxG1tbWchJq9R1FREbq6uvDee+/R9wAkKe2XLl3CgQMHkJubS6y8nJwcTExMIJFI0N5kfHycfsaeC61Wi/3795NYm9frJWYe+5x6vR5tbW3w+/2IxWJIT0+HwWCAUqlEfX09PYOh1/4PAv/jW5B8/pegev3HiJstHCvUyKnTCP7N39K/QyoVNDev39Za6kEhkUhgdHQULpcLHR0dt2WJ3U44bGpqCqFQCOnp6dR93ohx+iBht9sxODiI2traDZXo74ZEIoFvf/vb+Na3voUPPvjgFypZBh7yhDk/Px+5ubmbuqnuJcBFo1GMjIzA6XSiq6tr0wbjmzlGIpGgSl59ff2mOmYseGk0GqysrODChQvJB6qiAtrj79I8hOb8WSTcbri6kwrB0aFhSD77GfBuiVRFL1wAZHKIjx5B+O23wdNlQbCrB7ysLCQcDgzk5WL2xz9GZWUlDqjVMP+vv0F6eTnkX/86IocegyjFzJvP56Oqqor+zYS9eDweotEohoeHqUKbGnzT09NRW1sLi8VCthc+nw+JRALXr18HkKRaeb1eTE9P44UXXkBNTQ0SiQT+9V//FQBIhRhIbsZDoRDGx8dRXFwMvV4PmUyGvXv3Usd+cHAQIyMjyMnJQXp6OlwuF5qamiASiWA2m6nTDCQ7tMFgEH6/H+fPn6c5LjZrxrrHQDLoTE5OQq/Xc66FRqNBRkYG8vLyMD8/T7Su0tJS9PT0UNLkdrvxzjvvUKLt8Xggl8uxa9cuWK1WqFQqLC4uQigU0uZAqVRieXkZV65coYCZWqXt6enB4OAgPB4PZ9PI/t5gMOCJJ55AOBxGLBZDRkYG5ufnKakFPrKxYEj9zCyILS4u0lwYw2OPPQapVIozZ87A7/dTYGTvazQa0djYCIvFgvn5eaSlpVFF1WKxQCAQoLq6Gnq9HpcvX4ZQKERmZiYOHTrEKViFQiGix83Pz5MiNgDavOh0OszMzNA1Yt1ldt6lpaUcBe4HgVAohN7eXqhUKo7C7t0gEomQm5uL3NxcEg5L9SrVaDTUfVYoFA+0+zw3N0fJ8lZESyKRCD7/+c9jZWUFp0+fXjdv+giPsBmkp6dvOK+8Ee6lOL6VeAxsfj/BxsVycnLIfnIz5ySRSCCTyXDp0iV63vft20dr/cGDBxGLxXDq1CkAyZjImE7suG63G7m5uTTHmp+fD6vVSpoPP/rRj6BWq3HgwAESc2SJNxN1ZMjLy6Nrk1oYZq4kqfaIqSy7rq4ujI2NoaysDOXl5Zifn0dhYSHZTzY1NRENOR6P49VXXwWQtKdcXl6mjjTwkR3SwMAAdu7cSYXjffv20dpkNBpx+vRpiEQiNDU1gc/nUxI9NzeHaDRKxzMYDPTeZ8+epaSaFQ4EAgHtW3w+H8xmM3p7ezkCc8xuinWYmSd0eno69u/f/5FfcCKB48ePU2LL5oF37dpFs8azs7OQyWS0XxCLxYjH4zh27BidB4/Ho85tZWUlNSZSi/kOhwPxeBw2mw2dnZ3Iz88nf2zGUGPfkdfrhc/no2vLOubMcxdIxtSzZ89yVIjr6+tRVVWFmzdvUpGDXQ92P4pEIpp512q1dB4ejwfhcBj19fXweDw4duwYKYvv2LGD01AAgOAPf4iE04nQ938A2W/8Ov08EYkgvrQEfmUFIJMB4TAQi4GnVgE8HmKGRXh//TfA12mh/Ju/Bu8BJp/xeByjo6PweDzo6OjYNJttM8JhqRaVm91DbAV2ux0DAwOoqanZcrL8ne98B9/4xjdw4sQJdHR0PICzfLjxUCfMCoVi05XkzVadUz0dd+7ceU/D+XejaTGxEovFsk7F+3ZIHaTPyMjArl274Pf7YTabYTAYMDY2hrS0NGRlZSUrUhkZUHzrm4hevwHp//Wr9D6RD07C96WkcrbyX/4PEsEQ4v39iJ54H5ozp4FIBKaTJwEkg07DlatQTU0hOjUF12//RwQ6O5F7my77wsICLl68iMzMTOzbtw+Dg4MQiUR4/PHHaQaKRBtuCQEkEgkMDw+TqAmb10ndiMRiMRiNRszNzaGiogJtbW2YnZ1FXV0ddDodjEYjQqEQXC4XBgcHEQ6H4Xa74fF48Prrr0MkEuGpp56iyrbVaiWK28LCArq6uhCJRKgCz+ZyWIKnVqspkNTU1KCxsRFyuRzvv/8+XC4XhEIhent7EY/HyTIJAFHs4/E4Z96ZBXAguThdvXqVAld+fj75F5aUlEAikZBISnl5OQXk9PR0oj6zIJXapV1cXCTKGQusAMh+q6CgAC6XC++99x4SiQSOHDmC559/HlKpFG+++SZCoRAFbCAZoL1eL4RCIXbt2oX8/HyO3UMq+Hw+RCIRFAoFVCoV+Hw+KUI7nU4IhUJMTk7SNWNob2/HE088Qf9mKqvRaJRDCwqHw9Dr9dDpdKitrYXJZOIUKoLBIN5++22Ew2Hs27cPL7/8MhKJBJxOJ1X5JyYm4PP5MDo6iubm5geWbAaDQfT29kKj0XCq5feKVOGwyspKosNbrVbMzs6Syu2DEA6bu6V8v1WFz2g0il/+5V/G7OwsPvzww3UenI/wCJsFm+3d7Gs3k8yyTa7Vat10PE49xt3Gr5aWljA+Po7q6urbWvBsdE7xeBwikQg7duxAOByGxWKB2WzGzMwM5HI5xXq1Wo2uri5MTk5yHAWCwSCOHz+OeDyOlpYWSKVSEtg8ePAgWS0BIDeHVI9juVx+WxaIx+MhVefDhw9jcXERNpsNe/bsoTU+lXE2OTlJ7IBPf/rTKCkpgdvtpkJmagLg8XgwOzuLtLQ0NDY2IhgMorCwEGlpaRgbGwOPx4PZbMby8jKuX78Oi8WCaDSKU6dO0ZrP6NThcBhzc3M0h9zR0YHMzEyKLTweD+np6SRoyYRDgWT8fv7558mLemJiAjKZDAMDA5w5YyDZLdyxYwextljMrampoWQ5HA7j6tWrlNRqNBo0NjZibm4OhYWFaGpqwnvvvUe2RKnd90gkwklUU618gsEgVlZWEI1Gwefz6X5kiT6Lm++++y5cLhc6OztJKPTatWswGAyw2+00cgV8VJRobm5GdXU1iaTKZDLOPoONVQmFQqSnp0OtVsPlckEul8PhcEAmk2FiYgIGgwE2m42+79zcXI54mdlspmMz9hr7nOG33wZPJofsS7+BwP/6G0g/91nOvej94q8ieukyxP/2c0i7fBGJaBSx0TEIamvA4/EQOXEC8clJxCcnER0chKi7e8N7+n4Rj8dpLj7V+morWCscxvzDh4aGEI/HkZmZCZ1Oh8zMzG0VDnM4HBgYGEB1dfWmi4apSCQS+N73voevfvWrePfdd9H9gK71w46HOmG+F2wmiG5GPOxux7id1QSj40SjUXR3d2+qK87EvdiCyc6H0TfLysrI+9dsNmNqaipJA6quRtaePeClbnJTN+yhEBK3kiqnyYT5vj4UFRWhe8cOTJ05gzKxBJLPfRaxyUlEerrx/pUr5OmXmqAwrKyskG3E1atXkZWVhdraWppfSaWICQQCaDQaOJ1ODo2+oKAAk5OTEAqFqKurI3/Ca9euweVyUZAKBAIYHBzE4cOH0dTUBIfDQYJV7PtlHe1QKISRkRHs2LEDk5OTKCwshMViwfLyMhoaGnD8+HHOjHA0GkV2djbEYjEKCwvJRgFIFgVKS0shFArR3NyM8+fPw2w2Izs7G3a7HaWlpRgZGYFAIEB5eTmOHTsGn8+HgwcP4umnn6ZEkmFkZIQS29bWVhQVFeHtt98me43U+aSMjAx0d3dT997r9SIrKwsZGRk0g+bz+SAUCjk0ZHa/8Hg87N69GxkZGRAIBDAYDHStJiYm0NPTAyDp7zw0NITy8nLE43FMTU0hIyMDq6uryMvLQ0FBAU6dOgWTyQSdTgehUAiBQIBQKITS0lJkZ2djYGCA42sNJK1OJBIJVU7XJo/Mc3JgYIDESyQSCRoaGjjqmr29vZidnYVAIMCnP/3pdclhMBik58/pdFInQCaTEX2RVXFLS0vXnUcwGMQHH3yAcDiMJ554YtPMkrUIBAKkQJrqE70dkMlkRD2MxWIUUJlwWKoS5/0Ih7GuUXt7+5ZsIWKxGP7Df/gPGB0dxZkzZzZU2XyER3gQ2EysD4VC6O/vRyKRIGGe7ToGE15aXl5GW1vbpgpFLGax92RsLYlEgoKCAhQUFFB3lCW/AoEAOp0OlZWVty0msIIn8JF4qVwuJ90MiUSCoqIiLC8vkyiZy+VCQUEB9u/fv+79bDYbrbE3b96EXC5HZ2cnuT2sLTpkZmbCbDZzYr1KpUJhYSFsNhtyc3Oh0WgQjUZht9uxsLCAhYUFOBwO2Gw22O12fOpTn0JBQQESiQTeeOMNmqNeq/MxODiIAwcOIBAIQC6XQ6lUYmhoCGVlZbh+/Trm5+dpLWbMrOzsbGRlZRGlGkjuA71eLzIzM9Ha2kpFVqlUCpFIhPz8fFgsFvh8PjQ1NeHKlSuYnZ1Fc3MznnvuOUp8GRiVHABKSkrQ3t6OkydPwu12Y35+nrymgeT6fuDAAVKhnpiYgFarRUZGBux2OxKJBO2FlpeX6X5JLd5UV1eTVkYkEiGK+OjoKO3fGhsb4XK5oFQqUVhYSL7ZVqsVcrkc1dXVmJ6eRn9/P9LT0xGJRIhpplQq0dTURKrs7JqxY+/fv58ELdfuh1P9t1kHVSwWIycnh6OmHDl+HP7fTYrUKn/4z9C8e2zdvRibSIqbxUbHwFMqwQPA37UTsZlZhE5/COH+fRC8+y54Wh2EG7DJvL/zFUROnoLi6/8N4meeXvf7zYA1S/x+P9rb27c1iWXjF9nZ2WRtZrVasbCwQBaVjGl2P8JhTBuiqqqKs9/aLBKJBP7pn/4Jf/AHf4Bjx46RXdovIh7qhPlebhChUHhH5czUavCdxMPuhNtVnb1eL3p7e6FWqzftvZpqx8KC50aQSqW0gWazjxaLBTdu3IA0GETFX/01hDxA9d3vQvm9fwBPLoewvR3Kf/g7RIeGcaOsFOaZGSwsLOC5UBiNf/KnAADee+9A/eYbSb/cn/4UADgbhEgkgrGxMSiVStTV1cFqtSIcDqO4uJiSETYvXFJSQp1kHo+HI0eOIBAIcLpWS0tLFLDMZjMyMzMpsLpcLhQWFsLtdiMQCECj0eDMmTOwWq1EzQoEAqitrUVaWhpEIhHGxsbgcDjI46+rqws2m40S0dRkKy0tjY5tsVjo/Xp6eqhzLJPJMDIygng8zvF6Zqqic3NzOHToEMbHx3Hu3Dmq2K+urnKovw6HA3w+H0VFRSTiJRAIIBQKqQo7PDxM33dVVRVUKhVV/6anp6kbzzrNbLMnl8s5omWpn1Gj0WBxcRErKyscz8NUwbBYLAafz8ex92DCFSKRiCPsxZLijIwMtLe3QyQSYXV1FdnZ2ZienoZEIoHb7YZSqYRUKsXi4iIuX74MlUpFIiNqtRpWqxVGoxEej4djW8WueSpY5ZaJhjCYzWaMj49DrVYjLy8ParWao8JtsVhw+vRpAMDevXvx/PPPYyPYbDa6fqurq1tKmAOBAG7evAmtVouampoHSpdmG2adTkcz7larlYTDlEolJc/3Ihy2sLCAubm5+0qWv/zlL+PGjRs4e/bsloRDHuERtoq7sclcLhf6+/uRkZFxR/Gwux1jo4SZiXv5/X50d3dvauZ/bWF8rXowg1AopA00m320WCykkREIBOD3+9HT04MjR47A4/GgoKAAhYWFmJubQyQSIf0QuVxO3VWtVouDBw8CAH66Qaxnqr+BQIA21TabDSqVCq2trRAKhRgYGMDIyAikUilefPFFKta2tbWhqqqKcx38fj8lkIwKz4oDk5OTUKlU1A2Wy+WYmZnB8PAw6urq8P+z995xdt31mf/79pl7p/fee1MdSaNiWZIlWc2yXCEECEkI2UASQupu2m/DZpcsYQkkQEh2CaSAjQFXycaWZKuPpBmNNKPpvc/cKbf3cn5/jL5f3zsj2SNhjAl6Xi9eyDNz27nnnE97Ps9TVlbG0NCQzDPsdjtWq5WBgQEsFgvj4+Ns2LCBUCjECy+8IKnPAkJIS1EUpqenqaqqwuVyUVlZSUxMDIuLi6Snp8v1l8ihSX5+PsFgkIGBAdauXYvb7eb69esyho6Pj1NfXy/jllCwFk34QCCA3+8nJiZG5oCzs7Py38nJyaxdu5Zr166Rn5+PVquVa09OpxOv1yv/VtDhBSInzKmpqdjtdrq6uigoKJD5jdvtloW4RqPBZrNhs9mYnp4mHA7T0NDAnj17pF2Q2HkWxXAgEODhhx/GaDQyNTUlhayEErpgQTqdThlvdTodSUlJFBUVMTMzQzgc5tKlS4yNjUXl4zqdLupYqxKTbv1DhSoiBoXn5/H8zf9GZTKh2bIZlVq9gqbteOppFIcD/dNPk/DiC9wOit9P4JXjoCj4jh+/p4I5HA5z48YNfD4fGzdu/Klqi6hUqijhMK/XK5lmw8PDUjgsPT1dDkZWA1Esl5eXk5eXd9fvS6xK/sEf/AE/+tGPbttk+0XCB7pgvhvcSTkzHA7T29vL1NTUqrvB7/Qay4OoEPcqLCyUpvPvhkjajSiWw1NTBG+0o9v1IKo7dMMjdx/D4TCW7z+H+tbEsetb30Jz9JGljlQohH/9emK2biWjowPzLUEJ9a1uoKLX0zI5yWx3N01NTaxdu5ahoaGooNfb2yuLybKyMtnFjImJeVus4VbnN3KKC0uBxe12S3EOWKIkC0rp4uIi586dw2QySZERm83G7t27cTgc6HQ6qdrZ19cnb+yjo6OUlJSgUqnQ6XScOXNGKk8DcldaPO7AgQPMzc2RmZnJmTNnCAaD1NXVcebMGWCpYIuklogu37lz5+TPurq6ZOLR3d0tp9Lp6ekYjcaoifzU1BSnT59GpVJx8OBBYmJi8Hg89Pb2UlVVxcGDB6V9R2xsLBs3biQrK4sf/OAHMkESFG+VSoXRaJT2GH6/n97eXoxGI7G3lNS3bt3K7Oys3BO+cOECiqIQCATYvHkz4+Pj7yjKIHwdtVotN27cIC0tjaKiIrxeL4mJiczOzlJfX4/JZOL5558nFArJa2DTpk1kZWXJKbSYYEQWpOLm6na7mZmZYXx8XAZRlUqFWq2Omvru2bOH7OxskpKSooJra2trFE0uLi4uKnhF/u07sUaysrIoKSnB7/dHURxXC7fbTWtrK+np6VRWVr6vytYqlYr4+Hji4+MpLi6WNiXz8/O0tbWhUqlWJRw2NjYmxVjupWEQDof53Oc+x9mzZ3nzzTfvqWN9H/exHHfbHL/T9Hd6epqbN29SVlYmBQjvBbdbv4oU93o3lW2ByJWrSA2QyclJGUPu9PqRu4+Li4uSKt3c3ExJSYm0+TMYDFRXV7OwsEBvb++SqGdCgrxX2+12XnzxRSorK9myZQtXr16NmpAuLi5y+fJlYCmWC30LsU8Lb+tULKcQLy4uMjExQVlZmcwfjEYjhYWFzM/Pk5KSwosvvohKpaKpqQlFUXC73RQXF5OXl4fRaOTEiRMEAgEpiiRW23bt2kVcXJxsPgcCAWnVJbyhYSlXOXjwoLSzu3nzJpOTk2zZsoWzZ88SCoVwOp2yaSDg8XgkdR2WVrqE33Fvb68U+jSZTFKbRcDn8/Hyyy8TCATYuHEjBQUFDAwMMDU1hdvtZs+ePVI1OhgMsnHjRoqLizl79iyzs7P09/dH2Y4lJSUxMzNDSkoKpaWltLS0SNq1zWaLiuORTLCxsTH27t1Le3t7lFhe5HcUuc+sUqno6OhAo9GQkZEh1bwnJycpLCyUFmPz8/Oy+VBaWkpjYyOKoqDT6RgcHIwSWQPIzMykrq4uaqgTCARkoS/ESj1/9McEfvw6xv/xV8S/8CNUej2aCKE533e/h/+FF9++DvLy0ER4XqNSwa3rTmW487RXpdcT+1//hMAbJ4n91Kfu+Hd3QigUkiJxYmDwfiImJkYyTyKbZ729vVI4TEyf78RmFY3DsrKyqL38u8GPfvQjfvu3f5vvf//7UWt1v6j4T1UwLw9wfr9fdoiE59979RpCDGNgYIC6urpVL9FHGn+LAKqEQtgfewJlYQH9h57G9Pm/esfnCFy4iGKxkPTwftyvvYYSCFLwkV9iPhCQvrV2ux2TycSBAwcoLy8nNjZ2qbNYUIDPaKT/4kVgqbA0m83SciMnJ0d2u8RnjrQ6EDYRFRUVNDY2cuPGjaik2WKxcP78kn+eWq2Wk0Cj0cihQ4cApHKzx+ORBeLc3BwOh4OpqSmKioooKyvDbDZTXV2Nz+eT1lTPP/88KpWKDRs2RAUFWOoQC3GriYkJtm7dilarpbm5OYryrdPpCAaDUUmDw+Hg3LlzxMXFySCQlpZGfn4+FosFj8cji2WNRsOmTZskTU5RFE6dOiU/i9ixWrt2rWQ1CDq3aJTk5eVRUFAgA7L47Hq9nlAoRHV1tfRw1ul09PX1yWRD7BrNzc1RVVWFw+FAURTS0tKYm5sjOTmZ2dlZ0tLSSEpK4q233pI+nCKA6fV6NmzYQGZmJhcuXGBkZET6O6pUKnbs2CHpR263WwZdcf7bbDYKCgro7+8nEAiQnJyMw+EgKSkJs9lMWVmZPLYxMTG0t7cTCAQoKSmhoKCA+fl5hoaG6OrqiiqyI/2dRYDPysqSSuqhUEiemzdv3qSrq0smNHV1de/YRRW6BatFKBRiYGCA+Ph4EhMTaW1tJTMzc1Uquz9t6PX6qOaZzWaT3eibN2+SlJQkO9JGoxGVSsX4+DiDg4OsX7/+npSsw+Ewf/zHf8yPf/xj3nrrLSmUdx/38V4gUhX4nXC7WK8oCv39/YyNjbF27dqf2AdcsMnExG5xcZG2tjZycnKorKxctbjX7Vhkly9fZnh4GKPRKD2P7wSbzcbs7CxFRUVUV1czNTUlfd5nZma4efOmFATbvXs3jz32GDqdDq1Wy5EjR/D5fFy6dAmHw0FHRweFhYVYrVbp2iDEx4SKs9lslsdXURRef/11EhISqK2txWq1kpCQEHXvO3XqlGzeiYJUxA9Aio0pisLc3Jxs6Ao7yfT0dOrr62lvb5frNENDQ5SUlPDyyy/jdrujGFzitcValXDOcLvdFBYWSs/ncDjM2NiYXGuKLE5DoRAXLlzA6XTKpqFGo6G8vJxQKCTp2CLmCQEsgc7OTq5fvy7PVa/XS0VFBYuLi6SlpckVNjFkSExMlHmQaEQHAgGZVyUlJbFp0yZaWlpITU2lr69PNpanpqaApWHBrl27cLvd+P1+srKymJ2dJSMjg/HxcWJjY8nLy6Ozs5Pe3l4KCwsxGAxymFFdXU1dXR2jo6NReizi80UW5CJHEe9B6LnMzMwwPT0tizVhHRkXFydzKZ1Ox8jIiMw/t23bxuzsLHa7nbdOnWLdy6+gUhS8L71M4rf+n3zNsM2GMjuLur4O9PqlotjlQlOxVEwHmptx/d7vo0pNgeRkYj7yYWI+9Zt3umwAiPnErxDziV95x7+JhP/Hr6NYLGgeO8aNjg5CoRDr169/34vl5YhsnokccG5ujtnZWTlEibSoVKvV2Gw2rl27Rmlp6T0Xyy+99BK/+Zu/yX/8x3/I3P0XHR/ogvluktLlNK1ID+QtW7asiia9mtcQAfBuxUQiO83AShq2oHqH3qZ8Kz4/3n/8R1SxsRh+/ddQqdUEu7px/sonADD+zReI//a/yL9PZslv8MyZM9jtdlwuF+fOnSMpKUkaqDtMJvLy8igtLWVmZoaysjKMRiOdnZ1kZmby3HPPoVar2bt3LwaDQfoEClrwpUuXJM0jLS0Nq9VKa2urnBTr9Xp5nCIn1i6XiytXrhAfH8/atWuJi4sjIyODmJgYurq6yMvL4/Tp07jdbqamplhcXMTv9zMxMcHDDz8MLAUNsQsmpr5OpxOHw8Hi4iLJycls2LCB9vZ2qqqq5DkQ2SiZn5/nscceIxQKERMTw9TUFHa7Ha/Xy+LiIouLi1Gd8qKiIimSIMTAYmJi6OjokBO9wcHBKPpbZWUlsbGxZGRkUFJSQnNzM4ODg/J7D4fD8iamVqvZt28fP/zhD4GlTm1lZSWZmZlyn2t2dlYWr2JXOhgMkpOTQ3t7Ox0dHaSkpPDwww9LWp5IVBITE2WhLwrT+Ph4tm3bRmJiIoFAgNTUVPn34jXUajUjIyN0dHSQlZVFSkqKvGk7nU4pyiWUzwXWrl0rd6YB6bstinyn0yk7p4qisLi4SEtLCy6Xi4mJCTweD+np6ajVaskEUBSF5ORk9u7di9frlUlOb2+v9IyEaOsN8drAPVEyYYlRIGyfsrOzKSgoWDWL5P2EWq0mOTmZ5OTkOwqHxcTEYLPZWLdu3T0Xy3/2Z3/GCy+8wJtvvklJSclP4ZPcx328OyILOjGxbW9vx+l0smXLlnsSsLvda4hYMzk5SXd3N1VVVatOPkWsv93KlcgBljcHhoaGWFxcpK6ujpiYGFmw+nw+Zmdn2bFjBxs2bJB/X1hYSF9fHwsLC4TDYVpbW6VAaEpKCna7nfT0dKqqqrhx4wZVVVUkJSUxMDBAUlISb775Jna7XepfzM7OkpmZyYMPPojdbmd6ehqz2YzZbJYaFfPz8xQXF5ORkYFGoyEuLi4qZorP19LSgsfjYePGjWzatEmuKWk0GgwGAxMTEwwMDKDRaMjOzsbpdNLX18fRo0fZuHEjPp+P5uZmYClmi8Jvbm5O0rDr6+txOBwkJiZiMploa2uLslqcmpri2LFjeDweTCYTNptNWl4JyrhofGi1WrKysuQ+aVtbG319fWi1WsbHx2VccjqdtLe3y2lrQ0MDWVlZJCQkcPDgQekAAUsMNo/HEzVQaGxsZG5uThbLDz74IJmZmbS2tjI1NcXU1NQK7Ze5uTmZr506dQqNRsPhw4epqKjAYrFIJfXExEQ6OzslG02ce1u2bKGoqAi/3y9XdyLPPREbLly4gMlkIiYmhuzsbCorKzGbzVLz5PTp01EriTU1NSusHEdGRmSR73a7SUlJkfoWLpcL23/5TXjzLUa3bIZLl5YKvfh4ePQxlPl50GrBYCDuh8+hDodRFxcD4H/pZZT5+aW/AYKXr6D6nd+Rr6uEw+Dz3bNSdrC9XYrmmsfHCT+4k/Xr178ndcN7CZVKJYXDioqKZPNJMF2F247FYqG4uHjVYoTLceLECX7t136Nb3/723dccftFxAfrbPgJEEnTMpvNtLe3r9oDebUQQhRXr14lFAqtWkzkTuJenn/4Gr5nn8X4h39I/HPPEmxrQx9Be/C//DLef/gaAJrqKnQ7dizRUNRqCIejbg5ut5sbN26Qmpoq91JFABDdqIsXL0p5/6amJik0lZmZyZo1axgeHmZwcJBQKMSVK1dkkJqfn5cqveXl5bS1tVFSUiItkLKysnjjjTdYWFhg+/bt5ObmMj09HXXcBwYGJNWruLiY+vp6+TtRYLW3t+N2uzEYDFE2Bu3t7TgcDhoaGmTxKjp/iYmJDA8P09XVhUaj4fHHH6e4uJjFxUWuXr1KQUEB+fn59PX1AUh6kE6nw+l0SqVqsUtsMploampiYWGBnJwcenp6aGlpITs7m4MHD+JwOIiPj8dqtTI3N8fNmzdlgDAYDKxfv55r164xPz9PdXU1Npst6vf79+8HlhS6p6en6erqorS0lD179tDb28v4+Djz8/M88sgjMuCGw2Hi4+Pxer0UFRWxOcL+SxTqIgAbDAaysrLo6uqS1LyMjAwWFhbk9bF+/Xr0ej0//OEPURRF7gwL1sOBAwfQarXcvHkTm80mlUldLhebNm2SKwUmk2nFtCcywIh9v1AoxM6dO5mcnIzq1KtUKlJTU+Uxcbvdks4luvQCVqsVtVpNXFwcQ0NDaLVa8vLymJ2dlc2oyOmyzWbjtddek/T4e0mixbWtUqnIycn5QBbLt8Ny4bC+vj4mJyflLmJKSspdCYcpisLnP/95nnnmGd58883bCgPex328XxANsFAohN/vvysP5Lt9je7ubmZmZn5ica+pqSmam5vJzc1l8+bN5OTkSGV/WComRKElGFSwdD/1+XxRnyscDtPe3k4oFKKurg6PxyMt+ywWC2azmTNnzuB2u9FqtezevVuqQgN86EMfwuPxyLWn3t5eaeM4Pz+P2+2W3tCDg4NSOEp4HgsLuYqKCkpLS7Hb7VH3feE5C0v7tnV1dfJ3wopGNCKFdob4XOPj4wwNDVFdXU1NTY20KkxMTMTv92M0GqW1065duzh06BBer5dr166h1+tpbGzEYrGwuLgorTBFMX/69GlcLhepqalkZWXhcrnYvHkzTqeTlJQUrFYrr7/+OjqdjoMHD1JZWYnRaJTCq4KhIwrRNWvW4Pf7OX78OElJSZSWltLa2io/q3BhSUlJweVycfXqVRITE9mxYwc9PT0MDAxw5swZ9u/fHxWfRIyJj49nx44d8nvr7OyUsdfhcMj1JfEeY2NjKS4uZmhoSE6Hy8vLKSoq4sSJE1itVpKTk6Pi6ubNm0lPT+fatWtyYCCwYcMGKUYHS6tQdrs9imYded4PDQ0xPj7O9u3bGRsbkytbAiaTCdPvfRZ+77Ok36Juz8/P097VTd3CAiqAYBCCQZTRMTS7dxFobiY0PoG6rAx1eTnodIQnJ9A/9bYStxIM4nj8SUK9vZi+/CX0Bw5wt1AlJCwV68EgocQE1q9f/546Uvy0sFw4bHp6mu7ubnQ6HUNDQywsLMhYv1rhsJMnT/Lxj3+cf/7nf+aJJ554Hz7Fzw/+0xTMYsI8NDTE4ODgXdGkVwu/3y9FHurr61d1Qd1uh0nA+8//DG4P3u/8Kwk/fA7NLYqj4nCghMNLdBStFrRaPH/3VVz/7c+I+8dvEPuHf4D3O/9K+FaxBEs308HBQQYHBzl27FiUImFeXh65ubkMDw/j9XoJhUJShTMtLU0G1urqakpLS6UwVnJysqQ7vfnmm8TExLB27VqCwSCDg4M8+uijlJaWEggE5IR0YmJCdm+HhoakqFBOTg7d3d2YTKaoCVdvby/Xrl2jrKyMvXv3srCwIH0lFxYWSEhI4LXXXgOWEiRRfC4uLkp6rRCxEmIqMzMzdHZ2StqSCDyzs7NRlN9IcS9FUTh69Kj874WFBdra2qRY2MzMjLQAgqVgJtSj33jjDWw2GyaTifb2dhl0hL0WLAl+PPTQQ1LYKhwOc+XKFTkdf/LJJ+Vn83g89PT0RCkyVlVV8cADDxATE0MgEKCtrQ2tViubL5Fe2FlZWbLLeOrUKbxerzzv0tPTJZVNBEIhapKfn09NTQ1Op5NAIEB+fr7sEs/MzMhu5fnz5xkdHSUuLo5wOMy6devIyspCpVLJ7rh4jxqNRnZq323f1Wg0StXPjRs3MjExIYVLhI2F8OQWSE5Ovi1daGFhQSYNi4uL91QwZ2RkkJGRQX5+ftT+2s8TBI1uw4YNJCUlSeGwqampKOEwYWOzPKAqisIXvvAFvvWtb3H69Omf2+NwHx98rJaSLZLw+fl5Ojs774omvVpE+s2+F+JeAwMDuN1u+vv7Wb9+PaW39jJDoRA+nw+DwYDRaMTtduNwOPj+97/PunXr2LZtGxcvXsTv98scYmpqSopbJiUlRdFpxT3LbrdLkcWenh6CweCSjolajdvtpra2lg0bNjA4OIjRaGTdunWMj4+Tk5PDj3/8YwB27txJIBBgYWGBYDDIU089hUqlkq4VwnIqGAxKcS8x8RWWjZEWNgsLC5w6dYq4uDgeeughsrKypF7F+Pg4WVlZnDhxAp/Ph9PplE3gvr4+2VQXopSwlPM5nU7a2tqIi4uTlolNTU0rrLgElRWWKNQHIooqlUrFzZs3UalUhEIhufctxAzF64icr7e3l9jYWCYmJiRrSzDtxPMdPHgwStm8vb2diYkJJiYmKCoqIi8vTzYVJiYmmJ+fl+tkycnJ7N69WzK9hMBpZAwT52dMTAwlJSXcvHmTixcvrhAKW7NmDcFgMEohXJw39fX1JCQkMDU1RUZGhlwTsFgsJCQkEBcXx+DgIJcuXZLnZk5ODps2bcLhcMjjI9TXZ2dn2bhxI3FxcVHNoNtBp9ORPj9P3Ff/gfKH9uD+0t/iunIF7/w8fr0eb3wcGZcvY/rYr4D4TDodiW+eQr3suRWrlVBXFwCBC5fuqWAO5+Yy8r+/gNbvpyaiufTzBMHSKCkpobi4OEo4bGhoCL1eL4vnOwmHnTlzhl/6pV/ia1/7Gh/+8Id/LgYE7yc+0AXz3XxZKpUKj8fD2NgYmzZtuifa4TvBbDbT09ODRqNZtb/ruylhx37mM/ie/T4xv/5r8mehkRHsjzwKoRDxz32fxAvnCPX34/zljwEQeP11Am+dQZmZwfP3f0/46afQ6XRkZGTQ29tLwi3VYoGuri56enpYs2YNTU1NXL16lczMTNavX4/FYmFwcFDeuOfn51GpVFRXV0dN08TOcSgUkrRXv9/PzMwMi4uLlJeXU1tbK8U/IifPL7+8ZBewdetW+XiHwyGDydDQEKFQiMHBQRobG2WTw2QySWuI+Ph4XC4XOTk5UlxKo9Hw4osvotfr2bVrF6mpqSQmJjI1NcXg4CANDQ1cvHgRh8OB2Wzm0UcfXbFzGdkhjbTF8Xg8nD17FlgSKxMBLjIhO3nyJIuLixQUFMiJs8Vi4dFHH5VNG2H3ER8fT11dnSyALRaLnJoD8n3V1dWhVqsZHR2lvb2d9evX09jYGCV2Akv+ueI7EwrmeXl5UTdA8W8RQLVaLQ0NDeh0Opqbm8nKyiI9PV3uvPh8PjZt2sTU1BQXLlyQz6NWq9m8eTMmk0l+flHYi883NDREbW2tfIzD4aCtrY34+HgaGhpWHXwURaG5uVkW/3v27JE/t9lscvIcicii//r16/K1SktLpTDXvQhT2e12rl27Rnl5OcW3aGHvhqGhIa5cuUJRUdEHwqdwamqK3t5e1q5dK6+32wmHzc3Nce3aNbkrFQ6HycnJITU1lS9/+ct87Wtf49SpU1GskPu4j58VRFxqb2+npqbmntRf3wlC3A+W/GrvplgOh8NS0DASFRUVWK1WcnNzZdwJh8O8+uqrWK1WGhsbeeSRR/D7/VJMqr+/n5ycHJxOJ06nE7PZTEJCgnSKEKrFAmazmYsXL5KZmcnatWuxWq3odDo2b94s47UQ9xK7qBkZGaxbtw6dTkdNTQ2jo6Py+QS7CZZi1szMDNnZ2axbt06yzBITE7lx44bcOfb5fLJICwQCzM3Nyfc4MTGB3+9ncXExqiBVFIWUlBRiYmLIzc1laGhITjaFLsbp06exWq088MADkpGk0+m4evUq+fn5Ukl7YGCAY8eO3fb+q9Pp8Pv9K4q5t956C6fTiV6vp6KiAr1eH5UPtLe3c/PmTQwGAw0NDZJttXHjRilQJjRSDAYDlZWVclDgcrkYGRmRK1kJCQnSUnPjxo2Mjo5y8+ZNcnJyOHLkCIuLi5LuDm9bhQGUlJRI66vIfCDSXlLE+5qaGpKTk7l27RqZmZlSPCozM5PZ2VkaGhqIjY3lhRdekMyycDjMmjVrpLCqSqWSgqui2TA1NSUtvWAp/l6/fh23283GjRvvSifI83dfJXj2LMFz50ju7CDllpK1y+Vibm6Oub4+YjUa1GLVMhRCufU/79//A+GpKTCZ0G3fRuxf/DnBa23EfOqTq359gUAgsMRQyMujZpX5Sqi/H8fHP4EqJYWE7/1HlNL3zwLCqaegoEDmK5HCYaFQCIvFwvz8vBQOS0lJwWQyoVKpKC8v58KFCzz11FP8n//zf/j4xz9+v1i+DT7QBfNq4fV6pTl7U1PTT2QsvhyR4l6lpaWMjo6u6kR6px0mgZhP/joxn/z1qJ+FBofg1sTP/8braHJy0B06hO7oI4TaO9Bu3Yq6sBDP336JhY9/jEs/+hEGg4Ej+/bx8He/i2pohFB8PJpbxUZnZyc+n4+uri7S0tJwOp309PRQU1NDamoqBoOBoaEhgsEgPp+P+Ph4RkdHl25Yc3NkZGRQV1eHxWLBZDJRXV0tqdAXL16UOxROpxO73U5bWxsPP/wwa9asYXx8XH4um80mCyGr1crMzAypqanU19fT2toaVZQoisKJEyew2+00NDRw5MgRWSSLHbKhoSFZcC4uLpKbmysVtWtqakhJSSEzMxOHwxEVIBVF4erVq8zMzLBlyxb27t1LIBCIKqpEcIOlvaD169fL/x4dHWVwcFAGEL/fT35+PuPj43KnG2Dfvn20tbXh8/lIS0tjeHiY4eFh1Gq1nMAD0ucSloracDgsC9Hx8fGoiZ7f78fn80V5JFdVVcn3Nz8/z7lz50hJSeHBBx9kdnaWlJQUpqamyMzMJD4+nmeeeUbSp4SojdgRh2i7EXEe+3w+9Ho93d3dpKSksHXrVnp7eyUdPPK7czgcvPzyy4TDYTZv3rxqFobVasVoNMpjuXxXsL29nZmZGbZt2yap7rOzswSDQS5evIjH45HBHZYSPJFYrQZ+v5+enh5SUlKIj4/n2rVrFBcX35WatriOBgcH2bx588804AjrqTVr1kQl1ZG4k3DYF7/4RZ555hmys7OZn5/nX//1X6OEd+7jPn5WEAUKLIkVvdcq7ULUMicnB6/X+xOJe0UiKyuLRx55JOpnoVBICkOJe2l+fr4UiywsLCQnJ4eRkRFMJpN0eti9ezd5eXlyhUrQnAcGBmRxnZqaKplOExMTlJaWEhcXR19fHxaLRRZEdrudq1evypWXHTt2kJ+fj8vlIisri6amJikGNjY2Rnd3N+Xl5dhsNq5fv86TTz7JoUOHJDUeiBKmtFqtctJdUlLC5OQksbGxUfek1tZWenp6SE1N5cCBA2zatAmtVktdXR1er5dAICAbGMI7fnZ2lmvXrslmtk6nk4yZyPxveHiYGzduUFlZKV0zImOL8GSGpWI3kpkntFqERoYQCtVoNGg0GvR6PTMzMzQ1NTE1NcXExITMOc6cOUNcXBwDAwNRU9+dO3ei1WrlKpTIF6ampqQLCiyd50I4KyEhAYfDQUFBgWTV+f1+XnvtNQKBAA8++CDJyckkJCSwsLBATEwMOTk5nDx5kpmZGQYHB+W+//bt22VzW3xu8Xqw1CRRqVT09vYSCoWora0lHA4zNTVFMBgkIyNDXhPhcJjjx49Le7PVFsuhyUkIhdHvfYjg+fPoHtqDKiJP0L7wIolf+hIZv/zLaF56EUtfH87RUeZjY/D195Nz9ixpX/u6/Hv/954hqfUqMR/95VW9vqIo+J95FsXnQ/X0U7TduEFMTAwNDQ2rZqkEzpxFmZtDmZsjePMmugjdlvcboljOz8+/o7aIYJOmpaXJhs/8/Dyvv/46f/AHfyDX9n7rt36LT3ziE/eL5TvgA18wvxtNS9zUEhMT8Xg872mxHCnuJYQrlnvJLseddphWC92DO4n57O+iWG34vvGPEAoTM2tGZTAQHh7G9Tu/S+LF8xgeO8ZYezu0t+Pz+XBPTqHpXyr03C2tTBQXk52dTV1dnSyQjUYj4+PjUuEQlia5a9euZWJigvXr15OSkoLb7ZbKmg6HA6vVKvdbSktL5U5SfHw8i4uLJCQkEAwGsdvt6PV6rly5gtvtprGxkby8PLxeL+Xl5XJXdm5ujr6+PtRqNcXFxTgcDrq6uqRnZmTRKHZmBCwWCz6fT1pNGAwG0tLS6OjowG63k5KSwsmTJ0lKSuLAgQOsWbMmauLu9/vldLavr0/6RwOSTiemcYKmLmA2mzl//rwUVqirq6OwsFDuDoVCIX70ox+hKAo+n49t27ZFnRdWq1XSx2Fpv0tQZ4LBIBcuXJDBGYiijweDQV566SW8Xi9btmzhySeXdngiC9Lh4WFcLhcul4t169bJyXVlZaWkXaekpLCwsCCVuRMTE+Vkd3FxkaamJnbs2CF9lsXxbWlpoaenB4DHH3+c/Px8uScmFGndbjctLS0y+ArK+9TUFFarFZPJRDgcXmH30tvbS0tLCzExMTz66KPSJzLyOxNNhuHhYbZv305+fr7c35udnY1qzgCSur7ancaOjg5J9c7KyqKiouKuBTPq6+sJhUJR9h4/C8zMzNDd3c2aNWtWbaMXKRz2zW9+k7y8PL785S+zfv16PvrRj/Jf/+t/5fDhw3z2s5+9J0uu+7iPd8O7XTN+v5+2tjZCoRB6vf4ndr1YjvHxcXp6eqiuriYvL4+ZmZk72lcJrKYxfifodDq2b9/O7OystN0bHh6murpaUo2zs7N59NFHmZ+fl6tJolkIS/fWsbEx4uPjKSsrkzaKeXl5ciVITHJVKhUbN27kxo0bVFRUUFhYSDAYpKurS+Y1b775pizient7aWxsBN62jjSZTDLH0ul0DA8PMzo6ypo1a6ivr2d0dJT8/HxycnKkY4NgLNXW1soifn5+Xk5xRdNANMAF5d7lcjE7O0tBQQGlpaVYrVZKS0sZGxtjYGCAgoICmpubUalUHDp0iCeffFI2kgU6OztxOp10dHRQXV0tJ79CrTtSITxSUM3r9XLq1CkZN9evX09mZiapqak8+eSTqFQqXnvtNSwWCyMjIxw9enTFutfQ0JDMXePi4iRLLRQKcenSJSwWi1wbKisri4p558+fZ2xsjIKCAg4fPkw4HI7aBzabzXLvfHJyMkqF2+/3EwgESE9PZ2ZmBpPJhNPpxGg0otVq6e/vp7u7m9raWvbt24fL5UKn0+FwOCgvL2d6elr6Q8fGxvLAAw/gdrtZXFyUBb3QlhHWXiLWh4aG8J94Fe8DOzAbDBQXF0etlgV7enA8+hiEw8Q/+z2SOjtQLRPW8j37fXA48X/3eyR97vfIKl9y3CgOBLB1drIABOPi0LjdqMJhwjk5eBSF1d4NgufP4/6Lv1w6douLxO7ZTX19/V2tdOiPPkKguRl1airaiPPm/YbL5aK1tZXc3Fy55vFuUKlUxMXFERcXx2/8xm9QWlrK008/TV1dHf/2b//Gv/7rv/Lwww/zyU9+8hfed3k5PvAF8zthcnKSrq4uysvLycjI4OzZs7KT9pPC5/PR1taGoihS3EvY69zpNe4k7uX9zr/i/cpXMfz6rxH7W//lHV9XpdEQ++nfImy14nvmGQh5UcXFwa2eQUCn5WpLC7FGI5WVlfj7BzCOjZGUnIz/T/8bod5eLtbVMnvxotzvjCz6nnrqKfnvUChEZ2cndrudpqamKHXo+vp6FhcXJX1TBNGhoSGpGCmCmN/vZ9euXfIGLkztjUajVGgeHByUu1Zi/0rYX8BS4Tc9Pc3g4CAVFRUy+EbeBCIVIbdu3cq+ffsIBAJSWGrTpk1cvXoVeHuiLRoDPp+P6elpsrKyKCsrY3p6Osr6yO12c/z4cYLBIPv27ePYsWPodLqom31XV5f8bgsLC2WQgqWJ3o0bN+Qu/fJ9o5aWFvx+P42NjSQnJzM0NITP58NisTA+Po7NZovaNdZoNFGTcb/fL4OTzWaLSgpmZ2elX+Lk5KQUkNm3bx9qtZrOzk6par5v3z65M2e320lMTMThcMipuqDGw1LhGA6Ho6ycRIIBSMuOH//4x5hMJmZmZsjJyeGBBx7AarVSXV2N2+2WwmoCKpUqqugSzRGfz0cwGJQNDr/fz8jIiLQemZ6ejjrmwWCQEydOyKTGYDCwbds2FhYWsNvtnDlzJsqv8J0SbJFIqdVqysrK7kldMjMz866m2j8NzM7O0tXVRUNDwz15ziuKwre//W2+/vWv88Ybb/DAAw/gcrk4deqUvD7u4z7eb4gVCbF7efHixXctZlcL4bs7NTXFhg0b5PTzdvZVAndqjM/NzXHmzBmSkpLYvXv3uybhhYWFFBYWyr3h5Q2+oaEh+vv7aWhooK6ujqmpKRISEmhqamJwcBC9Xs/Zs2dRq9UcO3YsSodj+URbFJpr1qyRsUWn01FVVcX4+Dg+n4/a2lra2trweDwsLCzQ2dlJenq6FMBUqVRUVFSQkZFBfHw8L774ovSsFbnAjRs3OHDgAPn5+TInAKIa116vl3PnzpGWlkZtbS0ejydqZUpRFH784x9LhfDt27ejKIoUD12/fj2Li4uyOWu32yU1PxwOMzk5SUJCAtXV1XLCHPncp06dYmZmho0bN3Ls2DECgUAU9X50dFTGlaSkJKqrq2VsFvFVNBHil9Fx+/r6GB8fZ82aNcTFxdHV1SXtoK5cuYLH45H5lMDyeCN+b7PZohrIYsUsOztbCrq2t7eTk5NDQkICc3NzvPHGG1JJu7y8HIPBgMPhwGg0olarpWtFR0cHjz76qGx4i/NZrF8piiIdKcRjz549i0qlknT/Xbt2MTU1JVlmzk9/hvDAIPbvf5+rv/FJFhYWoqwcFbMZbl0z4elptOvWydcOnHgVYgzE/O5v4/37r2H48IeijonnD/8I1fETpOn1EAyi+cqXsSYlMRcOY2luxmQykZ6efkc9DgF1VjZotSihENr8PGruslgGUKenE/9///muHvNew+Vy0dLSQk5OzqqL5eW4ceMGH//4x/nLv/xL/uiP/khq6xw/fpy5ubn3+B3//OPnsmBWFIXe3l4mJiZYt24daWlpcjIXCoV+Yil4h8MhLRoixb0irSZuJ45zp06z77vfQ3E48P3bv79jwayEw7h++3cIXmvD9OUvYfxf/xPP//xfBHt6MP7Fn6Pbspn+tDT6+vsByEhIoPS//SmEw3hmZjH9zf8CQHWrqHwn+P1+qVS5adOmqMIQkJZS8/PzNDQ08KEPfYhQKMTi4iJms5nr168zNzdHOBxmeHiYNWvWoNPpiI+Pl4IfhYWFTE1N4Xa7MRqNPPfccxiNRhobG4mJiSEuLk7aMqSkpPD666/jcrmwWq14PB6CwSA3b96UXU3pW32Lnh2pjqlWq2UyoNPpVig0nj59moWFBTIzM9m7d++K42G326NUwSMD7Pz8PHq9npKSEsxmM7m5uTQ0NMjfX7t2TdIENRoNhw4dirIam52dpf/WdybsvURHtrq6Wna6RUEsVDztdjt+v5+BgQHKy8vZsWMHFoslqgGyuLjIG2+8AcC2bdvIycmhr69Pqp3GxcXJG9/CwgIqlUoWjiaTiYmJCSkEtri4GEWv9nq9HD9+HL/fz969ezl69CgxMTFRx7Wzs1PS92EpKdu6datMAIT9huikw9vKqNevX8fhcKBSqcjIyKCmpiYqqbp27RoDAwNotVqefPLJKHEbWDqHRVIDyEaA2LWNVN3u6+uL8itMSkqKukaF8FVlZeWqJ6jvVXPuvcLs7Cw3b96koaEhasdttVAUhf/4j//gT/7kT3jppZekZYjJZOKRRx5ZkYDfx328H5iZmaGjo4OSkhK5X/lOxezdQDRcvV4vTU1NUU01MQ1cjuUWkZHiXqOjo3i9XmZmZiSD507o6emRe9hbt27l9OnT+Hw+MjIy2LVrF16vV+qHxMTESM2Qixcv8sQTT5CdnS3jzjtB5EtC7Xu5DaZerycQCODxeFhcXOSxxx6TlGCz2Sytq4Qgo7CZ0uv1FBUVMTQ0REFBgXQwyM7O5sSJE7hcLnbu3ElKSgoej4fs7GzZxB0aGmJ0dJTR0VFycnKwWq3YbDZqampkviUUwsWqUmdnp1R67u/vp66uTuZnkeJiN2/epL29XbpmLC8mFEWRE3rRhBX5j8PhkO/VZDKh1Wp56KGH5Pc7MTHBmTNnZON8y5YtUTEzHA5z9epVGRu2bNkiJ+yKopCUlBR1TiUlJZGcnIxKpcJms9HZ2UlKSgo7duyQftSR7/u1117D5/NRUlJCVVWVbJbPzs6SkJCAxWKR52akMFdiYiLT09Nyra6zs3OFgONbb73F5OQkGzZs4NixY1JDRmB0dFQ6nQio1eqodR11djbhgUF8t1h64rj6X34F38uvoM7JQbNuHbpdD6KLaC4HXvsxrs/+HgBx3/0PEl74EcsR6rol9nkr19eNjFLwmw9TwNJ1LASuhB6HiOkpKSnR7h0F+fR/8W+Ii42lateuVa9dwN3pKv00IXQWfhL3js7OTo4cOcJnP/tZ/uiP/kjeV5uamqKsQe/jbXzgC+bllGwR4DweT9RUVFwQP2nBPDs7S3t7O8XFxZSWlkadiJF2FpEX2buKe332d/B+45sYPv6xd3xtxTxH4PWl4sf/8isQCKDMzRH44Y/w/e7voHl4P+lWK+qRYXRaLQlpafiLiwkPDjJdV8vNF16grKyMHTt2MDU1dUeVcJfLRVtbGwkJCZIGvRx+v18edyG4lJubK1U4w+Ewg4ODdHZ2otPppHhEeXk5oVBI7j098sgjKIpCV1cXPp8Pn8/HwMAAXq8Xr9eL3W4nISFBCn709fWRm5uL3W6X6o3nz5/HbDazbds2Dh48iN/vJzY2litXrpCWlkY4HJbFf0ZGRtQeUuR3BG/v6ghMTEwwNzdHRUUFdXV1+P3+qCA1OjrKuXPnUKlUPPLII1ETegHhYSwE0wSlW0xIhRiVWq0mKyuLmJgYMjIy8Pv9tLa2EhMTw4EDB7BarSQmJkrRC2FZFQqF5LFcLlwWeR6q1Wqqq6txuVykpKTIYlOondfW1q6gfU1NTcndseWw2WyyIDWbzVGUM0Gji4+Pl0W4y+WS76+7u5tr166RnJxMOBymurqa4uJiaWs2NzdHZ2dn1OstF5US0xatVht1TVmtVrq6usjPz2fbtm3Mz88TCoVISEiI2o0zGo0UFBRQUFBAMBiUAleCFi92etRqNTdv3qS+vj4q8XonCBp5SUnJByK4mM1mWSyLicHdQFEUnnvuOT73uc/xgx/8gF27dv0U3uV93MfqISaKIyMjNDQ0RDFuBJPnJ4HL5eLatWsYjUa2bNmyIm+4XVH+buJe5eXlLCwskJSUJKdzd4Lwke/t7ZUrMrAUk3Jzc9FqtTLXSU1NlUVBQkICx48fx2QysW3bNuLi4oiPj5dsqkiEQiE5Udy0adNtWTZihQiWEvGuri65ZpSUlCQ/0+XLlwmFQjQ3N+Pz+WSxpygKo6Oj7N+/n02bNmG1WiWLbHBwUNKwx8fHKSkpkd7L/f39JCYmkpWVJePQwMCApE8//PDDzM/Pk56eTltbG4FAgIqKCtkgjomJWdFEFZ/ndrDZbAwMDFBYWMi2bduYmJiIsrxyu9288sor0jL02LFjK55DiI7CUvO7qKhIrpHNzMzQ0tIiz02xrlVeXs7s7KzcA37wwQfR6/VoNBrJShgZGWF6ehq3283Q0BAPP/xwFEVcQMRBtVoti6VgMIiiKLS0tJCamir1WyKvFxGv1Go1jz322IpiWVgSic8Y+XuRp8XFxaFWq+XnFY4nwbbrOH711whlZXLmySco2LqVmiceZ7fbLQt215/+mdTmAdBuWB+1t6wSjDyVClXEOao4nHi+/GVUqakY//Z/43/hxaXHhcIYfunD8u/E/rfQ47BarczPz9Pf3y+Vx9PT04mPj6ezs5Ok4mKqa2pWVWgGOztxfuxXUKWnk/Dc91HF/+Q+7z8JxOpbZmbmPRfLPT09HD58mE996lP8+Z//+QemEfBBxwe+YI7E8gAXSV8SXd577ToriiJFNOrr6+WFHgkRHEOhUJTS5bvtMOkPHFiV1L0qMwP9xz5K8M230G7ZgiYnm+CNG9h37uTE6dOSZvPw628Qbr4MC4skvPgCyuICl2/cwDk/T0dHB3V1dXdU9p2/9Td5eXnveLGlp6ezY8cO/H4/4+PjUnFXFIxqtZry8nLKy8vxeDz86EdLHUGz2Synp9PT08TExKDX6ykuLmZsbAyDwUBNTQ0Oh4O4uDgmJiZkV1XsNNntdnbt2oXP5yMcDsvnHhoaoqmpicXFRVpbW8nLy6OwsJDFxUVUKhV6vT6KCj0zMyNVNAV1KFIkxu/3y26xz+e7rbKmYC4I/0MBUfinpaXR2NhIX18fVVVV8vnD4TAnTpyIEtY4cuSIfH8bNmzgwoULhMNh3G43VqtVNjiMRiNGo5Hy8nIuX77MyMgIOp0uimI8MzPD5OQkRUVFGI1GsrOzKSgoQKVSsWvXLmkHEYnIaSy8rTC9/JpZWFhgbGxM0ptiY2OjuvSR+3SAfM2EhAR5jQwPD6MoikyWhLVROBzGYrEQGxuL0WjE5/PJKXRiYiI+n09aYSmKQlpaGjt27IhKTFtbW5menmZ0dJQPfehDq1Kx1mq1MolwuVxy/0oEVJPJRDAYlGyId8Po6KgUBPxZF8xzc3N0dHRQX19/T8UywAsvvMCnP/1pnn322SgRuPu4j/cLkbEoGAxKXYotW7asoL1qtdqfaMIsxL1yc3Olmv5yLC+YVyPulZiYuOq1jDVr1sj3kJ2dLRvR7e3tXL58me3bt1NeXs6NGzfo7Oxk7969VFVVMTg4SEdHBxaLBavVesf1EXGf0+l0NDY23lHPQa1Ws3fvXmZmZlAURYp3JSYmkpKSgkqlIi0tTdr3vfLKK0u6KW63jPUWi0XSmIuLiykoKMBms1FVVUUoFMLlchEXF8fzzz+PRqOhsbFRWj2VlpZSUlKCXq/nlVdewev1yh1bUSzr9Xrq6urQ6XTExMTg8/miVk7cbjfnzp1Dp9OxdetWqSYeyZy7dOkS8/PzjIyM8Pjjj69gEglLKXh7ZxuWvvfBwUFUKhVVVVW43W7S0tKiGrxXr16VLDJY8jcWMXPNmjU0NzfL9TRB/RcQasbp6ek0Nzej1+ulVVZ6ejqhUIiuri6ys7Ol/di6devQaDRs2bIFt9stcyQxYDIYDCuuJ/FZIocGXq+X3t5ekpOTpd7Muls0aXFMhPq5eO7169dTUVEhc27PmTPgdKIZcKJbWKA3O5uG2FhykpIIDQ0RSklBu2ULwbfeQpWUhGK3o7s11HD92V8QeP11VCkpqPLzMP7Fn6Otfbsx7/vBD/D9278DEL95E6a/+POVJ/AyqNVqUlJSSElJoby4GMc3/wlnOMzE5k303PIM1+v12Gw2EhMT37VYDJw7j2K3o9jthPr70EaIwL7f8Hg8tLa2kpmZKb+Du0V/fz+HDx/mYx/7GJ///OfvF8t3gZ+bgllMhvLz8297ovwkNC2xy7uwsPCOllQiSIo95Z9E3Ot2UKlUaDIy8I+P4/7jPyHx3BkSf/wacwMDKM3NUlgr9moLmlAIX2src4cOkpqaSnV1Na2trVF7uctx+fJl+vv7SUtLo7y8/F3fjyjAxD7NcnuN/v5+xsfHaWhoYPfu3SwuLlJRUcHU1BSjo6MEg0FpY5Gfny89AJ1Op0wq3nrrLeDtXR1YSmbcbjezs7Pk5uZSUVGB2WymvLxceiwXFhbS0tJCS0sL+/fv54knnkCj0URNCXp6eqSPb319fVTRJ5gIYjIa+Z2Hw2EuX76M1+tl06ZNcoc90lfxxo0bUrjsySefXKHqHOn7aDAYKCkpkcevp6dHUsqGh4cxGAxRNhZDQ0NcvHgRo9HII488IinzHo+Hubk5SZMTzxUKhaT/ZDgcJhgMSrsocU6KPWSHwyGfG5b2kCOFz2BJ+EUoxIbDYammLiCo45Gf1ePxkJCQIKfa6enp0i7EarXKTv65c+cYHx9Hq9USDAZZs2aN3A/TaDRMTEzIIhuWAoSgc4vmRWpqKtPT02RkZNzTNdfW1sbIyAgqlYrMzEyqqqpQFOW21G1xHJdjzZo1dHR0/MwFsMQOW11dXdQ5dDd45ZVX+I3f+A3+/d//ncOHD7/H7/A+7uPu4Ha7aWtrQ6fT0dTUtGJdCN55v/jdMDY2Rm9vrxT3uhPEJA1WVyzfLeLj43E6nfT29pKRkSEFmJ5//nlgKQ6KqfP8/Dyzs7OSBj02NobJZLqjAv7Y2Bjnzp1Dq9XyyCOPvKv4oSgwBOVWo9FE3fPn5+dpb2+noKCAnTt3MjIyQkFBgaRKq9Vqzp07Byw1ExcWFgiHwwwMDMj40tvbCyzFIrHb7Pf7pcOGcM3o6OigqqpKCp8lJydLhe7GxkYeffRRQqFQ1PsbHx+Xa0Hz8/NRTVTBCExKSmJ+fn4FJb23t5eRkRHWrl3Lnj17cDqdUbnCxMQEzc3NAOzateu27BvRGFepVLJ5DUsDBLFnGhsbi81mi8q9HA4Hr7zyCuFwmP379/P000/Lc1swonp6emSDXsBms5GRkYHP50On00mfZCHwlZycTCgUkg4SgoXQ0NAQ1RBua2uLcgVRqVRRzalQKBQ1NICl61OtVhO4eInQ0BCLWzajvdqCtrgYfW0t9bm5GAwGfM9+H/ef/TnExIDXi2b9euL/49/A50NlMqH4/PiffXbpuW/lhuHhEXgQFL8fxWpFU1YKWi2qhATU9xBr/S+9TOgrXyUW0Oo/R86O7aSkpDA/P09bW9s7UrcFDI8/Rqi9HVVWFpqIVbz3Gx6Ph5aWFtLT0++5WB4eHubw4cM88cQT/M3f/M176l3/i4Cfi4J5ZGSE/v5+amtr35EyeS80rduJe70TxM0sUtxLdNp8z/0A9//8XxieeBzjn/63u3ofEkKyX6Ohva8ftWmJHmPv60fV20u61Yby1b8jcPIUHbseZODsWWJiYnj88cdX0HUFhI2QUBpeXFzEZrMRDodJTk6WlJv09PSoXawLFy6QlZVFQ0MDg4OD8uap1+ulOIA4Brt375YTUiFkEumbG9nVFOIj2dnZbNy4kfj4eHJzc4mJiaG/v5/CwkK5z5yfn8/OnTsl7WtoaIg1a9ZIgShY6m6LxEHsJ8XGxlJWVsbCwsIKj+IrV67Q19dHbW0tR44cwe12R9HnzGazDCKjo6NRVGQBQX8T+9MCs7Oz9PT0UFJSwp49e5idnaWiokKeV/39/VKB0uv1Sq/hSIiCUQiFiAAndn+rqqrweDzMzMyQkJDA4uIiRqORmzdv0t/fj8vlklT16upq6urqCAaDmEwmuXseCZvNRkJCgqQZxsfH4/V60ev1eL1eORXv7e1lfHxcirUVFhbKIJOVlcXQ0JBMLAR27twZNfW32+3A2x1vm82GVqvF5XJJRoL4LkOhECkpKSQkJGCz2Thx4oQU3UtISLhnBUfRHFGr1dTX10vq2rtRt1NTU2XiuZzy9rPAfASj5F7fy2uvvcYnPvEJvvWtb92Wgngf9/F+YnFxUapDV1VV3TGhu5eCORwO09PTI8WeIhugd3qNYDB4WxaZxWLh9OnTGI1G9u7de09rYJEJr2iE1tbWsmHDBoaGhkhMTKSsrAyDwYDBYJBimocOHeLIkSN3fN75+XmuX78ulaAXFhbQ6XSyiTk3Nxd1L3M4HPz4xz9GrVbz0EMPkZCQgNvtxuPxyCbv9evXmZmZYXp6ml/6pV+Kmq5u376dYDAofZYjj8Xi4iLnz59Hr9ezZs0a/H4/BoOBwsJCDAYDcXFxDA4O0tfXh06n44knnqC4uBiLxcLVq1flSo24F5vNZiorK+VrWK1WfD4fOTk5JCYmotPpohqHonGQnJzM/v37qaqqior1gsqsKAodHR089NBDK46niN0qlSoqP3S73Vy7do2EhAQ2b97M4OAgeXl5cvJts9k4ffo0wWAQvV5/2+d2OBzyPLbZbFJ7QqVSEQ6Hyc7ORqfT0dHRQXx8PDabDZVKJQVvJyYmyMjIwO12y8/odruJj4/HbDZLX22z2SzPs+LiYpm3ieJYr9fL70aj0WA2m2lvbycuLg6tVkt8fDy1tbU4nU4qKioIT0/j/JVPgKIw/uBOBg7sZ8uWLTwcMbAJDQ8v/eNWgz08OIhKq0UJBvE9/wLq7Gx0D+0hNDIKt/yA9Q8/jBIMYj96jPDAAGi1oNMR92/fQX0PuhyaokJQqwlrNCRUVFB6i4Z9O+q2x+MhJSVFNstFjqdOTyfu61+769d+L+H1emltbSUtLe2OjJh3w9jYGIcOHeLQoUP83d/93f1i+R7wgS+Ye3p6mJycpLGxcUVncDnuNogK5c3k5GTq6upW5Rmr0WgIBAK3F/f64Q/B6cT3vWfuqmAO9ffj/MzvoC4owPTVv0NdUsy40cTNwaWOYnJyMiWf/x8o8/N4zp8n4Yc/QL9nD+GLF8FsXqHcbTabmZqaory8HJVKxYULF1AUhS1btjA8PExKSgqvvPIKiqKwe/duLl68iNfrpb6+Xu4EjY+PS/+91NRUOd1eXFzEYDCQmJhIXl4e4+PjUTTnYDDIqVOncLvdUvDD7XZLlU+bzcbg4CBzc3NMTEzgdrvJz88nNTVVUrXgbfq7oAH19fUxMzNDZmYmY2Nj1NTU0NDQQDAYjJryDQ4O0tzcjFqt5ujRozz++OMrjregRo2Pj7Nu3ToZQH0+Hw6Hg+TkZJKSkvB6vVENGrvdzhtvvIFOp2Pfvn1kZ2cTHx8fdd60tLRgsVgwm808+eSTspARlP/R0VE5uY3s+ofDYTo6OmSRq1KpSElJieoGX716lcHBwSgRrc2bN0uxj6mpKUmRW1hYAJYK+A0bNshufEZGhkxUPB4Per2e9PR0xsfHOXfuHPHx8djtduLj49m/fz9Op5OUlBRCoZBUIBcIBAJR4mjLm03Cr9Lr9XL9+nU50TeZTOTl5eF0OqXq9alTp2QxDbB27dqo/TKbzRZ1bdvtdkKhkDz2wWCQ6enpqEB3J4iOcqRarEAkdVtRFLm/PzQ0xM2bN0lOTpaPf69tbe4GCwsLUjDoXovl06dP87GPfYxvfvObt93Nv4/7eD9hNptpbW2lsrLyXVXq77Y5HggEuH79uly9Wc21K0S/bscim5iYwOPx4PF4sFgsq16FCAaDnDlzRsbHhx9+GJfLJaezYpJtsVhobm7mqaeeoqmpSepkQHTz2e1209fXR3Z2Nunp6Vy+fJm5uTnWrFnD1NQUBoOBy5cv4/F4qK2txeVyMTIyQkpKCgcPHgSWjrtgDY2Njcn78MTEhLxnFxQUMDMzQ25ublTO09raKr2gS0pKGBgYID8/ny1btjA1NcXi4qKkKotiKz09HYPBIKm/Iq6I552dnaWzs5OsrCwWFxdJTk5m+/btTE9PSw9hWCo2jx8/jqIobNu27bZNhKmpKbkaJPauxTFcWFhYyq1KShgZGVkh3nXy5EksFgsPPvigFDyMLLb7+vrk91JQUBC1T72wsMCNGzcwGAwEg8EVE/6RkRFmZmaora1l/fr1K/IYUeiL46IoCvX19VRWVuJ0OiUbCpANcCH4Jd5jQkKCtPw0Go04HA4KCwtxuVy8+uqrMmfUarXs2rULjUaDyWRCo9Fw/fp1WWTDUryNHMiEY2IgNhbcbvy3GuIGgwElHMb7ta8TnpxCCYfQrFuL7shhlMkp9HuXGgaeL/0ffN/+DqhVEFbQbFhPwjPfk8+tOByExdQ7GIRgkPDoGFRULP1eUQg2N6NKSkZb/bZrxu3gq6qi+2/+F+nZ2ZRt2hR17kZStysqKqQ38ezMjNQViGSa/ayoy16vl5aWFlJSUqiqqrqn9zE1NcWhQ4fYs2cPX/va1+4Xy/eID3zBnJOTQ0FBwbtOfuHu9pqEuFek8ua7QVEUtFotIyMj5ObmShN7gdhP/xaeL38F/WN3N6nxv3Kc8NAQ4aEh/H19aHfuJMXhQD08hIqlG59mTQOBU6exbtrM+RMnyM3NpbGxkczMTNLT0+UFoCiK7GouLi7icrlkV3LXrl3k5+fLXSVYuhhF8eV2u+nt7SUxMZGamhopQlVeXo7FYsFoNNLZ2cn09DQlJSXyOxkZGZGF0+LioryBDwwMyGmpKHKTk5PR6XTMzc1hNBqJjY2lr68Pn8+HRqNhYWGByspK9u7di9lsJisri/b2dpxOJzU1NdJ+Q6VSRe3aCIgkKlLFVHzO/v5+srKy2Lx5M/39/VHFXjgc5vjx47K4vx01dXp6WiZJCwsLUY0Cp9OJwWCQ1PNIqp/4TmZnZ1m3bh2NjY14PJ6oQmdycpKOjg5gaQJ6O8GP24mZKIqC3W5ndHRUil4EAgESExOlEujVq1cl5ej8+fP4/X4qKyujlL4nJycJh8NRnph+v5/U1FQsFosU+LDZbJJKmJ+fj6IonDlzhrm5ObZv387BgwfRaDT4fD75/ba3t0fRyWBpKhFJtVx+Axf/PT09zfj4OBUVFTQ0NODz+QiFQmRlZUU9/sqVKwwNDWEymd5xUjo9PU13dzcbNmx4VyVplUpFUlISk5OTDA8PU1ZWRnp6OnNzc/T396+Kuv3TwOLiIjdu3KC6uvq2WgurwdmzZ/nwhz/MV7/6VT7ykY/c32O6j585kpOTVzX5hbsrmIVXqclkuq241+0gnBgEDTojIyPqflNSUiI9bu/Gvm1xcVGKK42OjlJZWUlycjJxcXGyOSkENePi4jh79ixarZatW7fywAMPoNfro17v6tWrjI+P093dTVFRkWRGCbXbUCgkqdBCaFP8e2xsjEAgQF5eHtnZ2VJ92ev1SveCV155BaPRyPpbe5szMzN4PB7ZlOzt7ZXUa6vVSjAYpL+/n5KSEvLz88nOzmZkZIRQKERmZiZTU1P09PRgMBgkPXr79u1kZGRISvjAwAD19fVcuHABp9PJ7Owshw8fXsGgi2T5RZ4L4XCY/v5+dDodNTU1+P3+FQ3O5uZmhoaGpODlch0Kp9MpC8bx8XE2btwofyf0NbKysujq6sJkMkWxqDo7O7lx4wbZ2dkcPHiQubm5qPt0IBCQQ4xQKMS2bdtWnCeRsT5SsDQQCEj2QXFxMbOzs2RlZTEzMyPPB6E90t7eLqnukboUQsk9EouLi1RWVsqJd2JiImazWTp6iGPv/c6/4vnKV4j5xCdIfO0E4ZkZGoqLqQkGSUtLI3j9Bt6v/n3Uc8f82q+h/+hH3/6BuI5UKkBBdauZEJqYwPetb6Pdvg3Tl/8PgeZmVDodqqQkdLsefPv4vXIc1+d+H9RqEl47geYOGiZOp3NJSbq2dlXiWCaTCX1nFwm/8SnURYV4vvJ3zNntUdRtwTT7SZ14Vgufz0drayvJyclR1mZ3g5mZGQ4dOsS2bdv4p3/6p1UNBu/j9vjAF8xJSUmrDoyrmTALevLQ0NAK5c13gijAamtrmZ6epqenh0AgQFpaGhkZGaSlpaHbsQPdjh2rej5FUQicfhN1air6R44QePMt3BXlvN7djdLdzYEDBzjQ20fghz9C29mF8etfIzw9TcfgIItjYywuLlJTUxO1ayM6hvHx8VgsFmlWb7PZiI2Npa2tDa/XS2Njo9wHjo2N5aGHHmJubg6v18vVq1elHYLVasVqtVJcXCzpr2K/SlBpATl5ttls5OXlkZOTg8PhkIrZwu/3Bz/4ATqdjs2bNwNL+0sFBQVUVlbicrl4/fXX8Xg8Ucqg169fl8WxEPzwer1RbINAIMClS5dQFIXNmzej1+sxmUxRuzgtLS2MjIxw8+ZNnn766ahiV3y/IoiI3WOBmZkZSQ+fnp6WtlUCYuc4NjaWo0ePRimPix0v0aQYHR2lurpa0oJFEExKSkKr1aIoSlTC6Ha7OX/+PAaDgc2bN5OVlUVaWho2mw2DwUBycjLHjx/HYrHQ398vmx8PPvigPFbCWqm/v1/uI9nt9ihWQlJSEomJifK7S05OJj4+nhs3bnDz5k25cxwbGyu77SqVCo/HIyf2ywWwgsEgHo9H2mbodDr8fv/StaLTYbFYOH/+PDqdDq/XS0FBgfTkFJP9M2fOSHbD7ShtAuK6X37922w2hoaGKCwsxOv10tPTw5o1a+4qyRUCZmNjY2zevPmuqNvvNRYXF7l+/TpVVVV3VMF/N1y8eJGnnnqKL37xi3ziE5+4XyzfxwcCer1+VcUyvG059G4Q9OQ7aZ/cDqKQKSwsRK/XMzk5SU9PD0lJSdIlwmQy3dae8E4QuhzZ2dnk5ubidrsZGRnhxo0bbN26lTVr1nDhwgU6Ozs5fPgweXl5TExMcOXKFWApBkVO3cW9OzExUWpCuFwu+fkWFxfp7e2lvr6eTZs20dHRQVxcHGvWrGF4eBij0cjZs2eBJZaSiE+dnZ2S5SVe2+PxRK3S2Gw2pqamyMnJob6+nv7+fkpLSwmFQvT391NdXc0LL7yA1+tl27Ztkl4sXDl8Ph/Nzc24XC5cLhfnz58nLy+PkZER5ufnWbt2LcnJySQnJ8smQiTa29slrX7Pnj14PJ6o6ezw8LCcWu/bt0/a40VCMLGWx3q73c709DQFBQVUV1djsViouDXZhOid43379vH0009HMQ9E80J4QWs0mqjmudg5TkpKWsFMENopVquVpqYmdu7cKSnSokHd3t4uFcgF6uvraWxslEMSEZNEwe92uwkGgzJfMxqNpKSkYDKZMBgMBAIBioqKmJmZ4eTJk1HONELMU3w+3/e+Bw4nvu9+l9jf/gzq7GySWLJEDU1OQnY2qrQ0FKt1afdYr0dTU43ici15NJvnCPt9qKurMf5/f4kyO4P2VsPA87//lsCrr+L73vdIut6G/tDBFd8bgCKu+3B4aQItfu5y4f2Xb6MpKca3Ywetra3k5+eveiAGEHjrLXC5CHd2ke73k1VfLwcJc3NzUsX9dtTt9xo+n4+WlhaSkpKoWaWi93LMzc1x5MgR1q1bx7e+9a37xfJPiA98wXw3eLeucygU4ubNm1gsFkllfTcsF/dKSEggMTFRduPMZrOka6amppKenr6iG307+J9/Afcf/wmoVCS8epyEl17AMjpK4BYNZ3FxkZQLF9H5fASaLzM3P098Sgolt3Z0c3Jyorpcly9fZmBggHXr1lFaWkpLSwt+v58DBw7gcrlwu92cPn0aWBJNGhoaIhQK0d7ezv79+0lPT5edaI1GE9WN9Xq9nD9/npKSEjZu3EhbW5s0Sx8YGCAjI4PXXnuNcDhMfX09ZrNZdppFAdXd3Y2iKPj9fjmBDgaDOBwOLBaLpMVfv36d4uJiUlNTZWfabrfT399PfX09jzzyCIFAIEqAbHJyUu5nixvkcoi/NxqNUTeeyclJ+vv7qaio4KGHHpLiYgJ2u52Tt3ytGxsbb7s3K8TMPB5P1M6xz+fj4sWLaLVa6uvrGRkZidqHDofDvPrqq1gsFpqamnj88cdRFCXq3BkZGZGBr6KiQn42sXMsvB0FA8Bms2E0GtHpdAwNDTE4OEhOTg5ms5nCwkKKioqYnJyUCuHihi/2qsvKyqKm20J0RlxXfr9fCouNj4+TmZlJTU2N3C0TCAQCvPTSS3g8HtRqNYqi8MADD8jurEqlYnBwUE60YYkCKJKbYDAoaelms/m2BW4gEOD8+fOEQiHZTFg+cb148SILCwsMDAyQmprK2rVr7yiUcyesW7eOrq6uqPPiTtTt4eHhnxp122KxcP36dSorK1dtf7UcV65c4YknnuCv//qv+dSnPnW/WL6PDwzu5lxcTXN8dHSUvr4+ampqVjRI74RIN4SYmBjJQPN6vZjNZim4GB8fT0ZGBunp6VHTxdvB6XTy2muvoSgKjY2N0gHiueeeA5bYbpH7xGazmdjYWHJzc6XzQORe7sjICBcvXiQrK0vem/x+Pw0NDZhu7YK+8MILssmv1+txOp3cuHGDmpoaamtrsVqtsjCKjY1Fr9dLz+Pm5mYSEhKoqalhfn6e2NhYKisrUavVmEwm2traWFhYIC0tDYPBgNvtpr29nWPHjlFRUYHVapXN57m5OdmktVgsxMTEoNFoqK+vZ35+nri4OCorKxkcHJQT8BMnTpCRkcHu3bvlPq6Az+ejvb0dWMopbjedFfdbtVodJQzmdDq5du0aqampbN26laGhoRWibydPnsTtdjM1NXVHcS9x3gndF1iK5W1tbbLg7+7ultZgAteuXaOrq4vCwkIOHDiA3++PYk7a7XbJEBgaGpJTfUDGLJGz6nQ6eZ6KAYnYcV1YWJCWY4ODg4TDYc6cOSOLvEuXLuHz+TAYDOzcuVO+hmgiRE63PR4PCfHx+F99FXVmJrG/+7t4//GbGD4WMTEGXJ/7fQLHT0BSElitGP7LbxL76d8CVKgMegJnzxK8cFH+fRhQKWF0Bw6gBAIoPj/a2hoCr76Kprwc9Csbzu7/82WCZ84S+2d/iukrS1ZTmoiY7P3Wv8jpdvdf/w8KNm64bS74TjD80ocJ9fWjKS9DfWsfW61WywZOFHV7dvanRt0WlqOC7Xkvz7mwsMCRI0eorKzk3/7t3963qfh/ZvynOoLvRMn2er20tbUB0NTUFHUjvROEBL+g9gpxL/8rx3H/1efRP3KEsj/7U8rKyqR3rqAcJSYmym70bTtQty4ABeifmYFAgNLSUqqyswn19JCzuIjmC/8T37PfZ2DPbjpefx2DwcBjjz3Gk08+ueLpRkZGpG+lOAZCzEuv15OWlkZ8fDwej4eMjAyKi4sZGhoiMzOT559/HpPJxK5du+TerMlkkjtB58+fx2KxMDMzQ3Z2Nna7XXolrl27VloOiGMkGhdqtZrOzk4URaG0tJTR0VE0Go3cF4+JiWFiYoLu7m4MBgO5ubn4/X5GR0dlN764uJgf/OAHwNLOkAhS6enpxMTE4Pf7ycjIID4+nnA4HMUYmJ+f5/Tp08THx/PQQw+Rn58f1S2FpQJC0NaPHj26QmlY+Ccv3zkW/pYqlYqamhp5UxXB2u/38+Mf/xi73U5MTAzbt2+PokDDUsEnim2z2RzFFnA6nXg8HulNHRMTE0Uhnp6e5q233iIhIYF9+/ZRU1MjPZxFUnL16lUp+iK6zx/+8IcpLy+XRZ7ZbJYTYlgKkF6vl5iYGAKBAA6HA51Ox7p16/B6vWRlZaHRaDh37hwTExN3pED7fD5pYyWuH7vdTlZWFjabTQqtCQstr9crFd7Hx8c5e/astGjx+XwrFNrFMRCqrjMzM1EFrRAwS0xMZGFhAUVRWLdu3aonWJHIzc19x4RbULeFZ6lQMxdiIkajURbP90rdtlqttLW1UVlZuerkfzmuXbvGsWPH+PM//3M+85nP3C+W7+PnFu/UHA+Hw3R3dzM7O7tqirdojIsmpJga2u12Tp8+TUxMDHv27KGgoAC/3y8T5qGhIWJjY2WjfHl8gehGgM1m48aNG1RWVrJx40b6+/tJSEiguLhYikMJca/9+/dLNk8kIvVFRAMTlprswp6voKCA0dFRcnJyMBqNTE1NkZ2dLQvCXbt2cfjwYSmseOTIERwOBxMTE3J9JhwOy5WqmZkZqSkhdmdFrIel3Gt8fByz2Ux1dTWlpaUsLCxQVlZGcnIydrudpKQkuVK1du1aud40PDyMXq+nsbGRN998E1iKh2fOnJGxPikpSU6b8/LymJ2djaJo+/1+Xn/9dSmkeeTIEbRabVTc6OrqYmxsjLGxMYqKiqKEywREjF/OEBoaGmJubo66ujo2bNgQtXOsKIqkeANs2rTptvvUgjY9OzuLWq2WxbLf75cNiOzsbGw2W9Rn83q9vPrqq/j9fvbv38/Ro0cxGAySkm40Gjl//jwzMzPyNQBKS0tlA1rkp9PT01FsLGHvKfyghZinsOTKzMzE/8yzuP/iL5eGO6+/RsKLz6/4bKHrSywrbjmqhAcGURkMhBcXCZy7hiopCXV5+dJUWK1GU1iApq6e8NQU9kcfQ/H7SXju++gOH0IdIT4roDid+L7xjwD4/v3fifvK3739O0WBUAjNre8jaDSSU11F0V0WywCavDzi/+8/vePfmEwmTCYThYWFMr+am5ujra0NlUoli+d7pW77/X5aWlqk0Nq9xGmr1crRo0cpLCzkmWee+akx3n7R8IEvmN+LrrMQ90pJSYmiy74TIm0kVCpVVJLr+/5zKBYLvn//D2L/9L+hUqnkRVRUVITX65Wql/39/cTFxUVRuVQqFfpHj6JOSmJaq6VleBiGh4mNjaXi6/9IqL0dT+azJJ0/i3bjRvxXr8L8PIFAIEroyOFwMD4+TmFhIRs2bOD69euEw2E2bNjAyMgI8fHxnDx5kkAgwI4dO4iLi8PhcNDZ2cmDDz7Ili1baG9vl9Qoq9UaRRHS6/UYDAays7OxWCxkZGTInaTU1FRu3rzJxMQEmzZtory8nKGhIYxGIwcPHsRisRAKhaRwRSAQkFYSk5OTcv9Y2E5F7iMJ2m4gEMDv97N161YmJiaora2VKp83btxgenoaRVGoq6vj0KFDK25OQrVT2HOIglNRFElXz8/Pp6enZ4UtVEtLC2NjY2zatIlDhw7h8/mijs34+LikRiUlJUXtU3u9Xq5duxa1Vx4Jq9XK0NAQxcXFNDU1YTabo4K32+3m5ZdfJhQK0dTUxKOPPrri/JyampLiMIL2DBAXF4fNZsNkMpGTk8PY2Bg5OTlMTk7Kgry5uVnSiysqKqioqJAJoKCAx8XFSao9LCUQkdQ0cQ4uL/4ENTwhIYG0tDRMJpO0uCgtLcXlcnH8+PGo/XKxwyYgvler1Yrf718xwREJa2pqqnzu5eJsr732Gmq1moaGBpxO56oT5/cCsbGxUt31dtRtwURZLXVbFMsVFRX3XCx3dHRw9OhR/uiP/ojPfe5z94vl+/i5xp1ivd/v5/r16wQCAZqamlZFl1zeGF8u7uV0OnE6nSwsLEjthJycHHJycuT1bTabuXbtmrTUy8jIICkpSU5lDxw4gN1ul7urwu/dZrPR1tYmhbImJibo6uoCor2Axe5qSkoKdXV1WCwWfD4fRUVFpKamEggEGBsbo6WlhdLSUtLS0hgZGaGrq4tjx45RXFzM3NycLFjHxsaiGrgqlYrk5GQCgQBdXV3ExsaSk5NDZ2fnkgOIz8eLL75IWVkZ1dXVMsZs3ryZ4uJikpKSeOmll1AUBZ/PJ9dYurq6pK2UYIEBK5odRqMRi8XCpk2b6OzsJC8vj7S0NObm5hgZGZH71hkZGTzwwAMrNG2EJzUsxcZIcTDBcsrOzqa/v5/k5OSo82J0dJTW1lZKSkrYt28f8/PzUUwlwRQT58qWLVvk78TKlWBiLYff76e7u5vk5GQ2bdpEb2/viqnnyZMnWVxcpKCg4I6uGWL6Ozs7G8XkEuzBzMxMRkdH5bpWXFwcSUlJDA0N0dLSQnFxMY2NjRQVFVFTU8PY2Bg+n4+rV6+i0+nQ6/WyUaIoCtXV1W+/AcF4U6shIncO22x4//GbqFJTUFdWoM7PQ7dvH+GxMQwf/xgAjo9+nHBf39Jjw2FiPv1bxH72d+VzBLq7paVU8Pp1DE8+EfXZlVCIYPNl1KUl6I89SuDsOQwR+ZASDOJ4+sOEurtR/c0X6Pr8fyevtpai2zRDfhoQ63lZWVlR1G3hlZ6SkiKb5au5F4nJclxc3D0Xy3a7nUcffZSMjAyee+65d2W73sfq8YEvmO8GtwuiMzMzdHR0UFpaSnFx8V3tMN3JczHmk7+Oe3ERw5HDt32+mJgY8vPzyc/PJxAIyOJ5eHiYmJgYWTwnPLiTeKsV1diS9L/JZEJTU71UMK9bx/W33pJqvqJ4cLvd8gJ48803sdvtjI2NyX1VWKLtPPDAA9hsNjo7O4Gli0js6zidTiYmJtDr9ZSUlDA2NoZGo4naC7558ybXr18nIyND3qBnZmbYsmULTz/9NIqi8OwtD73e3l5mZmYIBAL09vZSWlpKbGwsdrtdFlTp6elotVpJETt58iRJSUmUlJQwOTlJamoq+fn5LC4uUl1dTXd3NzabjfHxcQ4dOhQVZNLS0sjNzeWll14ClgrwhYUFeXMKBALodDrZ5U5ISIgqljo7O7l+/TpJSUkcOnSIdevWRTVRQqEQPT09wJINVCQ1KxwOEwqFSEpKko+JPG6iM24ymXjooYeYmpqKsusCuHDhAhaLhfHxcY4ePRo1WRavH8kSiIRIHCoqKnA6nSQlJUVR1rq6umhra1vyQbw1+V+3bp3sNAuBFlhSFBed7LS0NFJSUmSSJnbHxfdns9mkqqharaapqYnCwsIV6rCXLl2K8lEOh8PsiNjrF8lpJERDQTALKisrpeDY7SbLkQnGoUOHVvw+kgY4MDDAtm3b7uitvhxtbW309vaydu1aqeD9k+AnpW6LhLqsrOwdPWPfCV1dXRw+fJjf/u3f5k/+5E/uF8v38YHE3ZyXt2OTCcptXFwc69evX7W4V2SzdnkDsLCwkImJCWJiYm6rhB15fYuJrNlspqOjA0VRZPGckpJCUlISbW1tuFwuEhISoix9BFtp48aNVFZWMjk5KfUoAG7cuEFPTw9qtZq1a9fKnWJB8wb44Q9/CCzdM0SOIJqLPp+P3Nxc8vLysFqtUfoHZrNZuj/s2bMHtVotLQ2feOIJVCoVr7/+Og6Hg/b2dvLz8/H7/YyMjNDY2EhOTo4cGogpsMVikXaPFy9exO/3s2HDBilqlpuby8zMDMnJyWi1Wm7cuIFKpeLxxx+P2jlOSEigtLSUqakpyXg6f/68pMTrdDo8Hg+FhYWUlpbi9XqjcoW5uTlef/111Go1hw8f5kMf+tCKnK63txe3201XVxdr166VTUlhy6XT6UhISIiiYMNSE+O1117D5/NJ+vjyPfzOzk6Zgx07duy2FHIRc5fv5ItGTGFhIRUVFfj9/qhd7fn5edkAEWtPZWVlUfnE4OAgfr+fvr4+Nm7cKL8nYU2p1+vp6elhenpaWktFOk7odDr0jx1DnZGBKj0NTcRgwfetf8H3f//f229YpcL0tX9AHbnquCx/4VbsD3Z2Ejj9Jvqjj2D41U+A13vbnWXv3/8D3q99HVVyMonnzqIyRBd/yvwCoVsU/bkXXyT/L/78XRX2BQJvvoXr9/8A7ZbNmL72Dz9xXFxO3Xa73TL37+vre1fqdiAQoLW1FaPRSF1d3T0x0ZxOJ48//jjx8fE8//zzqxJLvo/V4z9dwSw6l4qiMDg4yPDw8F2Je71bsQyg27GdxB3bV/V8Op2OjOlpMmJiUT34oBRgunbtGhqNhoyMDHbu3EliYiLx8fEo//3/I+ZXP0HvzAwTg4NMTEyQmZkpFY/7+vrYtGkTgKSVe71eWbxpNBomJibo7e2VVk6jo6PExcXxwAMPMDo6ik6n46233gKW/JNtNhuKotDT0yMnnWJvdn5+Xk7//H4/Xq9X7tGUlZUxNjZGQUEBmZmZ9Pb2UllZyQsvvIDP55PCU263WwZD4Xco6ENerxe3243b7cbn87F161ZSU1MZGxuT+7iRGBgYYHp6moaGBnbu3InD4aCiogKfzydFGQRNt7a2li1btqwougQNWnhRi2Pn9/uldVVtbS3j4+NRRVMwGOT48eM4nU527tzJ448/LsWsxPM1Nzfj8/mkRVVk8BZCLcIGankRNzQ0xPDwMHV1dezZsweHwxEV/Obm5qRQy7Zt26L2jwREp1sEX7E3HggEGB8fl5Q2u90e1YUXKuE2m42srCwSExPlvvbi4iILCwvcvHmTcDgsJ6TCI1I8XuwcLy4uEhsbG6UEPjo6Sk9PD1VVVezbt0+qims0GjIzM7FYLFE2GmIqcTuIYvh2CYYQbMnIyMDlctHU1LTqYhmWzq9gMMjAwMB7UjBH4m6p2w6Hg2vXrlFaWrqCAbFa9Pb2cvjwYX7913+dv/zLv7xfLN/Hfwosb44Lca+CggJpp/huiJws3ynWm0wm9u3bt6r3JHZmk5KSqKqqkisvvb29sgG4ceNGuV6jUqk4duwYs7OzcoKZmZnJ5OQkTqdT6nnA25Z9arVaikmFQiECgQAXL16kvLycLVu2SEXd+vp6YmJiMBqNnDp1Sq6kOBwO2VjYv38/sHR/F3FiYWEhyhdYTForKyux2+0UFBRQUlKCxWIhOzubK1euMDo6Khk8TqcTl8vFgQMH8Pl8WCwWrl27Jj+DaKY2NzdTU1NDSUmJ1E7R6XRRjev5+Xm6urooKipi9+7djI+PU1JSgl6vZ35+XjoewFJ82bBhA0lJSVHfoxC3DIVCOJ1O2aRQFIXJyUni4+Oprq7G4/GsaFw3NzczODhIdXU1hw8fjto59vv9XLp0SWpwTExMRE3sRQNG5EoGgyFq0mexWGhrayM3N5c9e/YwMTERVQyHw2HeeOMNuUp1u0Lb5XLJ1xHfmcfjQVEUJiYmMBgMZGRk4HQ6V3j3trS00NvbS3JyslSPN5lMsjE+MjJCZ2cnycnJS7T4jRvkhFQJh5co0CI+xpnA6UJdUY7KZCI0OIj7//vvaOobMH37W4TOX0BdXo4yO4vulrWU81d/DWXRQrDtOvHf+r8rPps8jvalfEZxuyEUBJaOYXhhEd9zz6FrakL59G9hu3AR4yc/Se4qi2UA//HjKA4HgTdOolitqN5jBprRaKSwsHBV1G1FUWSxXF9ff0/Fstvt5sknn0Sr1fLiiy/+1MTIfpHxn6pgFsqZYr/UarWyZcuWqAncnRC5w/ROAfRuEXjzLZy/8SlQqYh/4Xkya6plN1r49QphBtGNTi0oIFerZeiWZ3JSUpL0JFQUhR/84AfU1dVRV1fHmTNn8Pl87N27l0AgQCAQkF1HrVbL7OwsDoeDq1ev8tRTT9HQ0CDN7GEpAAu/SViasGVkZLB27VrcbjdJSUmSniN8/QREF/rmzZscOXKEqqoqzGazpA9NTk7Kqfbc3NySPZZGQ35+PgMDA7JwEAlATk4OJ0+epKioiJ07dy4Jn0UINAWDQZqbm+V/R04uxb6S0WiUBbPL5aK5uZnY2FiSk5OxWq2kpKSwfv16YmNjyc7OjgrQZ8+eZWZmRlpNLLet8ng8siA1m81RE7/x8XEpDNXd3S2pyAITExOcO3eOtLQ0du3aRV1d3YpC7sqVKwSDQYLBIPv371+hgqzT6aRQS+QOfigUkh160Q2vra0lFAphMBhITU3lwoULDA8PS7Vrsd8rz9NAQAZ/j8cjfRlhKWlUFIWqqiocDoekyYmAajAY6OjoIDY2lgMHDlBbW4vRaCQQCMgE49q1a5I+duzYsRW74nq9XiaBt5u0Op1Orly5Qnx8PLt372ZqamqFzcipU6fkDrzJZKKpqWlV134k1q9fT19fX5QH9E8Lt6Nuz8/Pc+PGDZnkZWVl3bMa9sDAAIcPH+YjH/kIf/3Xf32/WL6PDzwiFXrfCaI5LpwH+vv7qa2tXbUY3moa43cLn8/HK6+8QigUYv369dJGUbCBhF6Ey+UiJSVFioZlZmYSExODoihkZGRQVlZGR0cH2dnZ/OhHPyItLY1NmzbR3d2Nz+ejvLycbdu24ff7eeutt3A6nczPz1NYWIjdbsdut1NeXi4dB8QxValUsmjTarV0dnai0WgoKSlhfHycUChEXl6epFULTQnx2fx+P4ODg9TX18sd3e9+97vAUvwT8WN2dha/3y+bBAkJCfj9fsrKymR+UFhYyPXr1+nt7eWhhx4iPT0dk8kUtaLS2toq926ffvrpqHiak5NDRkYGAwMDchIf6Vbg9XpRqVTU1dXR0NCwwtmiu7tbDi2OHTvG0aNHV3yfwv5ramqKDRs2yFhmt9ulenF6erp00BBwu91SBPXhhx/mkUcewWAwRH22jo4OpqammJqa4kMf+lCUGCgsXQfCw3n5lHBgYECuJCUkJJCVlUVOTg5Op5Py8nJGRka4cOFC1GOWDw2E8KrNZuPBBx+Uv0/S6YibnKR040a8ajVzc3PS89lkMpFhNJHy2d+D+Tniv/0vS1Pf+DgUvx9VfDwqjQbfv/8HwebLBJsvY/jw0xg+/KEVx1adnU1o0YI6b+WKkRII4P7vf0XYbMb4p/8NdWkx2oYGVBF5gft//DWBV17BExvL9S99kconn7jrdSXDJ36F0PgEuq1NqH/K61rvRt1Wq9XExsZSVlZ2T8Wyx+Ph6aeflqyHdxMivI97wwe+YL7bHWa/38+VK1dQqVT3LO4lAqj/jZN4vvA36I89SuxnPn1P71/xuMWLQMRETK1Wk5qaSmpqalQ3WngSp6Wl8eCDD5KWloZWq5WWOj/60Y/wer10dnZiMBjk+xb7x2q1Wno6pqamYjAYWFxcJCcnh1OnTqFSqdi2bRtZWVlYLBYUReHw4cO4XC5pt9XV1cX69eulrVRpaSlr1659x885MzOD1WqlpKSEmpoa3G43NTU1GI1G7HY7ycnJvPjii2g0Gg4fPszTTz8tVcvz8vJYv34958+fJxAIMDAwwKZNmyT9Sex8xcbGkpGRgdlsjioiQqEQ58+fx+FwsGPHDuk5mJaWJgsRMdUeHBzE5XJRVFS0Qi1ZNA2WU4bn5+eZnJyUCtJWqzVqx2dwcJBLly4BSxYPjz322IrjMzExQSgUksmECP6KouBwOKSIxODg4ApKUXNzM5OTk2zZsiVKqEVgdHRU7r0JWK3WKLXrSFE2eFvMTCiQJyYmSrGwBx98MGrq/sorrxAMBmUSmJiYSFlZmZyQdnd3yw5+V1cXJSUlUtRE2F+VlZVx8+bNFV38jo4OOjs7aWho4OjRo/j9/iiKu8DAwABTU1PAkpjJ7aa/sbGxMlHbuXPnPQWN0tLSFe/x/UAktTMyIXM4HJw5c+auVbdHRkY4fPgwx44d44tf/OL75hF9H/fxfkA0/jo7OzGbzTQ2Nt72vnE7iJgZWSw7HA7Onj2L0WjkgQceuCf7lch1k8gdXWH1GB8fT2lpKW63G7PZHCUQunHjRjIyMiQds66ujsuXL+N2uxkbGyMcDktGzcLCAtnZ2SQmJpKZmYnT6SQ9PV36AhuNRvr7+1lYWGDz5s3U1dXR3d1NMBhk165d0kJSxCzhNw1LjJTljeLlcDqdjIyMUFhYSFNTE6Ojo9TV1ck965KSEl566SWpPyKEywTTbevWrczOzkrRL4vFEsUAFFTh3Nxc5ubmVjRBOjs76e/vZ+3atRw6dAibzSbzAWEjKFaqRKxevhYlvich8hb52v39/WRlZdHU1MTAwEDUzrDT6eTEiRMEg0EpSrkcc3NzclAwOzsbFU/cbre0mhofH1/RtB8aGuLatWuUlZVx4MABrFZrVHPZ4/HIocHIyIg8zwTrEG6fM+v1+qj9dCFiupyB5/ytTxO81Ix2axPx3/m2bOiKCan10iW4JRI69dLLxH7m06TExKAxmQjPzRF2udDt24v/xZfQ1NSgjsjTAhcv4frdz6JZs4a4f/83wgODaOpXNqaD19rwP/v9pcds3EjMb3xyxd+os5bOF19cHFU1NeTcg7aHtraWhGe/d9eP+0kRSd0uLi6mpaUFRVHQ6XRcunQJk8kUxTR7txrI5/PxkY98BIfDweuvv74q95/7uDd84Avmu4GgFGVnZ696B+Cddph8//IvhMfG8H79G/dcMOsOHMCkUqOKM6Fdt/a2f7Ocqim60aIQSkxMRKPRUF5eTkNDAx0dHeh0OqqqqpiYmECn03Ht2jVsNhvbt2+nsLCQzs5Ourq6OHDgANXV1YyMjMgAOT4+LtUUBwcH2bZtG/Hx8SwsLABL3cjU1FTUajVarfaOF+C2bduYnJwkMTGRV199demY+XxRdgiisOzv7weWilKPx4PBYODGjRtS2drn81FXV0cwGFyxa3727FnGx8eprKxk7969hEKhqP00sQ8MS0FkzZo18ndqtZr09HSqqqqYmZlBr9ej1+vp7u4mEAhgNBqZm5ujoKCAnTt3Mj4+vqJTefr0aXlu7d69O+p34+Pj8rMBUhkakN69Go2G6upqXC7XioKnvb2djo4OkpOTOXjwIJs3b446BwU9WHxXkftdwt5J7FOrVCqMRiNOp5OcnBwp4CX2vIRat0qlIi4uDr1ez1tvvSXp94B8jsjXEI2EyJ06WEpGPB6P3GkT56kQPNNqtQwPD6PT6Th69OhtVUn7+vqkBZlosETC6/Xi8XjIy8ujr6+PuLi4qPNxdnZWFpSlpaVMTEywZcuWn9sOq6BhFxcXSzrm3apuT0xMcOjQIQ4cOMBXv/rV+8Xyffyngyh4bTbbXYl7RVpERk6WR0dH5d7t/Pz8qle4IhETE8P+/fux2WxR9NrlMBqNFBUVUVRUhM/nk3ZVAwMDcsqak5NDWVkZs7OzhMNhEhMTpaCjsKQqLS2lqKiIwcFBRkZGaGho4Omnn8bj8fD880tKxv39/czfEgwVK1c5OTksLCxI1w/hyetyuaKcGCJRWVkp3TMuXryIzWZjbGyMAwcOyPsUQHZ2Nk6nU67NOBwOFEWhr69Pekn7/X6Ki4uZnp4mNjY26jX7+/u5fPkyCQkJHD58mKqqqhXNi46ODoLBIF1dXRw8eFDe6xVFkXZYYnc3JSWFsbExurq6iI+Pl+tCW7duxWQykZCQEHXutLa2SvbU008/HdWYt9lsXLt2TRbbkbEelhrrVquV/Px8iouLCYfDUZPn2dlZTp48iVqt5siRI3z4wx9ecW/u7e3F6/XS3d3N2rVrV4iP6fV6ORBJT09nenqawsLCKA/n+Ph4dDodtbW15OXlEQqFpEhrR0dH1OstF51UxG78rf8XUE9MkPTGSZIL8vE21BNKSMBz4GFGe3rw+/1kAjm/+3uofD7i/vmfSLrWwnL4T5xAsVoJnjkDDifatWuifq/4/YS6e5YsnSrKUebn0T7wNoswbLHg+Mgvo7hcBL70twymJFO4c+c9FcsfBASDQak3s3btWtRq9V2rbvv9fj72sY8xOzvLqVOnVt00vI97w3+agnl6epqRkREMBgP19fV3Je4l6ErLH2P42McITUyif2ylbc5qoVKp0B94eNV/39/fz/T0NGvWrJHd6FOnTmGz2ejv7ycnJ4f4+HgqKyvJz8+Xkz4h+CE6t7B0gxfiINnZ2dJ6KSsrSxaQKSkpPPPMM6SmprJp0yba29uleMUTTzwhC5/bwWAwUFJSIv0bl9OHwuEw7e3t0p85EAhgMBiIi4vj6tWrmEwmwuEwzc3NaDQannjiCQ4cOLDidYS69tzcHCqVSr4ft9uNzWaTImBOpzMqUXE4HNL/8sCBAzz++OPodDq0Wq2c7F64cAGbzUZHRwd+v5+srKwVQcxkMq1Qa1YUhYsXL0ohtGAwKBMBAUHDBti7d+9tFTCFsqfYtRKvHQgEmJ6eJiMjg9raWiYnJ6M63aFQiBMnTmCz2UhNTSUUCpGfn88DDzwgn6erqyuqGIal5kJ1dbVsEIlkQYiEpaWloVarmZqaoru7m6SkJGmbEklTdrlc0v5EoLi4mLq6Osl4EBS5QCBAe3u7VD4VFiRCnKenp2cFJU08TkwqNm3axFNPPbXib8bGxvD7/dKqY9u2bbcVCrsdrly5Iif390p7fi/hdDppbW2lsLAw6jx6J+o2LKlu9/X18cADDxAMBjl48CC7du3i61//+vtSLH/jG9/gG9/4BiMjI8CSdsBf/MVfyGvZ6/Xy+7//+zzzzDP4fD7279/P17/+9XsqSu7jPzdWQ8l2Op3SIrKxsXFVKrCrEfcaHh7GaDTe1vN9tUhLS7tj0bkcc3NzdHZ2UlxczIYNG6ToT09PDz09PeTm5i7RYG/FAPGeX375ZQAZvwHpmOB2u0lNTZXWS2Kl48aNGxQXF/PCCy8QCoXYu3cvCQkJ2Gw2LBYLjzzyCMFg8I6MPJVKJZlPgjm0nCo8NDTE7Ows9fX1UnS0vLycjo4OHA4HRUVFMh7u3r1bsuYiIWK93W6X+QIsFRdms5m0tDTq6uro6+uLYnmFw2Fef/11FhYW2L59O8eOHSMUCsn36PF46OjokEOBs2fPUlxcjF6vl/kfIGO80WiMygf7+/u5ceMGpaWl1NfXr5gc+3w+Xn/9dcLhME6n87Y7x0IrJhQK4XK5ogr96elpyS64fv36CpbT1atX6e3tlTvJMTEx7Ny5U67UWa1W6eEsPuPs7KyM2YqiyLgoPpewIAtNTOD5H/+TYHERrU8+QfaafiqWTXWdn/wU4dHRJZXsUAhd40Yqt2yh4pbjyOLFi6huMSCGz59HX1QoafbB1lbCViuGX/4IoYFBtOvXocpaee93/fbvEDj9JrqH9pB4/JUVvw+2XSfcvzQ8mHrxJYo/8+lVxxD/K8dx/+8vYvjQ08T+1n9Z1WN+mhDFslarZc2aNfLaXo3q9uzsrPSH/9Vf/VVGRkZ48803VzAmfxr4RY/1H/iC+d0K30hxr6KiIllUvRverVgG0D+8H/3DKyk3d0JoeBh0OjT3qGYbDAa5cuUKsBTQd+zYgdFolF1ArVZLIBAgISGB3t5e+vr60Gq11NXV0djYyMLCAnV1dSiKIilgr7zyCoqisG/fPgKBAF6vl46ODpqamoAlW6dQKITZbGZubk523y0Wi+xWCSunuLg4OQEU3oPT09M0NTVx5MgR3G53VLIwMTEhrZeSk5OpqamR+9SZmZlUVlbKpH/58bfb7QwMDFBQUMD27dsZHh6OsjUKhUIcP35cTqYjlawFFhYWJI1tfn4+qghxOBzo9Xrq6uq4cOGC3CcTZvThcJiFhQWKi4vZt28fNptN3pAURaGzs5Ph4WFgqWgTxzMSkY2GyH8HAgFu3ryJ0Whk/fr1xMXFkZOTE5XEXbhwgYmJCZKSkjh8+PAKmpzP55M7Y6IpYrfbo87l1NRUKfwifJULCwuZn5/n1KlT6PV6XC4XKpWKvXv3EhsbK/ekW1pasNvtzMzMoCgKU1NTUZ1+jUYjmyRi9zgxMRFFUejt7cVut6PRaEhMTKS4uBij0Sj3vEOhkLxOH3300ajvJRLCVgyQe/ECc3NzOJ1OSktLmZycRKVS3Vbg7U4IBALST7S/v/9nXjA7nU5aWlrkdOJOuJ3q9szMDH/1V38lp/k1NTX88R//8T3RSu8FeXl5fOELX5D+3t/5znc4evQobW1t1NbW8nu/93scP36c5557jsTERD7zmc/w2GOPrdizu4/7eDcIe7aCggKGhoZWte+8Gm2S+Pj423rn3glCrDI5Ofme959bW1ulnV9hYSE6nS6qqAkEAiQmJjI/Py/9iUtLS2lsbGRgYIDS0lIyMjLk5PHy5ct4PB4aGhokBbe1tZXHHnuMwsJCxsbG5H10enpaxg+z2UxZWZm8XwgxzMid4cHBQekDv2vXLubn56Nivd/vj7Je2rp1K4FAgOvXr0slbyG2KT6fgJgWx8XF0dDQgEajIT09Pap4v3jxImNjYyQnJ3Po0KEVGhPLbSvF8RTfVSAQoKamRsaKsrIy7HY7V69eRVEU5ufnMZlM7N27l/z8fOLj4+V7nJmZobW1lWAwyODgIOvWrVvRFBGOEuFwOCrWK4pCf38/TqeTmpoavF6vFOMS6O/v58qVK6jVah599NHbnodin1ocQ/GZRMPbaDSSlJSEz+cjLy+Pubk5ampq5E6r2+2W18qGDRsoLS2Vwwf3V/+ewK3mt/0zv8V0eRmZMTFEto1UaakwOgoJCWCxoK5aalYEz19A/fIrpKckEygtRdXYiPGXPsycxcLg4CCJ8/OU/tlfLL3HL/5vEp757orPJhAaX6J6h8bGo34enp4mcPYc2h3bCT20B+fMLNkf/WUy7qII8/7Lt1Gmp/F+85s/84I5FArR1taGWq1mzZo1d4zTd1Ld/spXvsLzzz9PbGwsBoOB73znO++bZeYveqz/wBfM7wQh7mWz2diyZYtUOX4n/NTEvS5fwfnRj4FGQ8JLL6IpL3v3B92CoCkbjUYyMzMxm80YDAZ+/OMfU1VVxfbt27ly5QparZbGxkZiY2NxuVy88MILKIrCwsKCtKoSQXbDhg1MTU3Jm2QkfSgcDjM0NER8fDxVVVWSilVaWorT6URRlKg9WiGQodPpeOyxx9DpdFIABJaC6fbt22WwF8dWWEYoikJycjILCwu0t7dLz8DFxUU2bdokhc0i6UHNzc2YzWaGhoZ44oknVnSoFEWR+zuiqBKYmpqS0+aKigoURYmiRo2Pj3PmzBm0Wi2PPPIIH/rQ26IURUVF+P1+Xn31VUKhEIODgwSDQTIyMtBqtcTFxXHjxg2ZLFmt1ijaVDgcllPr7du38/DDD6NWq6O6f319fdJq4sCBA1G7xpHnhHi+SNhsNkZHRykqKmLTpk1S7GVmZmaFIvf58+fxer1kZWVFqU4LoRRBsRbT9qSkJFwuF3q9noyMDOx2u9x1F82Knp4ebt68SWJioqTPb9y4kWAwiMlkwmq10traGvWetVqt7Ij6fD7a2tqYm5tDURRaWlrIzs4mPT1dKpwuLCzQ1dVFYWEhu3btwmKxrPCefP3111EUhdzcXKk+ezeqkGKlYXJykvLy8lU/7qcBl8tFa2sr+fn5d7U/HbnKcerUKXbv3i3XKRoaGigpKeGRRx7hC1/4wk9V8Gt5gvfXf/3XfOMb36C5uZm8vDz+3//7f3z3u9+V6wz/8i//QnV1Nc3NzVGepvdxH3fCcnGv7OxshoeHb+vFvPxx77W413LmS2Qj992g3JrImUwm8vPzJf375MmTJCcns2bNGtxuN1arlfXr15OWlkY4HObEiRNYrVbMZjNZWVmkp6fLRLuhoYFgMCjVqIVSsni96elpAoEAOTk5lJSUEAqFpNq0mAgLLC4ucuLECQAeeughGdt6enrwer10dXVRX18vfy6sl7RaLUlJSVitVim6de3aNQwGA263m7feeott27axb98+FEWJiuc9PT2037IGOnz4cNQ+roCI8ctjvc1mY3JykqKiIjZu3Bg1VRXH4sUXXyQYDPLAAw9w7Fg0WzAUCnH58mUCgQBWq5UzZ86Qk5MjacwjIyNyX3twcHDFulZ3dze9vb2sWbOGw4cPY7fbo5qvVqtVDkH0en2UkraAiPHLLRf9fr/0jd68eTP9/f0UFhZKC83IeHft2jWsVisGg4FNmzbJ83xubk42RgTsdjs6nY6w3U7Y5yO4aRPKf3wXiopQ5+aSnZxMUlISwbY2nJ/9HOqsLEI3bqAuLSXume/CwgLqW01d1x/8IUqEjaS2IJ+8khLybh3bhZYWFEAFdPf2or15k/T0dEkvDluteP72S6gzMzF95csETryK/nC0VaTjV3+N8MAg4Q3rufHJX6ehoeG2Fm/vhJhf+wSev/0ShqefvqvHvdeILJbXrl17V01tobr9rW99C1hiSWzfvp2PfvSjaLVaDh48yOc///l7dtRYDX7RY/3PRcF8O5qWuCFrNBqamprQ6/VYrdZ3DKB3EvcKnDmD95v/hP7ppzDcRi1xNVBmZ5eEvYJBwgvzqy6YFUXhtddew2KxsHbtWh566CHC4TCvvPKKtIDIzc0lMTFRqj3CEi3KYDDg9XopLy8nKysLs9lMW1sbdrsdg8HAmjVraGpqkgVwamoqZrMZp9PJxYsXpa1F5F7u7QQ/xJQ2GAzidDrljmxZWRkTExNRatFer1dOfh988EFUKhXBYJChoSEsFgs1NTVymj03N0dlZeVtffMSExMxm80r9qdHRkYYGhqitraWffv2MT8/H1Uo2u12Tp8+DSzdnG4XfIXSdTAYxOfzyal5OBxmfHycpKQkNmzYQEdHByUlJSQnJzM3N8f169eZn5/H6/WSl5cnBT8iO8qioAUYHh6OOp6iWSO6gXq9PmoiKjreycnJbNu2jYmJiRWTz7Nnz0b5U4tk7W4VIjUajfRe1mg05ObmMjo6yrlz59DpdLKY3rRp0wqfZ6/XGzW5NxgMGAwGSaGLiYnB5/MRExNDOBwmOztb7ljZ7XaamprIy8uTvxdTI1iiNIp9womJCT784Q+v+GziulUUBY/Hw+7du+/Jb3Djxo1s3Ljxrh/3XsLlctHS0kJubm7UeXw3WFxc5JFHHqG+vp5nn30WvV6Pw+HgjTfe4ObNm++rOnYoFOK5556Tll6tra0EAoEo+mVVVRUFBQVcunTpP0UQvY/3Drc7V8PhMF1dXczNzUWJey23lrrd45Y3xoXafkJCAhs2bLina0Os38BK5su7oa2tja6uLjIyMti3bx9VVVVcu3aN3t5e2ewX9orivqtWq0lMTJTF6Pr16zGbzXLfF5auqQcffBCLxSJttbKzs9Hr9TIebtu2ja1bt8r3IpqYkYgsSD0eD+Pj46SmplJTU0Nra+uKWP3WW28xOTnJunXriI2NxWq1MjU1xczMjIwvJ0+eBJCWicshYrxOp4u6j1utVtra2sjJyWHbtm2Mjo6uiAWnTp3C7XYzPT3Nnj17VohBer1e2Vh3Op1RvxP74Q0NDZIiXVlZycLCAv39/TQ3N2O324mJiWHbtm00NjauWE8Tq1ydnZ0cPnw4am0rHA7LKaDP54uaAkYW6ps2bSImJgaTyRT1+I6ODrq7u6Ulp2h6364geiemhV6vR6fTUVFRgcPhoLa2lvD0NLYDB8Hj5fLHP8b8H/8hTU1NHI1QRnc9/wLK1BShW2Kb4cFBVF4f6tJSFLebsMGApqaa4PkLqEpKUCYm0B9coub6vvs9fM88S9Lv/jbqHz5H2GKlsKGe+fl5BgYGuHnzJsnJyeS8cRLDLYEv3fbtxP7u76x4/6pbTAOH38+aNWtWvfIQdQwOHkR/cKXP8/uJUCjE9evXAe66WBYIh8N89rOf5dq1a1y9elWuaV26dImXX3551Qy79wK/iLH+56JgXg4hvpCWlha12xPpw7wc77TD5P7ilwj39hLqH7jngll36CBGhwOMRrSbN6/6cWJPAZYoxDabjYSEBEpLS6VVkPAKVKlUnDt3jpmZGbZt28aRI0dwOp2kpKRIcYCEhATOnDmDw+Ggra1NimqYzWZSU1MpKSmRCpJi/0XAbrfT19dHXl4eCQkJtLS0EB8fT11dnaT8vPnmm7jdbsrKyrBYLJLiLXaH7Xa7nGbPzs7Kwmt8fJx169YRHx+PwWCgr6+P2NjYKJGC0dFRLl68SE5ODjt27KCysnKFLZAIMj6fjwMHDqzYN9NqtTKRiqR0hcNhOjo6UBSFmpoawuHwCuunjo4OOjo60Gg0PP7441H71EKxWJxfQmxKiC8lJCTgdDpJS0uTPseR+9Rer5dXX30Vv9/Pvn37ePzxx9FqtVFT9b6+Pqanp5menqasrCzK1kPAaDRis9lW3BgnJiYYHh6murpaenzu37+fubm5qIbG9PS07ObHx8dHTbfFPnWkuJewbpmZmSE2NlZ6gufn52O322WCcvnyZfr7+4mNjcXr9VJSUhKVnC0sLEhGwtDQUJTqekZGhqTFCTEa8VnHx8dJT08nJiaGkZERbty4QXl5ORUVFVgsFrZv335PxfIHAW63m9bWVnJyciRF7m5htVo5evQoubm5PPPMM3KfMz4+nscee+y2iu0/DYg1D6/XS1xcHM8//zw1NTVcv34dvV6/QowkMzPzXdlA93Effr+ftrY2QqEQTU1NUdf6neL9O4l79ff3Szuf0tLSe6IyxsbGsnv37ijmzWohfIgXFxdxOBwYDAby8/MZHBxErVbj8/lkAdXX18f169eprKxk27ZtVFdXk5SUhFarJTExkaKiIp599lkAbt68SXx8PMnJyczOzpKenk5JSYm8p0N0Y1cojMfGxlJaWsr169dxu91s3LiRHTt2SEeHgYEBjEYjpaWleL1e+vv7ZT4Ab1OFp6enZSN6dnaWtWvXkpaWRmJiIsnJybjd7qhiVyj6ajQa9u/fz9GjR9Hr9VExu6Ojg8nJSSYnJykpKbmtM4KYYC/fvR4ZGWFmZoa6ujq2bduGy+WK+q7MZjNvvPEGsLRPvXfvXvm75ORkuaYGS7H77Nmz0pM4LS0Np9NJcnIytbW19Pb2Ru1TA5w5c4aJiQkaGxt59NFHCQaDURPhmZkZhoaGAMjKyopiUAmIGK/X66O+O4fDIZl6IkdobGyUzANxrns8Ht588038fj9arZba2tq3v//ubnAtKXmbZmeZL8jHd6tZEuzuAbcLdVEhqqwsNOvWgt+Pdu1a1FmZ+F99Dddnfw9VSgrK/Dyq3FwST7yCKqIAdP/t34LDiffvv0bCCz9a+hy3jm15eTlOq5WFkRHmcnLI0WoJxcczrlKR5nAQFxdHeGgI1+/9PuqiIhx/9d+ZeeMkRU8+Qeo9FMsfBIhiORwOs27dunsulv/wD/+QU6dO8eabb8rmlVarZceOHVE2qz9N/CLH+p+7gnl6epqbN29SVlZGUVFRVJKp1Wqj9pIF3o2CbXjsGJ6//RL6nyC5VGk0GD7yS6v++8nJSaampqiurmbnzp0y4Lzyyivk5+dLP0S32y2VcH0+n5xeDg0NkZOTIwOFoJ2lpKRgMBgIhUJs2bIFjUaD2Wymu7ub2dlZjEYja9eu5YEHHiApKSkqAbl69SrT09MMDAxQU1PD2NgYAAUFBVRWVkYlIZECXwaDgampKex2O6WlpeTn52Oz2SgsLMTj8TA/P091dTVnz55FpVLR2NiIz+fD5/NJOjksFcyhUEh6QkbuULtcLkwmEwUFBSuslxRF4fLly1KA68iRI3i93qhO5OTkpFSITEhIuCufXYvFwoULF0hJSWHnzp2MjIxQXl6OwWBgbm6O0dFRRkZGCIVCZGdns3Xr1hX0YIvFIqcRs7OzUcFfUOjy8vIYHBwkKSkpqiCenp7mwoULpKamMjc3h0ajWaE4fenSJXw+H06nUxb6cXFxUR3r2dlZOjs7iYmJwev1Rvkwi+82Pj6esrIyDAaD9K/u7u6mtbU1iulRU1MT9R6F5ZPX6wXenrwIMZrExEQyMjJwOBy3ZRRYrVZOnjyJSqXi0KFD8nEzMzP09vYSHx8vfb2vX79OUVERDzzwwKps48LhMFevXsXlcrF58+b3tQt7J7jdblpaWsjKyqKsrOyeimW73c5jjz1GamoqP/zhD1d1LH5aqKys5Pr169hsNn7wgx/w8Y9/nDNnzvzM3s99/PxDKMYnJCRQX1+/Yrp3uwnz8sb4cn0SobafkJDwE9mv5OTkrNrz2W6309vbS15eHps2baK3txeNRsOLL75ITEwMe/bskY4HWq1WxtX+/n78fr+k/Ip4pigKfr9frs6YzWZqa2vJz8+XdlXNzc3Sh3j37t1otdoVe7MiHqrVarq7u4GlgkbERnFPj2w+azQa3G43Q0ND/P/snWdgnOWVtq+p0ozKjHq1ui1ZxUWSO9hgXMA2lqgBkpBkCZuEEtI2JISPJJu22bApu4GQTbLppOACptnGNrZxwbjIkiVZvfc2oxlNL+/3Q34fZizZ2HIl0f3HoDb9Pc855y4ZGRnMnTuXhoYGZsyYgUKhoKamhry8PCorK3G73ZSUlGCxWPD5fEKDDOMNozxYHxoaCtqaOhwONBoNqampdHR0kJCQEPTat7S0iEHC6tWrg84QMD7wPXDggLjvkxlwnQter5d9+/bh8Xi48cYbaW5uJi4ujuTkZIaGhhgYGOD48eMi6WP16tXk5+dPiKzq6upCkiS6urqYNWuWGIx7vV5hzBYREYHH4wmSdDkcDnbv3o0kSaKpKigoCHr8VVVVtLa20traSlpammioA70vbDYbJ06cEOknZ7/Xe+PjMX3kHhJDdeR87KMkejzjdP36eqxl5eNsyTPQrlhByF3vn409hw+D3490RjMuDQyA240UGoqvrh5lUiIhH/sY7j+/SMh9EynQksuN7+57iGzvIPHZH8G7hxgeHcViMtF69CgajYaMN7cTfvo0vtOn6SieR+6nPnnBplaul17CtWUrusceQ7Ns6Qf/whWGz+ejsrJS5LOfy0T3fPD7/Tz11FO8+uqr7N2797w+J1ca/8y1/kPRMCsUCvx+P01NTbS3tzNv3rxJNQzyBcbv94v/vhANU+i/fIrQf/nUBd8fv8WCQqNBcRGayaDf9/vZt28ffr8fu93OihUrSElJ4bXXxp0Bh4aGgjTHNptNxB3l5eXR3t4e1Aza7XZee+01fD4fa9asEVsl+TkwGAzYbDa6urpETqHH4xET07i4ONEc9fb2YjAYSEpKoqamhrCwMEZGRqioqBD5kFVVVYSGhrJ48WIGBwfR6XTivjudThHxJDd5q1evFpNoWfMU+Fy0tbURGRlJQUEBTqeTlJSUoM3r0aNHRVFesWLFhOglt9stopeampq44YYbghwo5ViOQD21DIfDweHDh4X2x2g0YjAYxKZubGyMPXv24HA4sFqtExyVIyIiyMzMpKOjQ2QRHzx4kPDwcGFcYrfbycjIIDc3F5fLFXSxM5vNvPHGG0iSxK233spHJtHYtLa24nQ66e7uFl8zmUzExMTgdrvRaDTExsbS3d094RBXW1tLS0sLaWlpDA0NMXfuXKFVDmyYrVaryHJ2Op3B0+gzWxz5EKpSqcR2p6mpidDQUJHjnJWVJRgIMD5p7+npIS0tjTVr1kx4bIGPRz78ytEcRqORzMxM+vv7sVgs2O12nE6nYDuMjY2h0Wg+0Al6ZGRERH81NzdPqiO7mnA4HBw/fpyEhARBn7xYjI2Ncffdd6PT6di6des137JrtVrxmpeUlHD06FF+9rOf8ZGPfAS3243ZbA6aPMsOvtOYRiDkz8LAwABVVVWkp6efc6AkD8hlXEitj4uLm/Qaey74fL7zukdfCI4dO0ZPTw/Nzc185CMfYcGCBUJv7HQ6gzwffD4f7e3tJCQkUFRUxLFjx4iPjxePSZIk3nrrLQYGBigtLWX16tV4vV5RL9PT09HpdOJ619HRgVKpRK/XY7FYiIuLIyIiQlz71Wq1+Jrso7J7926SkpKYPXs2fX19hIWFkZ2dLeKndu3ahdVqpetMHq/NZqOiooL4+HhhVCo/prMp6zLrbMaMGcJIMrCeyv4ioaGhbNy4kfvvv3/C0OP06dPY7Xaqq6uFnj3w+VOpVEJPHXhOlD0zzGYzixcvZtWqVUiSJH5fbpbls4rf72dRAFswNTWV1NRUxsbG6OjowOPxcOLECfEcGgwGLBYLKSkpLFq0iI6OjqBaI0vtxsbGKCkpoWwSNmNfX18QKwDed732er0iBqy1tZXo6Oigc1JfXx/Hjh0jISEBu90uNOsWi2VCw/ze0aM48vJoNxi4PYAJ53W63m+WFQqQJBRnzkvuN9/Eb7EiqVQoc3LG6dceD+pFi1DodDj/+Ccc//4dFDExGN7ejf5LX5zw+AAkyyj+9vFljO/kSfRlG0k2GEhOS8PT2cloXT0jNyxDvW8/zvg4NHl5uFwuPB7PhBisyWD/7vfBbsfx059e84ZZTorxer2X1Cx/61vf4qWXXuLtt9+elHl4NfHPXOs/FA2z1+ulsrISi8XCokWLJtB0ZcgNonzRnEzDdMn3peIk1o9+DIVOR+Trr4kA9YuBbNYzMjISNDVbvHgxe/fuFZMoWSsl05ALCgpQqVQ4HA6OHTsmiuPo6KjQHg0PDwfRlE0mE1qtVphWaLValixZIpyKGxsb2b9/P+Hh4YJCbDab0el0fOQjH0GhUPD3v/9dmETJTt319fWUlJSQlJQUFCslNzOyAUVoaCinT58mPz+f6OhovF4vGRkZREdHo1QqhTZYqVRy5513TtpUye6X8r9ygyRnI8fHxzNr1ix6e3uDDJy8Xi9vvPEGY2NjrFy5krvuugtJkoJiSNra2sQkPSsri/T0dPG90dFRKioqiIqKwuFwEBYWFvQeGhgYoK6ujqysLNasWUNvby9ZWVmoVCqGhobo6+ujtrYWSZJoa2ujtLQUo9EY1OBZrVahqR8bGwt67QYGBoRjaG9vL6mpqWg0Gnw+HxkZGTQ0NPDee+9hMBgErf/s/E+ZBmSz2Vi9erV4v51Nm5Hp6RaLheTkZPx+v5ikyxnOJSUlhIeHo9PpCA0NpbKyckKu40033RS0XZd1YzJd72z09fXR19dHTk6OkFcEUvd6enqEBi8nJ4fMzEwyMjIwm83U1NQIcxaZKjdZQTUajURFRWGz2S5a6325IX924+LimDVr1pSuSXa7nXvvvReFQnHVdUsXCr/fj8vloqSkBI1Gw+7du7nrrruA8azRcznLT+OfG5Ik0draSlNTE4WFhed1rw/cMF8pc69XX31VDLWnaqYTHR1NT09PkKN2YWEh/f39jI6OkpiYSGlpKUNDQ3R0dPDOO+9gNBopLS3FbrfT1tZGSkoKmZmZIrECxq+deXl54ppnt9txuVxER0cTGxuL1Wpl7ty5xMTEiL8tuzHn5+ej1Wpxu90iVkqSJA4ePChkQXPmzMHpdOJ0OhkeHhaHXp1Oh9VqRafTERERwdDQEGq1msTEREHZzsrKore3VwwFzWYzer2eHTt2AHDjjTeyYsWKCc+V3BzKtys3en6/n4GBAQwGA/n5+VRWVk6gw7/77rs0NTUxd+5c1q1bh8vlCqpFo6Oj1NfXA+Mb9uLiYvE9mfovP5dKpTLodx0OBxUVFURERLBgwQJiY2NJTEzEaDRiMpkYGBjg4MGDuFwuqqqqWL58OcuXL59Ag5cHCGc3xVarFYvFgsFgICIigtDQUJH6UlRUhMlkYvv27eJcC0yQ8dTV1WE2mzGbzSxZskQYSE4mO0hPT6eurk6wvVx/fwn3jp0o4uPAYCCkbCPajz4AdjvqwkK8x45h+/wXgv6GMm1GkITRf2ZRIplMSA7HhIWSr7MT99/+juaWleh/8H28VVWEfu6z7//+6ChjGzaistuJePRznP7Ot8nNzcXocIhs7LOXPJNBe+cduF/ahLZ8avLKywW/3y+YFlNtliVJ4gc/+AF/+MMfePvttyeVJVxr/DPV+g9Fw3zy5Ek8Ho8w9zoXhImXxxN0YblcBRTAW1MDHg+Sx4OvrXXKDfPatWtFEwbjTf7p06cFpVV2BvZ6vbz77rviZ+RhgVarpaenRzheFhUVTcgB7ujoYP/+/ahUKm699VZcLhcOh4PTp08zd+5cQW+G8cZGbkh9Pp/IgUxISCA9PZ2mpiaSkpKIjY3F4XCQkZHBoUOHGBgYYNmyZaKpGxsbw2g0ip+Vcxfhff1We3u7yN2Vb/Ns2O12GhoaSEpKYtasWVRVVU1wEH7rrbcwmUxkZGQEuUDLkIsQjB8uJptyJScnU1tbS0hISFCz2tzczJEjR4iMjOTWW2/FYrEERU3A+OZgZGSE/v5+7rnnnqDClJSURHx8vKDVKRQKoaGOjY3F5/Ph8XgoLCykpKQEv98fdCALbBRlKrQkSUFFvr+/HyDIBVM+ZAwPD4tNgtlsprCw8LyUJpVKxbp160SGc29vrzhcBD6fge+vQJqe/N7UarU4nU6qqqqIiopi+fLltLe3T0oh8vl87NmzR2RXTvYanm1Cc8MNN6DRaEhKSiIvLw+LxcLg4OB5C6parWb9+vUT/vbVhrxNio2NJTc3d0rXJKfTyf3334/L5WL79u1BlPtrha9//evcdtttpKWlYbVaefHFF9m7dy87duzAYDDw0EMP8aUvfYno6GgiIyN5/PHHWbJkyT+ECcg0Li9kV+KFCxcGMWAmg8xyuRKDcRi/3tjt4zrPs2nDF4O5c+eSk5MTFMnY1dUlmsOhoSEKCwsxGo1CciVnCMvXfrfbLaRoN9xwA93d3UEsILvdziuvvILP5+OGG25AkiRcLhfHjx9n3bp1JCYmYjabxfNkNpvFtbWxsRGVSkViYiIzZsygo6ODmJgYMjMz6e7uFkP5gwcPMnv2bNLS0hgYGMDhcGAwGEhLS2PevHls27ZN3Pf29nYkSaKhoYFbbrkFg8Eg6j8Ee8j4/X7q6urGqbgZGbS3txMeHh60GKmsrBRyojvvvHPSeiIz2zo6OigqKprQUEVERBAXF4fFYgl6LS0WC9u3b0eSJNauXSs0pvLrBeMHf1lznJqaKs4vMB7fKBuqdnZ2olaraWlpobq6WrhZy5nUK1asYHBwMKjxcbvdgiEYHh7O2NgYXq+X3NxcoW1uamrC5/MFMSpkFuLo6ChqtVpkRyckJHxg2kJpaSnFxcXjrAWfD/sz3wSfT2yVvadOoQ80hIuMBKUS/H4IHa/76rw8JL8f5wu/RLJaCf30p1EYjagLC1BOctawP/MtvAcO4PrLXzEeP0rI3XcF/4DbDWfMRM3tHZR86lPiGpCTk4PD4RBmsQ0NDYSFhYlaHxkZKT73Yd98hrBvPnPex3+lIW+WAxvJi4UkSTz77LO88MIL7NmzJ+jzfq3wz17rPxQNszwN/SDqpUKhQKVS4fF4RGP9Qb9zsQi58w78XV0oDAbUkzgwXyhUKpU47LpcLk6ePIlarZ6ga1Gr1SxatIj33nsPs9ksMgCdTqfIZpTz3M6GXOzl5ky+oCiVSlpaWoiJiaGgoIDR0VGMRiPLli2juroaj8dDb28vdXV1hIWFicLV0NBAUVERGzduxG63s2XLuJlDc3OzmHo3NTVRVFQkcuPUajV+v5/U1FT6+vpETqCM2bNnExkZKaaqMo4fP057ezunT5/GaDRit9tFoy9DdmqW/5UxMjLC0NAQGRkZFBUVYbFYzmnOYjAYxDRMRl9fH1VVVeJgIRuryZBNNFJSUhgZGZmwtWxqaqK2tpbCwkLWr18vtggKhULEYMib2cHBQRGTEPheDSyMcoyXXq/H7/fT3NxMSEiI0CjPmjULtVotdGonT56kpqZGbP2BSXXDZ0M+nMmRWWFhYbjdbqKjo/F4PGRmZuLxeNi3b5/YPCuVSpYvXy62u0qlksrKSpFxXF5ePul7E8bfh+Hh4ZNSxurr6+nt7aWwsFDQzOVmOfD+GgwGDAbDRRXUawGn08mxY8eIjo4mLy9vSvfF5XLxsY99DJPJxFtvvfWBDcXVwsDAAA8++KCQc8yZM4cdO3YII52f/OQnKJVK7rrrLlwuF2vXruX555+/xvd6GtcjUlNThcnfB0FumCcz97ociIyMZMGCBYyOjk4wdboYKBQKUevl5nBwcJCUlBT6+vqCWE0LFy5k165dgiVXVlaG1+tl+/bteL1eRkZGWL58edDvwPg2XH4e7Ha7YNupVCq6urpQqVRkZmbS1taGx+OhpKSElJQUQZHet28fKpWKGTNmCANGp9Mp/DC2bduGw+EQDt8w3ugbDAYWLFhAaGgoUVFRmEwm4uLi0Gq1tLW1BTVu0dHRrF27Fq/XGzS8bmlpERT1rKwsrFYrVquV4eFhIT2Ta7zH4wlyhHY6nbS3t5OcnMyiRYtoaWk552slG4wFYmxsjHfffVcMD3p6eoKaYbl+JiQkUFtbi16vDxpSDg8P8+677xIbG8vSpUuF4ZosxRoYGOC9997D7XbT3t4uYsgCm3l5GA7vG7PJixQ5L1ve5sfExJCRkSHONL29vezevTvIX+RCaj2Mf178ff0oYmPQrFqFZ9cuNLesxNfQSOinPw2A/UfP4n79DRSRkeD3E/LZz6D77GfGqdrh4XgOHsL5k5+OP79paefNOFZlZ+E9cEBEUonn+NgxHP/7a0LKN2L94Q8YrThJ2qOPTKhvOp2OtLQ00tLS8Hg8DA8PMzg4yIkTJ1AqlaLWy8kf1wqywazT6bykZvm///u/+dnPfsbOnTvPeYa62vhnr/UfioY5LCzsA/MWAWGU0NPTQ2pq6hWhKir0evRfe/KCf16m62RmZk66HR8bGxO03/z8/Ekb/JGRETweD319fYK2a7FYxi94fn/QJNTtdlNZWYlOpyMvL4+Ojg7GxsZQKBQiJ7C7u5vKyko0Gg0LFy4UUVG9vb0iBmnr1q3jj1ehEM+9x+OhsrISvV5PVlYWGRkZ9Pb2kpycTEREBHV1dWRnZ3P69GkqKyu56aabgPELiMViYd0ktv5KpXLSyb3cpMtGX8PDw6SlpdHf3099fb0wF2tpaQlqwH0+Hzt27MDn82E2myeNlTofOjs7BV2rrq5ONGQyWltbOXjwIEajkXXr1pGfnz/hglhVVYXdbqeqqory8vKg96HRaCQ8PFywCaKjo+nu7ub06dNERkZit9vx+/0sXLiQFStWoFKpiImJwWq1EhMTQ0tLi4gSkeFwOILcrgNjs+B94xuPx0NXVxcGg4H29nahEQ7EW2+9xeDgIHPnzqW8vFz8vgw5MiQQcvSZrBeXDzlhYWGTHnzb29s5fPgwKSkp3HbbbRP01B6Ph6NHjwKILOgLoTTpdDqSk5MZHh4mLi6O+Ph4hoaGrnlBlTfL0dHRwu3+YuF2u/nEJz5BT08Pu3fvnpK775XCb37zm/N+PzQ0lOeee47nnnvuKt2jaXxYodVqL+jzIdf6oaEhIiMjMRgMV2QgNpl78bngcrloa2sjMTFx0mGWx+Ph1KlTuFwuFi1aNOm10Wq1Ctpud3c3eXl5SJIkaNCBtUSSJOrq6gT1evbs2bS0tKBQKLjpppvo6+vD5/Oxd+9eAG6++WbB6KqurmbRokVkZ2eLnGC5SZdRV1dHX18fmZmZwsgrPT1d1GOj0Yjb7Wbz5s2UlpYKxlF/fz/Lly+ftPZO5j0jN6BKpZLk5GTa29vR6/VoNBoOHjyIwWAgOTmZjo4OEhMTg+7joUOH6OnpISwsjDvuuOOCm0V4X3KVkZEhohADJU1Wq1X4i9x2223ce++9E5JFGhsbMZlMmEwmCgsLg84ier1ebMw7OzuJiorCbDbT0tJCaGgoKpWK0dFRioqKWLt2LaOjo8yYMQOz2SwkRLt37wYQUY8KhSKIiSW/VwKHCLJXi+ftvSgMkTSHheHxeMjPzw967hzP/wLnT36KqriYyL/9BcnnC3K6lnw+XL/6NUgS0hn/FF9DA4oz70HJ60WVlYkiIgLJ6UQVMGiQ4WvvwPqxj6PQ6Qh/8U+E3HM3yrNkY/Yf/ie+k5W4jxyh5Wc/oeTLXzqn7FKGRqMhMTGRqP3vkFVXh+tjH2XQ46Gurg632y1kWvLw5mrB7/dTXV2N3W6/pGb5hRde4Ic//CHbt2+/5tGXgfhnr/Ufiob5QiBrmHJzc+nu7ubw4cOEh4cTHx9PfHz8NaEu+v1+du7cKaZhgTE7MD6drKqqIi0tjaysrHMW/JycHAYHBzEajWITFxkZycaNG/F6vUF61KamJkGljYqKEtEIDQ0NLFu2jIiICGFqoVAoiIyMDCoAJ0+eJD09neLiYk6cOEFiYiIlJSW0tbWh0WiEnrqurk7kGMtOpsuWLUOlUlFTUwOMb2rlpu1C8ir7+vo4cOCA0AfB+Os6e/ZsZs+ejVKp5NVXX2V0dJTBwUE8Ho/IeA482MhmMGdfrFpbWzGbzeTn508wcZEkiZaWFjo6OiguLsZoNE6Y4sP7NGiZ0iYfeiRJYmRkhIiICPLy8oRbaCCOHTtGQ0ODiOiQ3a71ej1Op5O2tjaxmd27dy95eXnigi83ofL9VigU6PV67HY78fHxeDweqqqq0Gq1mEwmVCoVpaWlQnMcHh7OwYMHaW1tDdL+xcfHi0OYJElBNMHA96PL5RI5oLJuXaawZ2Zm4nK5eOONN3C5XKxZs4a7774bjUYzaWPa1taG1+ulvb2dJUuWBL1/5YgQ2f1Vr9dflP6ntbVVvP9uueUWioqKBFNgcHDwqhdUmRZpNBqn3Cx7vV4+/elP09LSwttvvz0hSm0a0/hnglzrZ8yYQXt7OydPnkSlUolaH6gVvpp499136ezsJCQkhHvuuSfoew6Hg5MnTxISEjJpnq+M+Ph4ZsyYgdvtFs2fQqHgtttuY3R0NOizbzabhblWaGgovb29uFwuqqurBXU60ChSrVYTFhaGzWYjMjJSyGby8/Pp7+9Ho9FQXFxMamqqMNJsb2+npqaGyMhIXC4X9fX1WK1W8vLyyM3N5a9//SswHmso1/iz844ng9PpZNeuXfj9fkpLS8XrZTQahXdKRUUFra2twLjEye12C7Mtubaf/a+M4eFhWlpayMnJmXS4ODw8TGVlJTk5OaSlpU3KQJMXFfJ/n22SqVQqycrKoqenh9jY2KDFRUdHBwcPHhR1DN7PpPX5fAwPD7Nnzx68Xi/vvPMORUVFgmUmDxV8Pp9giRmNRgYHB0lOThZUd4vFgtPpFEuHgoICXC4XiYmJeF59DduXvwJA/Wf/FWtCAjqdLsgwynsmE9hXXY3k94tmWfJ68R4/gSp3FiGf/Qye119Hs2o1/v4+dGc0x2Of/wKe7dvRf/MZDAf2I3m9KCdxnfceOoTU14cE+Cor0d5yi/ief3QUhUqFZvVqvJVVmOfNFWeWC4GvsxP7N54Gxt//uV/9N2bNmsXY2BiDg4N0dXVx+vRpDAaDqPVX0u9DbpZtNhslJSVTOldIksRvfvMbvv3tb/PGG2/8w1CZ/1HwoWiYP6j4BWqY4uPjSUhIwOPxMDg4yMDAAK2treh0OvG98PDwq1JQFQqFMMk6+8PT1dUl8vs+KJ7CYDBw6623Tvj6ZBcWOYNXq9USHR1NZmYmfX19xMbGsmPHDqH9bG1tRZIkNBqNcNXevXs3JpOJjo4OkpKSsNlswnxl5syZ+Hw+Dh8+DIzTq0ZHR3E6nUIz3t3dTX5+Pvn5+TgcDpEJPDo6ekGT+ra2NpxOp6CQAUHZxxqNhuTkZEZHR0lKSsJgMNDY2Eh+fj719fU0NjYyZ84c1q9fj9lsDqJ92Ww2Dh48KP5f3qTD+5P6wcFBFixYcN4LdkJCAj09PcyYMSNoQ1BZWUl1dTXh4eGUlZUF0bpkNDc34/f7xSHG5/MJQy2/3y+28w6Hg6ysLBwOh9iOytEcctHOyspi0aJFYjBw+vRpEQ0iw+FwBJmgBVLyZY2cVqvFbrfT1NREZGSkOFwEbqwlSWL79u1YrVZmzZrFLQFFT0Z/f784MPX19U36+Pv6+vD7/aKwp6SkBB0ca2trOXHiBFFRUcTGxhIdHX3RmYVRUVEolUpUKpUYLimVSqKjo4mOjr6qBVVulmWjmqk2y5/5zGeoqanh7bffnnRDM41p/LMg0NwrIiJCDMRMJhP9/f0iY15unmVzyasBucafXestFgsVFRXExcWRl5d33vujVqsnNcPSarUTPvthYWEi9z42NhadTieawH379qFQKFi8eDFxcXEMDQ1ht9tF5GJTUxPV1dXAuNmo7IPR0dEhaoasp1ar1URFRTEyMiISS+St6uLFi+no6KCwsBC1Wk17eztZgdrXc2BgYEAYX3V0dAhassViEeezhIQETp8+jV6vJy8vTzCZzGYz7733HklJSSxZsoSsrKyg1BCAd955h7GxMfr7+9mwYUPQ9/r6+qipqSE/P/+8pnKyDlPOypbR39/PW2+9hVKpZP369ZNm3csRmfJyAhB+Km63m9jYWFJSUoS/h0qloq6uDo/HIwa8qampeL1ewsPDWbVqFT6fD61Wi9lsFgwsGXa7PdijRK41CgVKlUosRySPB9ef/owiIhyFRoMyMwPdF7+IIuA9af+PH+L+/R9QzphB5O63JrhdS5KE5623QJJwv7WLkI8+wNmVzdfSgq+mFvXKm9Hs2w96PZqAeC9vZRXW+x8ArZbhn/83Pb94jpLFiy+q/ipjYlAkJSH19aE+E7OpUCiIiIggIiKCrKwsXC6XkGk1NzcTGhoqar0c13o5IEkSNTU1jI2NUVpaOuVm+Y9//CPf+MY3ePXVVyf1dJnGtcWHomE+F+SL7GQaJrm5Sk5Oxuv1Mjw8TH9/P0ePHhX5hfHx8VeMygXjH95169ZhMpmCNqZNTU10dXUxf/78C86Wu1DEx8dzzz33iOgfOYPwwIED4sIREREhNEF9fX1iuhoREYHJZCIsLIyUlBSampqIiopicHBQxEoVFBRw+vRpwsPDhftnTk4Ohw4dAhDRRqmpqUK7HEhTOhuSJNHf349OpyM7O5uenh4MBgPFxcWEhoYSHx9PS0sLx44dIykpSTRYo6OjLF26VBgh/O1vf8Pj8VBdXc26deuCpr0wfuCQ84cDN5per5fdu3djt9u56aabPnC6eerUKex2O52dnSxYsEB8XZ6qOxyOoFgzr9dLV1cXsbGxpKam0t/fT3FxMRaLBZ1OR3R0NLt376avr08MKeTJtdxIt7a2ikGFfDv9/f34/X5BvwqktUVFReFyuUhLS8Nut3PkyBG0Wi0DAwOo1WqWL19OREQEISEhaDQaDh06RGdnZ5AO6uwLvmxGFxh3BuMDjb6+PmbMmEFeXh5Op3NSw5H+/n527doFwMqVK8/rhi5/XubNm3fR1OnY2FjuuusulErlpHSoq1VQ3W43x48fJyIigoKCgildY3w+H48//jjHjh1j7969/zDRDNOYxrlwvs/JuZywlUqlMF6aPXu2kEHV1tbi8/mEPCMmJuaKSjEWLlxIenp6UE0fGBigurpaJDBczrOGVqulvLxcNFIAM2fOpLm5WTTDqampwl+ko6ODzMzMIEMt+SwUFhaG1+slNDSUd955R2wsZfNImSo8c+ZMKisr6evro6uri5SUFBEDGRkZ+YFaS7PZLLagUVFReL1eCgsLRb3W6XS89NJLaDQaZs+ejSRJOBwOoqOjRQzTO++8E0SDniz5ICoqirGxsQnb5WPHjtHa2sq8efPO2ywDYosL43VPfs7kwbDf7xfGZzD+/uzp6QliSGVkZBAVFYXVaiU3N1cMhQOTLeTzkjzMffXVV4VXCSAkcwaDAUmSCA0NFZvnpKQkRkZGmDlzJpLfj/2738ff3k7NhnVYP/oAsxaUsvpMzrder8f1l7/i+P4Pgh6nFGCsCSANjtdhv8k0bvIlb55tNtxvvIm6eD76734H9/Yd6B59ZMLzJjmdWO68G2w2Qv7lU4S/MFHD6qurA48HPB4sp6opefDjFz2sVuj1GN7agTQ2hvIcrKuQkBBxBpU3+4ODg1RWVgLj54W4uDhiYmKm5GIN7zfLVqv1kjbLf/3rX/nKV77C1q1bhZxxGtcXPrQNs1w85QP+2Vl9gVCr1SQkJJCQkCA+NAMDA1RUVFxxKpdOpxMGDz6fj5qaGiwWCwsXLpxwgRgbGxMxQcXFxVO+L5N9YNPT0+ns7MRoNJKamkp2djZerxev18tLL71EXl4eGRkZdHR0iGiq++67D4AXX3xR5CfLG+W6ujoyMjK48cYbhbOy3+9n5syZREREMDAwQENDAz6fD71ez5w5c6ipqcFut7N06VLx2Jubm3n33XdRKpXk5eVht9ux2+14vV7RkMpu0X19fWLK7r/FKgMAAKBOSURBVHK5xKTbaDSSl5dHQ0PDBGrVwYMH6ezsZP78+YJeJT8/sgO5fKDo7u4+pzbU5XKh0WhISUnBYrEI2tqpU6dEAxYSEkJeXl7QoezIkSO0trYSEhIihhROpzMon1G+fVl7LA+C5Ey7tLQ0Ojs7sVqtZGRk0NXVRUhICHv27MFsNuPz+URjl5GREUT9r66uDqLlwfikO/CwIL8/dTodDodD0JTNZrMwOlGpVBgMhqBcSoCdO3ficDjo6emZdDMiI/C9HPjfkiTR2NiIJEkUFhYyOjpKZGTklJplGReTmXolCqrcLIeHh0+5Wfb7/Xzxi1/knXfe4e23377mcVjTmMa1wvkG42dDzqmNjo4mNzeX0dFRUYvkzV58fDyxsbFTPiCfCyqVKogt1tHRQVNTEwUFBSQkBKdp+P1+jh49itPpPKee+UJv8+zrZGJiInq9XkTulZaW0tXVxYwZM9iyZYu4jqvVatxuNzabTfhVvP322/T09NDR0UF+fr4YKNbU1LBw4UJiYmKor68XdSInJ4eBgQFOnDiB2+1GpVKRn5/P6OioaEzl58RqtfL6668jSRJz587FZDIB42w7uR7W1dUJN2i5Hvr9fnw+H6Ojo4SEhJCdnU1/fz/JyclBQ9GmpiaOHTtGZmamaGrlWi9Lrurr60V0WSD7KhCBRl91dXVERkai0+moq6vDbrcTGxtLaGgo0dHRQa9rW1ubYLHJ56HR0dEgtpZc6+VGHBBDoKGhIYxGI3PmzKGxsZGcnBz6+vpQKBQcPXoUm82G1WolIiICr9eLTqdj5cqV4rPgranB/cc/jt++5Kd/5c2o9XrSA95bivgzLAWNBs6kfqiL5yPZbDh+/BNQq/E2N6FITibsP/8jSNNs/8F/4P7b31FERmI4cpiQuyZu1sdvRBG04Q6E58BBvCdOoLn7LsbuvosxSSL34x+bMrNLERKC4gLrfeBZX5IkIe1rbm7m1KlTREdHi2H5hX4eJUmitraW0dHRIB3/xWLLli088cQT/P3vfxcGWtO4/vChaJjPLo6yudBUYiQCPzR+v5+RkREGBgaoqqpCoVCIafTlpnK53W5OntGMLFy4cNKmtrGxkZ6eHnp6esjOzp6QlXspCA8PFw1BZ2enyEV77bXXcLlc1NXVCdq02+0WTptyvmJvby9xcXHo9XqOHTuGwWBApVKxb98+Fi9ezIYNG7Db7SQkJKBQKEQ8xf79+4FxDZC8HT19+jQlJSUoFApRnALNy2Tta319PdHR0eTk5GA2m0lOTmbOnDl0dHSQkpLC4cOHaW1tJTExkVWrVk2Ybvt8PqGBamtrEwcui8VCTEwMJ06cQKvVotPpcLvdQRs8j8fD/v378Xg8zJgxg4qKCqKjo7n11luZO3cuarWaU6dOCRq0XCC7u7spOkMPAoIGOrK22mg0YrPZaG1tJSEhgbi4OMbGxli6dKmYJIeGhrJt2zahFwucOMp/v6urSxi6yI/NZDJhs9nQarXituTIiZiYGJGDbbFY2Lt3L1qtluHhYRQKBTfeeCMxMTHifV9RURHUbMt6qUAEurFOhtraWqELX716NZIkBT3P3d3dwnRGjjWZM2fOBX32PB4Pra2txMXFXRYTrMtRUOVmOSwsjMLCwildQ/x+P1/96lfZuXMne/funVRLP41p/DMgsNbD+QfjZ0OhUGA0GjEajcycOVNQdFtaWqipqSEmJob4+Hji4uKmZM5zLvj9fhoaGujv76ekpGRSA7CBgQEaGxuBcSOsySQsU4WcpuByuTh16hQ33HADeXl5nDhxQgykBwcHRe01m83ExcWhUqlISkoSmtysrCwh3UpNTeXdd98lPz+fVatWMTg4SGJiolhGuN1uXnrpJUGrlhM6Tpw4QUJCgvDNCKyH8tfCw8NFDNWMGTNoaGhAo9Ewb948YmJiiIiIYHBwkIMHD6LRaCgvL+fuu++e8LhbWlrwer00NzcHSbokSeLUqVOYTCYSEhLo6+ubwHqrqKigs7OT2bNnc+zYMZRKJevWreMjH/kIKpWK4eFhjh07BoxL5JxOp4j1lAcvgcZbkZGRmM1moqOj8fl8NDY2isQRvV7P7NmzMRqN4nxx7Ngx6uvriYiIYOPGjRQWFgLv13q3282mTZuA91lmTqeTkZERoiIjkQYG8Kak4J2Zg7qvn+iyjSTo9RQWFiK53Yw98hj+tjakM5+j0EcfIfSRz427XSuVOP/0Z1x/+GPQcyKNmIL+X6E90wxqNBMaYQDPu+/i+K8fo739diJf3oKvthZNgHxLso4x9umHwedjuKGB9vs+QklJyTnzlIPuiyTh2b4dQkLRrrz5A3/+g3D2tcFmszE4OEhfX594HeRafy4JpyRJnD59GrPZTElJyZSb5W3btvHZz36WF198cVJj3GlcP/hQNMyBOBctaypQKpXExsYSGxt7RalcNpuNiooKIiMjKSgoOOffSklJob6+XsQsXU4EHtwD/7ugoIDjx4+TlJQkcp8jIiKorq6mvb2d+fPnC7pvQ0MD8fHxzJ49m/T0dF599VXx9YULF06IBpIprZIksWDBAo4fP47D4WBoaIiXX35ZRCJptVqRwZiSkoJWq6W6uprTp08L50xZZ1taWirMtOQprTyJPhtylIasqXW73TgcDlJSUnjllVeEc6RMM5YPZTBOIZb1R3IhHBkZwev1imGHPNAICQkRh4vc3FzGxsY4duwYRqORhQsXkpycTHx8vGhidTodu3fvpre3V7hfwnghlPVfMhUN3o8HOxuxsbHiOZ8zZw7d3d3CWXRoaEhQw30+H/Hx8UEGEk1NTUFTbvn24+Li8Pv9QvPU3d2N0WjE5/OJ10aOckhJSWHt2rXCjORs+P1+ERdSXV3NypUrJ/xMWFiYoIKHhYVdcLMM44exxsZG1Gq1kCFcLkyloHo8Hk6cOIH+zEFlqs3y008/zSuvvMLevXsvSA84jWn8o+Bs9klgk3UpA+xAKUZOTg5jY2MMDAzQ0dFBbW0t0dHRYlh2KSaAXq+XU6dO4XA4WLhw4TmbgaioKCIjI3E6nR9IDZ4K5Ocq8JqYnZ1NR0eHkKstWLBARAP+9a9/JTExUTC0ZIPExMRE5s+fz/bt27HZbJw8eZLMzMwJDadarSY8PByr1crMmTMZHR2ls7MTpVLJa6+9hlKppKCgQNCTY2NjueOOO/B4PFitVjH4nTVrlqhLQ0NDYgssa9M9Hg9ut3vS5iQzMxOLxUJmZiZpaWl0dXWRnZ3N9u3bGR4eJjU1Vch+5JoL7zP/AMGK8/l8mEymoLQOuVZnZmZSX19PamoqCoWCI0eO4Ha7WbBgAStWrCA0NJSYmBhsNhvh4eHU1dUJczYZw8PDQfFXcq2XpU9nQ46xlBMs5CH3qVOnyPqvnxBRV0fvmtWceOB+dDodd5WVIdt7eWtq8e7bF/T3/O3t43WXcZMvZWoKqNWg16NMS0MZFoZ62VL8JhO2r30dhU6P/lvfRL10MeqCwqDNswznc7/Ad7ISx6lqQj7+MVRnD3pDtCji45F6e7EaDJSWll7wJtez8y1sn/8CAIoX/4xmweV1jg4LCyMsLIyMjAzcbjdDQ0MMDg4Ks1u51sseKXKzPDIyclGP42y88cYbPPTQQ/zud78TkoNpXL/4UDXMgeZelztz8UKoXAkJCRetdRgZGaGyspLU1FRycnLOe5/j4+MFDfpyw2AwcNttt03YpLrdbpxOp2j2iouLAcQFvru7W2x+5RikGTNmEB4eTnJyMiMjI0FRDB6Ph127duF0Olm+fLmgfTmdTjZu3AiM066OHTuGzWbDZrPhdruFK+fs2bNRqVSiIKrVapKSkujq6iIhIQGHw0F9fT3JycksW7aMlpaWc0ZJuFwusWHu7u5m8eLFjI2NcfToUVEwZeMRGC+cTqcTh8MhNg8ej4fi4mJaWlqEmZxMK5PzKHU6HSUlJYJ6dfz4cbq6uujq6iIzM3PSpkc+SIWFheFyucTfGxkZob6+nsTERHQ6HX6/n3nz5k34fYfDwfHjx8nOzhYO4vLrMDAwwM6dO4H3hwCyS7RWqxV0Lp1Oh9FoFIYpaWlpmEwmdu7ciUqlEsV74cKF4rHC+NZY1v3Kzp+BkLcMYWFhZGVlCe1cII4cOSI2zzNmzBBu2BdzKJY/h2q1+oqb+H1QQY2JiWFkZISwsDCKioqmdLiXJInvfOc7/PWvf+Xtt98+J2VwGtP4R8flHIxPBjnDPisrS+Tl9vT0UFdXh9FoFM3zxRyEnU4nJ0+eRK1Ws2DBgvNurUNCQkQ9vNxQKBTceuutDA0NTRhkytvJhoYGsb2UWWB9fX1BtdzlcolEiVmzZlFdXT3BvPO9996jra2NBQsWEBERgdVqxWQysXz5cmDca0QerJ86dUoMt2tra0VqhyxVAoiJiUGj0aBUKoWTt1arFdn151smNDY2ilzmkpISoqKiqKysFLc5PDwshi+BTbF85uvs7KSoqIjBwUGUSiUpKSns2bOH/v5+8vLy8Hg8KJVKMjMzxQa4p6cniCkQmIwh30+51ssRkUNDQ8yYMUMwAGT2n1arFcy7QPj9fvE83H777YSEhIjaIEkS5i98CYDQ5hZYshiv10tPTw8xoaEoGxshKhplTjb4/IQ8cD/+jg5CH/70uNb4rrvxt3eMN8teLyGfeBD95x9//z3wl7/i3fM2AN7b16NdtWrC8+7v6weNBu0d5XirqtBuvD3oMbi3vYr9O99Bs3Ej3c/+J46WVgrKNl7UZ0she9IoFCj0H7yRvhRotVrhfyS/R2RZgixz8Hg82O12kUE+FezatYtPfvKT/OpXv5rgqj+N6xMfmoZZ1rHA+TVMlwPnonLJZhoXSuXq6enh9OnT5OXlXRcaxMniaOSLukqlCpqGL1myhLa2NgoKCnC73ZhMJjIzM2loaKCiooIFCxZMujEcHh4W0UQdHR24zxhKyC7PMD4YkLVXK1as4L333sPr9dLf309NTQ1hYWFigq1Wq8nOziY7OxuVSsX+/fvp7OykoaGB++67b9JmUoZGoyE8PJyxsTGio6Pp7Ozk5MmT5OTkiGzoOXPmkJubi0KhICYmhpdffhm3283ixYtZu3at+FuyVqmtrU3oo+RmW54OyzmJKSkpNDQ0YDAYgkzEhoeHOXjwINHR0SKeKjc3V0Q9KBQKtm/fztDQEO3t7YIyJ+t6ZVitVkF1k+87jE/ke3t7CQ8PJywsjMjISIqLi+np6UGpVE6qZ05OTg6isvf39+PxeIIm8PL9cDqdKBQKMjMz6e3tJTU1ddKtbnV1NZWVlRgMBjZs2DAhTs3v94tDxsmTJ8nNzT1nBvn5MH/+fJKSkjAajVfNCRcmFlR5G+Pz+XC73VRXVxMXF0dsbOwFUz0lSeI//uM/+L//+z/27NkTtH2YxjT+mXClm+WzIeflZmRk4HQ6GRgYEMPyyMhIka5xPuqo1WqloqJCGI9dzevRZNDr9RMGmaGhoWJLGlhPZP2wfE2TpVdKpZLt27eTkpLCzTffLAw2ZQT6TzQ1NQkmlMViEa+hTEMeGxujuLiYrq4uYT65bds2lEolubm5qNVq/H4/RqORu+++G4VCQVNTk9gsR0VFBUmdJoM8tIyOjmZsbIwDBw4QHh7OzJkzaWlpYfbs2SQlJWEymUhPT2ffvn309PSQlpbG8uXLhWeK/Ly5XC56enqA8WECjNcut9uNTqfD4/EQHR1N2Jmc47MXEfv27RMu1zAejXXTTTchSRIKhYKqqirq6uqCHsPw8HCQaabX6+XkyZMifkuuJ/6BAVwvbcK3YAGNDz9EbFU1SU98ngWqcWlYZ2cn/q8/RVhnF/6oKJQmE4q4WEI/+Qnxt31Nzfgbxuswcr0/M1CRHA4k8yjqZctQJCeh0OlRz3s/WUTcv+PHsX7046BWE/n6q0RVVkz4GddLm5DMo7j+/GdGV95MyR3lF01f1tx4AxEv/R20WtT5V682qlQqwULNy8vDYrGI7HOAmpoasX2+EGq5jH379vHAAw/w3HPPcf/991+puz+Ny4wPRcP805/+lL6+PsrLy6e8vZkqpkLlCsz0lXU41yuSk5MpLy9HrVYHTcrS09NJT0+nu7uburo6FixYICa2ELyZBUQmoGySZLPZSEtLIyYmBpPJRGpqKps2bRJRF/KE12azicb0xIkT9Pb2CiMrGKcjt7S0kJ6eLuItOjs7z+tu/t5779HU1ERJSYmI0XA4HOzcuRO/309HR0eQ0ZfcMMrbbpiYJWkymbDb7UJTpdFoWLZsGR0dHSQnJ2M2m3nzzTdRKBSsX7+e++67b8L9a25uxmKxBFGhzWZz0M8ZjUaGhoaIjY3F6/UKjZiMzs5O9u/fj1arZdGiReJ3JUli165dgjIub/WjoqKEvjcpKUk0zLLm2mKx0NnZiUqlEpEWYWFhJCQkkJiYiFKpJCkpiaGhIXbs2IFSqWTDhg3nZULI7w2r1RrkGO73++nt7SUqKorCwkIaGhpISUmZsjGWTNe/lpAkiY6ODgwGA3PmzBHU7ba2NmpqaoiKivrAgipJEj/+8Y95/vnn2b179wceDKcxjX9U7N+/n9/+9reUlZWxYsWKKesCp4rQ0FDS0tJIS0vD7XaL5rmpqYnw8HDRPAeaFA0NDVFVVUVGRgaZmZnXJAP6QhASEkJ5eTlutztoS2s0Glm+fDkWi4WjR4+Snp5Obm4ub775JoAw55LhcrkYHh4mISGBvLw8WlpaSE1NJTExkdbWVjIyMnjzzTcxmUwsWbJEMKj6+vqEd0pfXx8dHR3A+BBaHsrW1dUxZ84cwsPDRY1XqVTnNIVqb2/n0KFDJCcnc+ONN5Kfn49KpWLHjh3YbDZRi7xeL+3t7eTn54t6KNf4syVdTqeT/v5+EhMTSUxMxGKxUFxcjMlkQqfTERkZyWuvvYbFYmHZsmXCMC3wde/v7xdD8bMH7IGZ0zD+nktISMBsNgc1yw6Hg1dffRWPx8PNN98cNHy1f/vf8ex8C79OR8O/fZmGG5exJjaG3AAmmMk5vrn3KUAJ2KKiGG5uJlaSCK2sQhEXi3JmDorISEIfegh/by8hd92J5HAwuuZWpL4+9D/6IcZ9eyd97gF8rW3g84HPh7+7J4iG7a2oAG0I2oc/jb2vD/PiRZQuWDBlyYN63vkd2K8G+vr6cLvdIn1GZto1NDQQFhYman1kZOQ5rwMHDhzg3nvv5Sc/+QkPPvjgdXu9mMZEfCga5ry8PA4dOsSaNWtISEigrKyM8vLyi6ZwXg58EJUrLi4Os9mMxWL5wEzf6wWT3cfApj8w/mr58uUMDQ0FbcBsNhuvvfYafr+fhQsXMjQ0hCRJNDQ0sGTJEtLS0mhtbRVbSzlOAcabKJvNhlqtJi0tjaamJvR6PTfffDMVFRUolUp6eno4evQoer2euXPnsmbNGmJiYs55oWlpaRFxTLm5uVgsFmprawkNDcVutxMeHi7cQZOTk4XRmmyuZTabg6hnNpuNN954QxhWyQVWpVKJ5qalpUU0+WazOehAYrVaRVRUb28vMTExIg6isLCQnp4e9u/fj9FoFNv59PT0CZRcs9lMRUUFkiThcrmwWCxBQw69Xo/FYiE6OprBwUFRfGV6uF6vR61WEx8fz5IlSzCbzbjdbrq6ukSERSACqeSjo6NiayA7dQbC7/dTV1eHQqFg/vz5hIWFkZiYGLSBrqio4PTp04SEhJCYmEhhYSGzZ8++oILh9XqxWCxXxMl+qvB6vZw4cQK1Ws2cOXNE9nNkZCTZ2dk4HI4PLKiSJPE///M//PjHP2bnzp3nZUxMYxr/6JAHS4888ghOp5P169dTXl7OzTffPGXq41Sh1WqFg77H42FwcJCBgQFaW1vR6XTCHLC9vZ2CgoIrokW+3AgJCZl0CDE8PExlZWVQ/NXSpUtpbm4OomnDOJVU3tLabDZcLhc1NTXMnj2bqKgoYUYF442jTIOWt7Nut5uYmBgiIyNxuVwsXbqU9vZ2RkdH0Wg0vPbaaygUCgoLC7nlllswGo3nfO3lvOPOzk58Ph8KhYJjx44RFhYmzC+Tk5Npbm4mPT0dq9Uq9MfLly8XOciBeOuttxgdHSU2NlZoni0Wi6BbOxwOMfQeHBwM+n2XyyXMT+Pj4/F6vcyZM0foqR0OB9u3bxdeJjDuRXLjjTcG3Qe32817770nBvgDAwNBw2Hlmf9WJiQQGhqKPiyMqKgofG1tOH/9G5TZ2eMGeelpRP/m13jNZpwGAzaLBd1jj+Pv7cOv06F0OFDExKBd/T7V2t/Xj3Rmo+47XQflE59391u78FVVof3YRwn98pdQhIWhXvK+R4pn/37GHnoYFAp6fvgDrN/5NsXFxRfULEuShK++HtWMGSim6J59uSGzKfr7+yktLRWvnTxc83g8ImHjxIkTKJVKUeujo6PFOejIkSPcc889/OAHP+DTn/70dXOWmcaF4UPRMK9bt45169Zhs9l488032bx5Mxs2bCAqKoqNGzdSXl7OwoULr2jG4mQ4m8rV29tLc3MzPp+PyMhIhoaGJlCdPwyQm5+hoaEJTf+MGTOYMWPGhJ+XtbIyBclqtRIVFUVPTw9er5fU1FSio6OFaUbgBnXr1q2o1WqKiopEQXU4HCK4/fDhw0iSJLZ3LS0thIWFCTdzg8EgdDsJCQksWLCA5uZmioqKOHr0KM3NzSKyCiA6OlrQhOX8O7/fj91uZ/ny5RMMTQLdL2U9d1hYWFARl90vIyIiguj3sp5Y3jwHGjvIDe2pU6fwer2iOANC1yXHWTU3N9PQ0EBBQQG9vb3odDqhPYb3dWtywxw4SHrnnXeEm6fX62VwcDAo7iwuLo6WlhYkSRI/Y7FYqK+vB8ap5jk5OaIpnOxg2NHRIQy+IiIihBY+EPLAxO12Ex0dfcHNMowfYoaHh8nNzQ3Kv75W8Hq9IpZu7ty5k157dDrdpAX1+PHjPPnkk8yaNYvw8HC2bdvG9u3br+rj+sEPfsCWLVuoq6tDp9OxdOlSfvjDHwYNipxOJ1/+8pf561//isvlYu3atTz//PMTInKmMY3LhdmzZ/P888/zP//zPxw8eJDNmzfzxS9+kdHRUW677TbKyspYvXq1uA5fLchGWcnJyeIa2tLSgt1uJyQkhLGxMSGd+bAdgmXpWH5+ftC13Wg0BkUiyZCbOLnxHRoaIioqSvhkZGRkkJ2dTU9PD0lJSeTn5zM0NERiYqKQPC1YsEA0nT09PcyfP073bWtro6GhARj3f5H1xLL5qtx8dHV1idg+l8tFcnIyvb29HD58WHjRDAwMEBkZyeLFiwUba8+ePfT09NDU1MR99903aRKJfJZRKpVoNBp8Pl9QCoOsRXa5XEGaZY/Hw7Zt23C5XCxcuJA1a9aI78lnis7OTrFxls8V8vPp9XqF/8fRo0eJj4+noKCAsbGxCXGZuq89iXb9elQ52dwdcD4b+88f4XlrFyiV4PcjAVithM6dSxKQBIyGh+MH/AYDSoeDoZkz6aquJs7hIPzQYULLNqJ/9kf4amsJ/cy/Tnx+RkawPfoYSBKSzY7+macn/IxkO2NUKkl4x8YoKSm5YHmS8+fP4fzv/0GZkU7kju0orrG8QZYc9PX1UVpaOum1R6PRCEaC3+8Xn4W6ujp+8YtfMDIywpw5c/jDH/7At7/9bR599NGrdp2YrvWXDx+KhllGWFgYd999N3fffbeg2G7evJl77rkHnU7H7bffTnl5OUuXLr3sGYsfBL/fT09PjzCQkLOeZSqXPHGcat7c1YLP56Oqqgqn08nChQsvaKofERFBcnIyfX19aLVa1q9fL2jQO3bsAMb1pvLUuaWlReim5KZMpmTBePOn0WgYGBhAp9MJE7b4+Hjmz58vmsu6ujoOHz4stFlWqxWj0ciGDRvIysqiubmZpqYmfD4fzc3NwsRqZGQk6GJlMBgwmUwTookaGxvp7e0lOztbGEvNnTuX4uJiEX0lo76+XkR2eDweMcUPLI4OhyOoQPf394t849DQUFJTU5kxYwZjY2Pk5OTQ3t7OO++8Q2hoqLjvfr9fDBLOhlarDWqiZcTGxtLf309KSgqjo6Nic93S0kJLSwt6vV5sz1euXInb7cZqtdLd3U11dTUAvb29zJ0795yb/YgzmY4KhSJowCJvYQFmzpzJyMiIOERdTMGQt/pnO3tfC/h8PsF+uNC86MCC6vP5eOaZZ/jxj3/M0aNHCQkJ4T//8z/ZuHEj69evDzJYu1LYt28fjz76KAsWLMDr9fLUU0+xZs0aamtrxTXqi1/8Iq+//jovvfQSBoOBxx57jDvvvFNkjU5jGlcKKpWK5cuXs3z5cn7yk5/w3nvvsWnTJp5++mkefvhh1qxZQ3l5ObfeeutVZ3EpFAoGBgYAWLRokdA9nzhxQkTTJSQkYDQar+vmWZIk2traaGtruyjp2KxZs6isrESr1VJaWkpubi46nY4tW7aIwWBHRwcej4e6ujpuvfVWDAYDFotFNIc2m00kOISEhDA6OorH4yE5OZnU1FQkSWLRokVoNBpMJhPt7e289dZbKBQK4uPjRT7xHXfcwerVqxkaGuKdd97B4/HQ398vbkc+c8ivgzzEP7vWDw4OUltbK6RfCoWCWbNmkZKSgiRJQZvRzs5OwQQzmUxCD+71esWg+2xJlyzF0uv1hIeHExISwsKFC+nv7yc9PZ2xsTFef/11wVLz+/3odDpWrFgx6WugUKkmpSiri4vxvLULVW4ukkaDKjMDVV4e3trTOH70I5Qz0vC3tqGIiyVm099Bp0Ph9zM4OIj06OO4e3qwvvYa3t/+H3G3rkU5CRtBERaGIiEBqa8PVU520Pecf/wT3mPH0H7+cfq/8ARejZr8++67qNg2f1vb+L89veDxQsjUXesvFZIk0dzcTE9Pzzmb5bOhVCrF0GbWrFmEhYXx/PPP88ILLyBJEps2bcLtdlNWVhbkQXOlMF3rLx8+VA1zIHQ6HWVlZZSVleF2u9m1axebN2/m4x//uNBZ3nHHHdx4442XNWNxMpjNZk6ePElycjIzZ85EoVBMoHLJ+Y86nU40z+fKd7tWcLvdYmsWaDDxQZAkid7eXlGAc3JyCA8PD3K/DA8PJyIiArvdTmJiInV1dahUKlJTU6mtrUWpVJKdnU1SUhIajYa+vj6OHDmCSqUSByMZGo2GpKQkYRzldDrFgGRsbIyamhqsVitOp5OsrCxaWlrIysoiKiqKvr4+CgsLRYbynDlzuPXWWwVVW4bH4+HIkSPAeHGXt6MjIyNBG3an04lKpSItLY3Ozk4SExPRaDQ0NjZit9uZPXs2CxYsQKVSTcgffvvtcfdJWU9stVonbKfl25BxoSyKxsZGjh49SlZWFrfccgsul2sC00E2W5P/pslkQqlUEhoaSmhoKAaDQbjE63Q6GhoacLlcwvQuJiaGI0eO0N/fz7Jly7jjjjtQKBRBtyMbtME47S8nJ0d8Ri4GK1eupKurSxikXSvIzbJCobjgZvlsKJVKzGYztbW17Nq1i/j4eLZt28YLL7zAo48+ytDQ0BXfoG3fvj3o/3/3u98RHx/P8ePHWb58OaOjo/zmN7/hxRdfFOZ+v/3tb5k9ezbvvvtuUETZNKZxJaFUKlm8eDGLFy/mP//zP6moqGDTpk1873vf47Of/Sy33HIL5eXlrFu37opveF0uFydPnkSpVLLgjB5TNgbz+/2MjIwwMDBAZWUlCoWCuLg4EhISRBzN9QJJkqirq2NwcJDS0tKLirHs6+vD7/fT3t7OsmXLiIyMFAZtMG7UOWPGDJFg0dXVxcjICHl5eSQmJmIymUSMpcPhEDRsSZJYvnw5N910U9DtyWZekiQJWZD8GGpqasRwPScnh9raWgwGAwsXLqS+vp6MjAx6e3s5ePAgcXFx3HjjjeTk5ExYXBw/fpyhoSH6+vpErR8YGAiio3u9XrxeLwkJCej1evH69vf309nZSW5uLjfffDMmkyloI+xyuUQzbDAYGBsbw2azYTQaxZCiq6tL3K5sgHahtcVbe5qxT34KRVwckX/9C9ryMhRRUUHRT85f/hLvgYPAeAMkDQ4hjY6iSkjAyDibwJqTg7enB+UZmVpdXZ14b8fFxaF++ZXxnOUHP47hzdfxDw8HaZb9IyM4/v07AAzbHVj/9dPMnz//opdXuq89iXLGDNRLFqO4hs0yjC8Vuru7KS0tndKyS6FQEBISws6dO/nmN7/JQw89xOuvv862bdv41re+xcsvvxxkLnslMF3rLx8+tA1zILRaraBtezwe9u3bx6ZNm/j0pz+Nx+Nhw4YNlJWVcfPNN192E5G+vj5qa2uZOXPmBKoyTKRyDQ0NMTAwwNGjR9FqtaJ5vtZULrvdzokTJ4iMjLzoDFmFQkFJSQltbW1BhkVGoxG9Xo/dbkehULBx40ZhknTs2DEA8vPzxRa2p6dH6GZlQxDZHEyGz+ejvb0do9FIWloaAwMDJCUlUVpaSmdnJ6GhoZw4cQKLxSIafp/Px8DAAPPnzxcFsL6+HrfbTUNDA3l5eUEHBpm+HB0dzcjICFlZWURERKBSqYJ0RH19fezevRuNRsOGDRuE2+Hw8LBotjUaDfn5+ROes8DHFB0dLShrsiZOqVTidDpRKpWkp6eTn5+P0+kMarrPh9bWVvx+Py0tLSxevDioiXW5XGi1WjIyMmhubiYnJwe73S6e+/r6ejFM2LhxI3a7XUzkbTYbAwMDdHZ2Ul1dLZr6pqYmESUC7zvdyk7RPp+PGTNmTKlZBoRT5bWEz+fj5MmTSJJEcXHxlJplSZL4+9//zpe//GU2b94sClRhYSFPPfUUJpPpqtNN4X1fAdmr4Pjx43g8HlYFxIjIEWKHDx+eLqLTuCZQKpUiwu/73/8+1dXVbNq0iZ/+9Kc88sgjrFy5krKyMiHZupw1dWxsjIqKCoxGIwUFBRNqpFKpDHLUNZvNDAwMUF1djd/vF+aggZrGawGfz8epU6dELM7FSsYKCwvxer2kpaWJ50A2h5QNvJYuXcrixYtxu91s2rQJGNf+ym7TLS0tLFu2jLCwMNEMw/v0ZBk9PT34/X6SkpJEDb7pppvo6+tDpVLR2tpKfX09CoUCl8slNtwRERHCYOzw4cM4nU46OztxOp0Tar1M+ZZjuAwGA8PDw0F0a5fLxauvvorT6eSmm27izjvvFN+TjbnMZjOrVq2akIgiN/owzpKU9dFKpZLBwUFhqqZUKgkPDxdN94UaWnr270cymZBMJnz1dahL388olux2UKnQrl6N561dqBeUooiNRZWZiXLmTLwnK7F9/euoS0sJe+7n+E/XosovID5Ei8vlEh4cTU1NFPzmN4Rarbj+9Cd0T3weVcCCQbLZIDISZVERvpoa7HMKp9QsAyjj4tB94YmL/r3LjebmZrq6uigpKZkyM7Suro4NGzbw2c9+lqeffhqFQsHDDz/Mww8/jM1mu+LLvMkwXeunjn+IhjkQGo2GVatWsWrVKp577jkOHDjApk2beOKJJ7Baraxbt47y8nJuueWWS9IWy9vU1tZWioqKiIuL+8DfUavVQbRMmbYtGwfJBfVqU7lGR0epqKgI2pBfLPLy8oIKDIxvRmXd8MDAAGlpaSgUCnHxkSOY5CIaGxvLsWPHCA0NJS8vD61WS0RERNDmt7q6mlOnTqFUKklMTBQZ0osXLyYjI4PKykpB7/b7/YSGhuLxeLBarRw/fpyQkBAyMjJIT0+ntbV1gjbo8OHDNDc3k5ubK+hcKpVqUhq0yWRCkiRhICY3OjqdTmiBAynYkiRRVVWF3W5n/vz5rFixQrwn3G43ISEhdHR0cODAgaDbcblcEyhkk0F2ItXpdISFhaHT6SZEgcgZ2PHx8axevTrIaVvGqVOncDqdVFdXk5WVFUTLDw8PJzQ0lJCQEGbPnk1FRQWDg4PYbDYOHz5MfHw8sbGxHD58mKGhIebNm0d8fPwF5ZBfz/D5fFRWVuL3+5k/f/6UD7xbt27lscce429/+9ukk+ULeZ0vN/x+P1/4whdYtmyZyBeV5RVna/wSEhLE53Ua07iWUCgUFBUVUVRUxLe+9S3q6+vZtGkT//u//8vnP/95li9fTnl5ORs2bCAuLu6Srj3Dw8NUVVUxY8YMss8YKp0PgbRMWVI0MDBAXV0dHo+H2NhYEhISiI2NvarNs9vt5uTJkygUig/Mij4XEhISJr12yR4csju0UqlErVYTEhKCy+XCYDCQlZVFX18fWVlZ1NXVYbFYmDt3LjfffDNOpzPIQGtgYIA9e/YA43IeWZYzNDREWloazc3NwnlakiR0Oh2jo6MoFAqOHz+OXq8nMTGR5ORkurq6iI+PDzrztba2cujQIWJjY4OkU7JcLBAOhyNI0hXocxIREcHIyMiEa3dHR4eI5ly7di2jo6Okp6cHJVns3LkTSZKCWGYyG++D4Kuvxz9qQWGIRJGQgLq4GFWAaaT31Cms938UhU5H5KvbMNacmvC+df3tb/ibmnE3NaN77FHU89+PjgoJCSElJYWEnl6kjEzMn/0s7l//hr4blnLqnXeEqZX+L3/F9d//g3r9euqf/DfUfj9zr4Gn0OVEa2srnZ2dlJaWTlny0djYyIYNG3jwwQf593//9wnP/bWQZ07X+kvDP1zDHAg553fFihX87Gc/491332XTpk08+eSTDA0Nceutt1JWVsbatWsv6s3r9/s5ffo0w8PDLFiw4KLoTIH3TW6QJ6Nyyd+70lSuwcFBTp06RU5OzoTcxktFWFgYCxYsYGRkJGjLqtPpRIHw+XysW7cOgNOnT4tcwvj4+Aku0YB4LmTae29vL8nJydjtdg4cOEBYWBh5eXmcOnWKjIwMSkpKGBkZQafTcejQIQYHB6mursbn8yFJEt3d3UGNfldXF4DQSAU6fNrtdvR6Pe3t7Xg8HrKysnA4HBMMuPr6+vB6vSiVyqAiOjw8zKlTp4DxIitfsADBfAicyMbHxzMyMkJmZiZ+v19M0s+le2lsbOS9994Lut9n/5x8ARwcHBSFGhBmI3q9noKCAmpra8+ZBXzo0CE6OjqIiopi/fr1wDiFfWhoiMHBQVpbW8Xhqb6+nvnz5wc5bp8Pbrebt956C7fbzS233BKUF3qt4Pf7xSCmuLh4yv4Ir732Gp/5zGf405/+xIYNGy7zvZw6Hn30UaqrqycMaqYxjQ8LFAoFeXl5PP3003zjG9+gubmZzZs388c//pEvfvGLLF26lLKyMjZu3EhSUtJFNc9ytOLs2bOnFGOnUCgwGo0YjUbR+Mn+JtXV1cTGxopB45XcONntdioqKoiIiKCgoOCyNzRLliyhsbExqG6rVCrRMNtsNmG2aTab2b17NzBe++Rox0AEnnuio6PRarWo1WqMRiPvvPMOY2NjzJs3jyNHjqDT6bjpppswmUyEhobS0NBAVVUVVVVVhIaG4nK56O7uFhnIML69liSJwcFBMeyWv2ez2QgNDcVkMtHX10dOTg4LFy7EarUGnRfGxsbEhvjspcmhQ4fwer04nU6R7CE/J/JtKZVKfD6foJ3LsWTuPW/jO3mSkE9+AuWZTWAgfC0tWMruGI90kg2+XE4UAbXJV3UKXC4klwtfczOaxPcNnPx9/aBUEHLXnXjfPYKqtATFJN4Z7s1bsH/9KdBoiN2zG+W99xDn92MymYTuO+vV1wgDXG+/jfJjDzC3tPSC31u2bzyNZ/sO9N/5Ntoz58BrjdbWVtrb2ykpKZlys9za2sqGDRu45557+OEPf3jdyDGma/2l4R+6YQ6EUqlk6dKlLF26lGeffZbjx4+zadMm/v3f/53PfOYzrF69mrKyMm677bbzHtI9Hg9VVVV4PJ4LNsW6kPt2LiqXJEnExcUJzejl/OB1dXVRX19PYWHhFXPDC3Tik+FwOIQTZaA5hmwoJW+WZdjtdo4ePUpERISgkYSGhpKdnU1OTg4ul4udO3ditVoZGRnBarXi8Xhoa2tj0aJFwkRJbnTUajU6nQ6r1YrVauXQoUOoVCqys7NZtGgRLS0t5OfnC1p0SkoKb7/9Nj09PaSlpQm6uFqtntQN2uFwAOONVuC2W3bSdjqdQcZOfr+f9957j7GxMfHz0dHRQS6bHR0dHD9+HBgfRExG/5d/VzYpkSnRMhtCp9Mxf/58NBoNKSkpQe+l06dPc+LECcLCwigrKztnswzBbtcyNBoN0dHRWK1WFixYQF1dHZ2dnURERNDe3o7dbicuLo6YmJjzNpxDQ0PiANLT03PNG2a5WfZ4PJfULG/fvp1PfepT/Pa3v+WOO+64zPdy6njsscd47bXX2L9/f9DWRGY9mM3mCUZ1FyoLmMY0rgUUCgU5OTk8+eSTfPWrX6Wjo4PNmzezZcsWnnzySRYuXMjGjRspKytjxowZ52yeZXfcrq6uoGjFS71vgdFzssRFzm2Pjo4mISGBuLi4KefVTgaLxUJFRQWJiYnMmjXrijB9EhISJj1HyCyzwFqv1+vR6XQ4nc6gYbPf7+f48eM4HA4KCwuFnjcmJoZ77rkHv9/PwYMHgzKcnU4nTqeT0dFR0bQGylpiY2Pp6upCrVZz4MABtFotiYmJFBQU4PP5SEhIIDU1lYGBAVJTUwULKzIykrGxMeF6PBnLzO12i+F0oDGnUqkkOTmZjo6OCUOWxsZGmpubiYyMxOfzicWOfJb0m83YPvfIeBNssaD/1jcn3K7kdo83y4AyIwN/SwuaM9RZz9Fj+Hu60WxYT0hzC4rICNSLF4nf9VZXY737XlAoiNi6GcPbuyd/QQFJzqj2epHOeNIolUqijUYiDh0mKy6WsW88hfmFFxhZsACz2UxlZaXYPp/vfCx5vbhf2gSShGvLy9dFw9zW1iaa5akswmD8rLZu3To2bNjAT37yk+umWZ6u9ZeOf5qGORCyYceCBQv4wQ9+QFVVFZs2beLZZ5/lc5/7HLfccgtlZWWsX78+iB7d1dVFe3s7er2e0tLSK+LEPRmVq7+/X1C55Ob5UqhcsvNfZ2cnxcXFV50GGhsby5IlS3C5XCJaCcY3qvfcc4+gcslobGyks7MTQGiQbTYbTqcTSZI4ceIEERERWK1WQkJCyM3NpaqqilmzZjE2NkZtbS1JSUkYjUb6+vrIyMiguLhYmIXt2rWLkZERWlpaSE9PJzU1lZCQkCBdueyKabVaxQZXp9Ph9XqFw3ZtbS2SJJGfn49KpRJ08l27dgljrPLycvx+f9DjGxkZoampCXh/qi4fMmTodDpxXwKnnn6/n6qqKrxer6CnFRYWUlRUJGKiGhsbhaZ6w4YNLFu2bMJrIrtP2+12QRkLhGx2ExYWxpIlS+jo6Jig1Xr33Xfp7OwkJCSE2NhYFixYQFpaGhaLhYGBAZqbm6muriY6OloU1LM9BRISEkhPT8ftdpMeYChyLSA/t263WzijTwW7d+/mwQcf5Je//CX33HPPZb6XU4MkSTz++ONs3bqVvXv3TsgilWNAdu/ezV133QWMswU6OjqENnAa07jeoVAoSE9P50tf+hJf/OIX6enpYcuWLWzZsoWnn36aefPmUV5eTllZmdjuwXh9qaqqwufzTYhWvJz3LTw8nPDwcLKysrDb7QwMDNDV1cXp06eJiooSTLNL8V4ZGhqiqqqK7Ozsq35NVSgU3HLLLfT09ARtnrVaLeXl5Xi93qDHNjQ0JJIzZFkTjNffyMhIKisrg2Ie09LSMJlMREREEBERQWVlJSqVCqPRiFKpxGAwsHz5chwOB1qtlsrKSurq6mhqahJ07ejoaHQ6nbgGylIsq9WKTqfDbrcTFhaGJElCH93X10d/fz8FBQUsX74cp9NJTk4ONTU1VFRUMHPmTG688Ua8Xu+EunH8+HG8Xq+4HZ/Ph9PpFM2lQqdHio1FMTCA8ixmluuVbXgPHUYRPz4YUC1cQPjvfwd2O8rISHwdnYx99GMgSeie/sakkU/+zi7RbPu7u+EsKZ0kSTh/8QJSfz8hn38cRXg4ytQUVOnvMxDdf38J+zPjjXzrD76P+mtPMr+oCKfTyeDgIH19fdTX1xMRESFMw8LCwoIGNQq1Gt1Xvox7+w5CH/70JO+eq4v29nZaW1svqVnu6elh/fr1rF69mp///OfXRbM8XesvH/4pG+ZAyNEw8+bN4zvf+Q6nT59m06ZNPP/88zz22GPcdNNNlJeXExUVxaOPPsp3v/tdHnzwwavyQQikcs2aNeuyULlkOvnIyMgVOwh8EBQKRVCjHIjJpuqJiYnU1NSg0+mYM2cOarWaqKgoRkZGOHToEEajkcTERHp6elCpVGRlZQk35QMHDtDW1kZjYyOhoaFIkkRXV1dQRICsawoLCyM7O1voyuX7mpmZSXR0NMPDwxQWFhITEyP0ydu3b2doaIiEhASh3TIYDIK25Xa7BQ26q6uLjIwM8d7x+/3CgVo2xiotLcVkMpGRkYHf7+edd95hdHRURD9FR0cHDTh6enpE9JMMi8USNEwJpIAFft3v99PY2IharWbu3LmEhoaec7NRX18vXMmTk5Mn6NXh/Q2+1+slJydHbMENBgMGg4GZM2eKLO3JXDjDwsJQqVTceOONE/721Ybf7xda7ovJkDwb+/fv54EHHuB//ud/+OhHP3rdaLgfffRRXnzxRV555RVxAITx10qn02EwGHjooYf40pe+RHR0NJGRkTz++OMsWbJk2gRkGh9KyJ4Zjz/+OI899hj9/f28/PLLbNmyhW9/+9vk5+eLWMovf/nLFBQU8MILL1zWTe/5oNfrycjIICMjQ0RVyY2HwWAQzfPFeK/IdPKCgoJrti2Sh6NnQ6VSTRj6y0ahLpeLnJwc9Hq9cKbetm0bkiQJg0+FQoHBYGDjxo3AuEmTLHlKTk7Gf4Y67HA4hOROboQUCgWzZ89mbGyMuro63G43CoWChIQEwsPD0Wg0ZGZmMnfuXCwWC7GxsZw6dYqqqip0Op1gkfl8vqCmor29Xfwrx2LJcDgcYhA/MjLCzJkzUSqVREREYDQacf7m/3D+7vdYH7ifA//yScLtdlbf+/6AVbLbsf/bV0GSUEQZx2+/ugalWg0yE0utApUKvF4U+uD3iWfvPrx1dYTcfz+6p74OCgWam2+e8Lr4Kqtw/uSnACiTkyfNYubM35aUSkIjI5ldVIRSqUSv15Oeni6G3rLJbUtLizhfxMfHYzAYUCgUhP7rw4T+68MT//5VRkdHBy0tLRQXF0+Z1dbX18f69etZtmwZv/zlL68bDfd0rb98+KdvmAOhUCjIz8/nmWee4f/9v/9HU1MTmzZt4sc//jHNzc2kp6fjcrkYGBggISHhqh5+J6Ny9ff3CyqXHPVzPiqX1+ulqqoKl8vFggULLgud/GpgdHQUv9+PzWbD7/ezePHioNzFwcFBMaWW6d5yUxoVFUVbWxsRERHMmTOH+vp6Zs+ejclkoqqqiuTkZJYtW0Z3dzeJiYki9svv9/Pmm29iMpno7e0VrtZtbW2kpqaKi6FsFhIYz2QwGMSBJzY2lpiYGBwOR1CTKUkS27dvZ2RkhLCwMEFzTktLE0ZkJpNJbNYno0HD+CFLvt28vDxMJhNFRUX4/X6OHj0qqGoAs2fPDpqctrW1cfToUQBWrVrFvADDkMD7CQjTnNDQ0KAhi91u58iRI4SGhpKTk8Po6Ch5eXmTUsZhfCgRFhZGRkbGBBdOvV4vCuq1dI2Xm2WHw3FJzfLBgwe59957+dGPfsQnP/nJ66ZZBvjFL34BMCHC5be//S2f/OQnAQSd7K677sLlcrF27Vqef/75q3xPpzGNyw+FQkFiYiKf/exn+cxnPsPIyAivvPIKv//97/n2t79NWFgYt956K01NTcyePfuqf3ZDQ0NJS0sjLS1NXCf7+/tpbGwkPDxcpGucy3tFkiShxbxcdPKrAZfLJdhVw8PDzJs3D4fDwYEDB8TXZZ8RSZKw2+2CRio3YUqlkry8vKCUhnfffRe1Ws28efPQ6/WEhYWJ52TWrFmcOHGC06dP09PTIxhkHR0dzJs3TzT78u27XC7BaIuJicHv99PT04PRaCQ6OhqbzRbkTwJQWVnJqVOnCA8PF9T0uLi4oNgq5y//F8lkIuSlTfj+5ZOMhoSIDTuApNWiTEvD396O9s478TU0oi0bHxa4/vo33G9uH988e70oCwrQ3n23+F3/wABj//oZkCQkqxX9v31l0udf8vtRpqehiItDMptRBZiASX4/9u9+H39bK6qnv0H7175KSGISs1fdMukCSavVioQY2eR2cHBQmM7Jg5Rr7Rrf2dlJc3MzxcXFGAyGKf2NgYEBNmzYwPz58/m///u/66ZZhulafzkx3TCfA7IOSqvV0t/fzy9/+UssFgsvvfQSX/3qV1m8eLHQQaWkpFz15lmmcmVnZ2O32+nv7z8vlcvlclFRUYFGo7mojOXrAfIAQN6Q9vb2UltbS25uLqdOnSIiIoIFCxaIxz0yMsI777wjjEJgfBIsT+9hfPPX2dlJZ2cnWVlZE2gqcsSDyWTCaDSi0WgYGRnB4/Gwe/du/H4/6enphISE4Ha7gyb4Wq2W119/XVC1ZU1uIM3a5/OJr8tFUavVolKp8Hq9WK1WoeX2+XwsXrxYZED7/X727Nkj6GE+nw+j0cj8gOLW19cnNsIy5OZeRqBb+WRbC7fbzfbt23E4HKxatYp7770XpVIZVAxaW1vp7u4Gxo1c5s6dO4GqfS54PB46OztJSEigqKgoyDVepVIFFdSrRW3y+/1UV1djt9svqVl+7733uPvuu/ne977HZz7zmeuqWQaCaI3nQmhoKM899xzPPffcVbhH05jGtYFCoSAmJoacnByqq6t54oknmD9/Plu3bmX58uXMmDGDsrIyysvLmTNnzlWnWYaEhJCamkpqaqoYEPf399Pc3ExYWJio9eHh4SgUCvx+P3V1dQwNDV10xvK1hkqlEoagWq2WsbExTpw4QWJiIjabDY/HQ35+vvBziY6O5vXXX8fr9ZKbmyviDCMiIli9ejUADQ0NQvKUlJQ0YZgrb6rl2581axZNTU1ERESwd+9e0XjD+Llg5syZFBcX43K50Ov1nDx5kurq6iAKuTykliGzz2w2W5CkS5Ik/A0NMGMGpjvKCX/9dcIe+RylhQVC0uV4/hc4n/8F6kUL8be3g0pF6Kc+ifKMXlySJOzf+vY4zfrMdtTf0RFMf9brURgM401wgH41ELavfR33y6+ge/obGPbuAbcbRcBw3He6Dvcf/whA78+fQ/0vnyKvoOCCapvS6yP8938gQqUi79FHGD3DNJPjPWNiYkS9v5pn066uLpqampg/f/6Um+Xh4WE2btzI7Nmz+eMf/3hFpJqXgulaf/lwfb2y1xl+9atf8eyzz/L2229Teibb7stf/jJdXV1CB/XUU09RUlJCWVkZZWVlpKenX/XDsV6vJzMzk8zMTBwOR5CGxGAwYDQa6e3tJSoqatL8yOsdGRkZhIWFodVqMZlMNDU1MW/ePDo7O/F4PCLHUXbaPHr0KA6Hg+7ubpKSkoD3c4/9fj8KhUIYciQmJgY9H4ODgxw/fpzU1FQxCZb1uDB+8XnzzTcZGRlhZGREmJe1traSmJgY1KADIlZDPpTZbDaxzU5MTMRut3PDDTfg8/kICwtDrVbz+uuvYzabhYkWjG/KZfOQsbExQauRjUZkyAcGOfrJ7/dTVFTE2NgY+fn5+P1+Dh8+zOjoKMuWLaOsrAylUjnppmJ0dFRom3t7e4XLp/z4vF4vycnJ1NTU4Pf7KSwsvOBmGaCqqoqWlhaam5tJTU0VpjEylU524ZRdRGXjuytVUCVJoqamBpvNRklJyZSpmCdOnOCOO+7gmWee4bHHHrvumuVpTGMawaivr+e2227jpz/9KQ8/PE4R/cQnPoHVauX1119n8+bNrFmzhvj4eDZu3Mgdd9xBSUnJVa+lGo1GbO28Xi+Dg4PCNEymvJrNZrxe72UzJb2a0Ov13H777TgcDjQaDUePHiUtLY2wsDAqKysBgjKSu7q6xOBZ9hkBRAoGjHujqNVqIeWS4XQ6OXz4MGq1WsizwsLCKC4upqSkBICKigpqamqC/nZHRwezZ88WTKtAs82YmBhMJhMpKSn4fD5aW1sxGo3ExcVhs9mYM2cO8fHxYsjtePa/cP7yf/FlZ3Pwo/fDZz/DspJi8gIG+O5Nm8Hlwnuy8v0n6kwPJNlsSCo1qvx8fLW1hH7yE/j7B9DeOh775fzTn3H9+c/oHn+MyB1v4h8YQD2JnArA/drr4PPhef0NQj/2UThT/yRJQhoeRpmViaKwAE9rG9x4AwUX2CwDeHbswPW/vwJAVVBA9No1REdHC5+ZwcFBOjo6qK2tJSoqSjTPlxL9+kHo6uqioaGB4uLiCZFKFwqTySTO/X/5y18+VIuoaVw8phvm8+CBBx7g1ltvDYpbUigUzJgxgyeeeILPf/7z9PX1sXXrVjZv3swzzzzDnDlzRPN8LXJndTpdEJWrvb2d9vZ2QV9qb28/L5XrekVsbGxQkLzBYBBT3JCQkKDmJiUlhba2NoxGI8uWLRONcXd3N/v27SMqKoq1a9eSmZmJUqkMeo1qa2sZGhpiaGhIbFID3T3lafTIyIjQ3Q4PD6NSqdi9ezcej4fk5GShiZo9e7aYaCsUCrF5DgkJIScnh5tuuiloYytJkrg9ueDLwwK3283w8DA6nY6IiAgkSWLZsmVYrVYSExORJImdO3cyODhIZGSkmIAHRnqZTCZaW1sBaGlpCdpKy7Db7QwNDZGYmEhubi52uz1Ic+52u3n11VdxOp3Mnz+fmJiYKWnk4uPjaWlpISoqKmgqq1QqiYmJISYmhtzcXKHdb21tnWAadrkOhHKzbLVaKS0tnXKzXFVVxcaNG/nqV7/Kl770pelmeRrT+BAgNzeXY8eOTUgHiIiI4L777uO+++7DZrOxfft2Nm/ezMaNG4V+try8nEWLFl11GqZarSYpKYmkpCR8Ph/9/f00NDTg8XgICQkRtT7QuPTDgIiICMGImzlzJjNmzMBqtaJSqcT2WEZcXBzh4eFiYJ6cnExoaCharZYtW7bg8/lYu3Yt9957LxAcVdXR0SHYUfIG2WazBUVPyQ22RqOhsLCQ5uZmjEYjhw8fFnRwuWHOyspi4cKFIq5RbrZl7fzatWuD3LsBfM3NAKi6u1EplUhnpHeSz4f36FGUM9JQZmYiORzovvJlFGFhKGekokxMwPHz53D+7L9Rzs7Df3o8jlNbVoYq7f0NuvOnP0MaHcXx/AsY1q2bEFEluVx49r+DurAQ/be/hfvV1wh99JGgn7F9/gt4tm9H9YkHOfWlL4o0l4t5T6lmzwadDpQKVLmzxNcVCoUwbJNjOmWZVkNDA+Hh4UKmJTMoLge6u7tpaGhg/vz5U26WLRYLd9xxB/Hx8bz00ktXzetgGtcO0w3zeSDTns8FhUJBUlISjzzyCJ/73OcYGhrilVdeYfPmzXzve98jNzdXNM/XQgc1OjpKV1cXs2bNIjExkaGhofNSua5XSJLE6dOnBcVMfk2ysrKIjY0VBVJGe3s7LpeL/v5+FAqF0ATX1dXh9/sZHh7GbrcHvbZutxu1Wk18fLzYTBcUFNDd3c3MmTPp7e3lyJEjJCcni+2u0WgUm2cYjw6yWCxYrVbR7La2thIdHR1Ef4bxAjx37lxRwK1WK62trUJzpVarWbJkCSEhIYSEhKBSqdi+fbtwBJU3z7LuFxB0PXh/6n32hDYyMpLk5GRGR0fP6Zi6Y8cObDYbmZmZkzpq2+12YXrS0NDAkiVLphRLJhuDaTSac25qArX7OTk52O32C3bhvFBIkkRtbS0Wi+WSNsu1tbXcfvvtPPHEE3zta1+7rj9T05jGNIJxvig9GB9c3nXXXdx11104HA7eeusttmzZwr333ktoaCi33347d9xxB0uXLr3qtEyXy0VLSwvR0dHk5+djMpkYGBigsrIShUIhan1UVNR1zzCTJVeBQ9iIiAjKy8vx+XxBdbuvr08MmIeGhoS0qrOzU9SogYGBILqt1+sVcZ0ajQaNRsPChQtpb28nKSkJp9PJvn37UKlUosENDQ2loKCAgoICAJHxLNdhGDfglCVcENycl5SUiL8l2e24/vwiiuwsTq66hTCvl5R77ubOFSuQJInQ0FAcP/4Jzl+8AJERYDlzG36/2BwDePbuHf9yaxtn7uQEo6+Qf/kUrj/8kdAHPz7pc23//g9wv/gXFLGxGA7sJ+SuOyf8jPeMz4l1337i7r6L3Nzci65tqpk5GA8fBIUCxVlDg0AELnw8Ho8wDWtvb0ej0YhaL7ugTwU9PT3U19czb968KSfEjI2NceeddxIREcHWrVs/dEyOaUwN0w3zZYJsYvDpT3+ahx56CLPZzLZt29i8eTPPPvssGRkZQgdVWFh4xYtWZ2cnjY2NFBQUiGbmfFQuuaBeS7OlySAbMNlstkkpZpM5GiYkJIhJcCBFZvbs2djtdmJiYoI27B0dHezfv5+IiAhUKhV+vx+r1SqeExin2Y6NjdHQ0CA2CbIRl4zo6GiGhoZISkoSrtrh4eG888472O12oqOjRZTEvHnzgt4DBw4cYHh4mJCQEFxn8g5tNluQWYv8dbVaLRzU5SzL3t5ewsLCxPDjxhtvFNqgQKhUKlauXHne5zyQvh4Iq9VKT08PM2bMIDc3l87OTkpLSy8pw/ti41Iu1oXzgyA3y2azmdLS0inHt9TX17NhwwYefvhhnnnmmevqMzSNaUzj8kKn07Fx40Y2btyI2+1mz549bN68mY9//OMoFAo2bNhAeXk5y5cvv+Kbp9HRUSoqKkhOTmbmzJlBhkqyvGVgYIDq6mrRKMryluutee7o6BCSq7Nr12T03EB2UmDzk5ycTE5ODj6fL2gwbLPZeO2114QHicfjwePxEBoaKthWjY2NgoIt34ezzTajo6NRKBRotVqKi4tpbW3FYDBw8uRJTCYTer1eNPLp6elBW3Hnr3+D839+DgoFfU88jnPFcjxGIwsDao//DM0clxuiolB4vaiL5yN5vXh270GZkgw6PYrYWEL/7cuoM7NQxMehDMi0BtA98jl0j3zu3E+4/LjOOstINhvuba+imlOE6vvfZeAPf4R77p5SsyxDcZGsRo1GE8SgGBkZYXBwkFOnTiFJkkiJiYmJuWB2R29vL3V1dcybN2/KRng2m427774bjUbDK6+8ckVp49O4vqCQLkQRPo1LgsVi4bXXXmPz5s1s376dpKQkoYOaP3/+ZS1acsZyV1cX8+bN+0C6ic/nE03H0NCQ2LImJCRccNNxpeD1eqmsrMTr9TJ//vyLOnjIG+MLeW6PHTtGXd04pSkpKYne3l5SUlK4+eabGRsbQ6vV0tLSwsmTJ0lOTqaoqIj+/n6ysrIYHBzk4MGDxMfH09fXh9frZebMmSxatEj8/V27domttIyUlBTmzJkjJv779++no6OD+Ph4EbexbNkyHA4H9fX1xMTEcPToUSRJYvXq1WLCqlAo2LFjB4ODg4SGhgpNc1lZ2UWZvZhMJmpqapgxYwbR0dH09/eTlpYW9Jy//PLLjI2NERUVhU6no6ioaNK4kMlgt9sxm80TNOOXC4EunIODgxfkwikzF0ZGRigtLZ3ylLipqYnbbruN++67jx/96EfX3SF0GtOYxtWB1+tl//79vPTSS7z88su4XC42bNhAWVkZK1euvKQ85ckgNxAXkrEsSRKjo6P09/czMDCA1+sNiqa8ls6+geeWizVgktlUF7LV7+7u5u233wYgMzOT1tZWkQkt+3+4XC52796NRqPh5ptvpqenh6SkJDQaDW+99RYwvvHu6elBr9dz553vb2Vra2tFJKUMvV7PkiVLBHvM9dIm7E99AyIiaPmvZxlwOli8eDHGkBCcL/wSRXw8zpdeQqqrJ/TJfyP0wQfHo6Q0GhzPPY/zpz8DjUY0ufpvfZOQjz5wwc+XZB3D8eyzKKKjCfnUJ/HsfAt18XxUAZnP9n//Lq4//hFCQjj142dJysy8YImh5HLhffddVHPnopwi3fm8f//M+3hgYIDBwUGcTmeQadi5zol9fX3U1tYyd+7cCcOYC4XD4eDee+/F4XCwffv2KUdQTePDiekN81VAZGQkDzzwAA888ABjY2O8+eabbN68mfXr1xMdHS2oXAsWLLikouX3+6mtrcVkMgVRl88HlUoVZLYkOxXL1v/Xisrldrs5ceIEWq2WkpKSi6a4XUxznZ+fj9frJTo6mpycHEZGRkQc1YEDBwgJCREOmKOjo0RFRYlpdnt7O263m66uLrHNDsxZlh3NYXwCLv/9iIgIjh8/jslkIjo6mqKiInJzcyccXPbu3Ut/f7/Qb8H4hDPwgi9vgkNCQkRW88Vq1CsqKujp6aGjo4P7779/0mZbfnwOh4NFixYJ3dcHwe/388Ybb+B0OikoKJhUN32pUKlU4r3q9/sxm80MDg5SV1eHx+MRpmHyoUWSJOrq6i65WW5ra2PDhg3ceeed083yNKbxTw61Ws3KlStZuXIlP//5zzl48CCbNm3ii1/8IhaLhdtuu42ysjJWrVo1Qc96sejq6qK+vp7CwsILYvnIrCSj0cisWbOwWCwMDAzQ1NREdXW1aJ7j4uKuKqVcHlwODw9f8LklEBdzX5OSkigqKsLj8TBv3jzy8/PR6XTCl8Pv95OamorT6cTpdKLRaITBWEtLi6Bgy+cLuVZLkoQkSURERIg0jyVLltDd3U1kZCQdp6pxPfc86rAw+PY3idn0EiEpyZQE1FDnr38zTsMOgL+tHUXg45M3wQoFipwcFE4n6htvvKjny7V5M64X/zL+3C1eTMjdd034GUX4+PnBq1aTnDqD7Ivw47F97et4Xnsd5axZGF5/9aLu24Ug8H08c+ZMbGcct+WUGDmzPC4uTnzG+vv7qa2tZc6cOVNull0uFx/96EexWq3s3Llzuln+J8R0w3yVER4ezj333MM999yDw+Fgx44dbN68mbvuugu9Xi9MRJYsWXJRhUDOWHa73SxcuHBKk2ylUnldULkcDgcnTpwgIiLiqtDX9Xp9UEC73AiazWZg/EIZGxuLzWYTG1XZuCsqKkrkDc6bN4+RkRFSUlKEwVh4eLhwmo6OjiY3N1fcjhxT1d/fT0hICB6Ph9jY2KB4BXnbKwfKq1SqICdqs9mMyWRCoVCwaNEiQSG/WCQmJtLT0zMhX3xkZITjx4+TnJxMQUEBtbW1lJaWXnCzDOOHiXPlSF8JyHEjgS6csg6qpqYGo9GIJEk4HI5LyiPv6upi3bp1rFu3jp/97GfTzfI0pjENAZVKxfLly1m+fDk//elPOXLkCJs2beKpp57i4YcfZs2aNZSXl7N27dqLahIlSaKlpYWOjo4pZyzL5pUGg4GcnBxxjWxra6OmpkYMGM+3sbscCJRcXcq1+EKhVCpFmga8T+Pu7+8XA2l5MBweHo5WqxVxVrIESqvVsmLFCgYHB4mLi8Nut/Pmm2/i9XpRKpVIkoRKpRLSIQBX7WnstbUA9OzcSV1uLga3i7ixMeLj49Hr9eNmWAoFiohwQj72MXxNTYQ+9JC4r5LHg+vN7QCEfvZf0T3++JSeA/W8eRASgiI8HFX2+1tlyWrF9vT/A20Ivi99geaQEGIWlJKTf35t/9mQzgwVpAB995VCYMRqZmYmTqdTsMwaGxsJCwtDr9czNDREUVHRRZ1bAuF2u3nwwQcZGBhg165dUzYKm8aHG9OU7OsETqeT3bt3s2XLFl555RVUKpXYPN9www3ntasPzFieO3fuZZ8OS5KE2WxmYGDgilO55NzF+Pj4S9LLXA40NjZy9OhREhISWLlyJXa7Hb1eT1tbGwcPHkSlUqHRaHA6nURGRrJx40bxu0ePHqW+vh5AOFwXFhYyb9483G43KpWKnp4eDh8+THJyMkuXLsVut4vnWKY+y2ZW59rwt7e388477wBw4403BtHy7HY7fr//nIexkZERdu3ahV6vZ+3atUiShEajCXrO33nnHdrb24Hxprq4uHhKBzRZf5SVlXVNoxccDgc1NTWMjo4iSdKUXTh7e3tZu3Yty5cv51e/+tU1pTNOYxrT+PDA7/dz4sQJNm3axJYtW+jq6mLVqlWUl5dz2223nddHxO/3CxnJ/PnzL3obeyGw2WyiDlmtVqKiogR753JSymXJlc/nY968edfUZdhsNrNz505UKhXr169HkiS0Wi1Op5Nt27bh8/lITEwU0qq77rpLaFe7urrYe8aAS6/XY7fbiYqKGv87Ljd43PhHRxn7xKcgJISIP/weT3iY8JEZGRkRJqxxCgXhsbEoJ9le+s1mRhcuBklCe+89hH3vu+J7ks2Gv6sL5axZk753JLsd6/0P4O/qJvy3v0GVkwNqNYqA51xQxYG2z30G4x13CBO1i4F/eBj362+gWX4jqoyMi/79ywWv10tzczMdHR0olcog07CLYUx6PB4+9alP0dTUxJ49e6bcdE/jw4/phvk6hMfjYe/evWzevJmXX34Zr9crdFA33XRTUNHq7e2lqamJqKgo8vPzr/iWS5IkQeUaGBjA6XReNiqX2WymoqKCtLQ0srKyrrlx0ltvvSWcth944AFxf2pqaqioqADGM6Lb2tpEMzwwMIBWq6WhoYHGxkbi4uJYsWIFo6OjxMXF0dvby9tvv41Op2PDhg3nPCQ4HA7xHI+OjhIZGSkOLYFUPnlCD1BUVCRe/9HRUV5//XWheZ5s83zq1CmRbbl27dogPbI8be/q6uLgwYNotVpuueWWKbtKXg+QJInGxkb6+/spKSlBo9EI/f7w8PAFu3D29/dz2223UVpayu9///vpZnka05jGlOD3+6murhbNc1NTEytXrqSsrIz169cTFRUl6s7o6Cj19fX4fD7mz59/VZx5z65DBoOBhISES87IDZRczZkz56q7ip+NwJq+atUq4c5tMpl4/fXXAcjOzhZO5GvXrmVsbAy73S506xqNhg0bNmCxWMZ9MyxWLOs3IFksRPzhd6hLSye97UA36KGhIUJCQkStP9tHxvXKNrzHj6P73OdQJo3fR8nnw7LmVvwdHYR+4Ql0Z8VCAXirqrDedQ8AoY8/hu7z72+nJZ8PXC78Q8NY7v0ILiRcz/2c9DNZ1B9WDA4OUlVVJTbLMmNycHAQn88XZBp2rvef1+vl4Ycf5tSpU7z99tuXZHA6jQ8/phvm6xxer5cDBw6wadMmYbq0fv16ysrKAHj44Yf59a9/zbp16656gylnBssFVXaClgvqxWwSZfMSOXfxekBvby8nTpwgMzMzKMv49OnTHD9+nPj4eNasWYPP50OlUgm3bRinCsmaJvm1AqisrBQNrnwg+iC4XK5Jp9Hn24r29vaye/duAJYtWxY0KbZYLLjdbvR6PUeOHEGv17NgwQLRIJpMJnbs2IFKpWLu3Ll0d3dfUl7h9QBJkmhqaqK3t5fS0tKJeZgBLpyDg4PndOEcHBxk/fr1FBQU8Oc///mqHfT279/Pj370I44fP05vby9bt26lvLw86PF985vf5Fe/+hVms5lly5bxi1/8gpkzZ16V+zeNaUzj0iD7KsjNc01NDStWrKCsrIySkhI+9alPsWrVKr73ve9dE5aOy+UStV6ON5QNQi9Gj321JVcXApvNxqFDhwgNDWXp0qXiej88PMyOHTtQq9XcfvvtaLValEolTqeTrVu34vf7BYMM4M477xTPhffECawfuR8A3deeJPShf/nA+yGbV8rN84X4yEguF+b5JeDxoL2jnLD//KH4nt9kwld7GlXxfBw/ehZ/Rwdh3/nO+822y4Wl7A78bW3ww//gZGQE2dnZpKWlXdLzea0hnycDU2JkyEsf+Uwln1vlYbm8kPL5fDzyyCMcOXKEvXv3kpycfNXu/3S9vz4x3TB/iODz+Xj33XfZtGkTf/7znxkcHKSwsJCvfe1rrFmz5qKNni43pkrlmix38XqGvHlWKpU88MD77pTNzc0cPnwYgLS0NHp6epgzZw75+fn09vaiUCiIiori5MmTRERETCmbW55GDw4OMjQ0hFarFZRio9Eo/p68TfX5fOTm5gblPW/btg1Jkli+fPmkhbGxsZEjR44A47EaS5cuvWDXUrPZzNtvv01YWBgrV6685psDeL9Z7unpobS09AM/J2e7cL7xxhscO3aMm2++mU2bNpGbm8vf//73q3poffPNNzl48CAlJSXceeedEwroD3/4Q37wgx/w+9//nszMTP7f//t/nDp1itra2umMyGlM40MG2TV606ZNvPjii5w6dYro6GiefPJJ7rrrLhITE68pA8vtdouGY3h4WAxxExISCAsLO+d9Gxsb4/jx4yQkJFxzydWFIHDzvGbNGsHUstlsbN26FYD4+HjMZjNxcXHcdNNN+Jua8TU1or7lFly//g3S0BC6L34BxUWkVgDCR0Z+ngO3omdL4TyHD+N99wghH/+YiJaSJAnLmrX429rRfuQjhH333yfchq+rC8vNtwAwcMtK9N946oIXFpLTydhDD+Pv7ib8l79AFeDPci0xNDREVVXVpM3yZJBNwwYHB2loaOCnP/0pa9asobW1VWyWr/YAYbreX5+Ybpg/hHjuued48skn+eY3v8ng4CBbt26lp6eH1atXU15ezq233nrNHfzOReWKj48P+kC3t7fT3Nx8SVb/Vxvy9DI9PZ3s7Gzx9dbWVmpra5k1a1bQpK+np4c9e/YAwUX3YtHS0kJraytFRUXEx8eLrajc2MlRSvHx8URHR086jR4ZGeGNN94AYNGiRUH302QyMTY2RkJCAvv27cNms3HTTTdd1Ga5qqqKqqoqYCLN+1qhqamJ7u7uC2qWz4YkSdTU1PDb3/6W3/3ud7hcLpYtW8Ydd9xBeXk5WQFRHFcLCoUiqIBKkkRycjJf/vKX+cpXvgKM0zcTEhL43e9+x3333XfV7+M0pjGNS8eRI0eEC39OTg6vvPIKR44cYdGiRWzcuJGysjJSU1OvaeN5NqU4NDRUNM+yazRcf5KrC4HT6eTo0aPodDqKi4uDWFhHjhwhKioqiJ0lWa2Yly4Dp4vQRx9B94UnpnS73ppaHD/5KZqbVxD60Y9OKoULNGabbHgrSRKjCxcjmc1o1q4l/Of/Lb7nHxrCe/hd1CuWY/7jHzG9e4TQL32RlItIsPCerMR6z70AhH7+cXSPPzalx3o5MTw8TGVlJfn5+VNavgwODvKnP/2Jn//85/T19ZGdnc0999xDWVkZCxcuvCZsiOl6f/1gumH+kOEXv/gFTz/9NK+++ipLly4FxieRlZWVbN68mS1bttDS0sKqVauEDupa5ymfi8rldDrp7++/6NzF6w2BGZLFxcUThhUX0jCfPn1aXOjnzJkz6e385S9/wefzCSp4IOQoJbl5DjRmO1uj09XVhcvlIjMzUxQAu93O1q1bkSSJjIwMvF4vJSUlF5XlDOMbhIMHD6LX61m2bNk1p9vJr0tJScmUDXIsFgtlZWUYjUZ+8YtfsHPnTl5++WX27NnDM888w9NPP32Z7/X5cXYBbWlpITs7m4qKCubNmyd+bsWKFcybN4+f/exnV/X+TWMa07h0VFVVsWzZMr7//e/z+BlHZEmS6O7uZsuWLWzZsoWDBw8yf/58ysvLKSsrIyMj45rWep/PJ5rnwcFB4QsREhJCc3Mzs2bNum4kV1OFvMGcNWsWqampQd8bb5hvAKfznA2z98QJxj73KKqZMwn/7W9QTNLsjj3yGJ633gKFAuOpShQBDD1JkoLYfLJBqNw8By4kfI2NeA4eQrvxdpQBZp2W28vw1dUhLV7EyU99kry8vIumHEseD7Ynv4a/u4ewH/0nqrRr+7qOjIxw8uRJZs+eTVJS0pT+ht/v5+tf/zovv/wyr732Gs3NzeK/CwsLheTuamK63l8/mG6YP2To7+/HbDYHxRMFQpIkamtrhQ7q9OnT3HzzzZSXl7N+/XpiYmKuOZVrYGCAlpYWXC4Xer2exMTED6RyXa+QJIn6+noGBgYoLi4+Z1PW29uLUqk8J0Vo27ZtWCwWQkNDufvuu4O+5/f7USqVHDp0iNbWVkpKSkQ2JIxvUOvr6ykqKiItLW2CRsfhcARpdCYzGgtsmI1GIzfddNMVcWC9mpCjV6aS7SljbGyMO++8E61Wy2uvvRak1RsdHcXhcFx1GcHZBfTQoUMsW7aMnp6eoIPCvffei0Kh4G9/+9tVvX/TmMY0Lh2yBGvZsmWTfl+SJPr7+9m6dStbtmxh3759FBQUiOZ55syZ17x5HhkZoa2tDbPZjFqtJikpSciHrvUwdSro7++nurr6vPIxX2MTvqZGNKtWTdoM23/wH7j+77cARL75Bqqc91lqks8HSiXul1/B/vWnUC9fTvgvfyFeR29NDfZvfhv1ooXo/218u+hwOEStN5vNREZGCqbZuRhVo+tvx9/QgGV2HtpfvjDlBvN6gdwsT6Xxl+H3+/nWt77Fn//8Z/bu3Rt0xvZ4PHR2dl4XjLLpen/tMN0w/wND1rHKzXNlZSU33ngjZWVlbNy4kfj4+KteUH0+H9XV1dhsNubMmYPVag2icsm07UAq1/UKeThhMpkoLi6+KOMT+feHh4eJiIigv7+fmpoacnNzgy7KtbW1nDhxguzsbJYsWSKa50C89NJLuFwuDAYDt99++4TbOVtbbjQahbZcnkZLksTJkyfp7+/nhhtu+NA3y62trbS3t09pSy7Dbrdz99134/f7eeONN66b52S6gE5jGtMIhFxLXnnlFTZv3szu3buZNWsWZWVllJeXT8kv43JAllzNmTMHhUIh6pAkScTFxZGQkHBO+dD1hp6eHurq6igqKpqS1MjX1gZKFfi82L/xNMq8PPRPfwPFmcfuPXEC6yf/BWViIpFbNoFOh+KsBAbbV7+G+4x22vDuIZRnydjO1pbr9XpR6wPPVIOnT9O1ZSvJ995DwofcKMpkMlFRUXFJzbIkSXz/+9/n17/+NXv27KGgoOAy38upY7reXz+49o4807hiUCgUzJo1i6eeeoqvf/3rtLa2snnzZv7617/yla98hSVLlggdVHJy8hUvqF6vl5MnT+L3+yktLUWr1RIeHk5SUpKgcvX393Ps2DE0Go1onq81pXwyyHEgY2NjlJaWTslo4dSpU1RVVaHX6ykvL5/UWKKjo0P8u2TJkqCDhcvlQqvVMmvWLOrq6s7pkBgWFkZmZiaZmZk4nU5xaGloaCAiIoK4uDjsdjtjY2MsX778ghv/4eFhenp6yM7OvuhhwZVEW1vbJTfLTqeT+++/H5fLxY4dO66bZnkyyJuO/v7+oALa398fRNmaxjSm8Y8JhUJBbGwsDz30EP/yL//C6Ogo27ZtY/PmzfzXf/0X6enpbNy4kTvuuCMofvBKQTZa7O7upqSkREiuYmJiyMvLE/Kh06dP4/V6xUY0MJHgekJnZyeNjY3MmzeP6ABq84XCe/w41vs/CkolES9vIeLFP0/4Gc/BQ+Bw4G9txdfairqoSHxPsttBpUZ7+wY8e99GvWABiknuh1arJSUlhZSUFLxer6DHy2eq+Ph41Go1rd3dzHn40xfsp+IfHsb195fQLF6Mev68i378VwqyLj43N/eSmuVnn32WF1544bprlifDdL2/dphumP9JoFAoyMrK4t/+7d/4yle+QmdnJ1u2bGHr1q18/etfp6SkREyj09LSLnuD6nK5qKioQKvVMn/+/AlFUaVSkZCQQEJCQpCZVUVFBSqVSkxJrwcql8/no6qqCpfLJRr/qcButwPjzVng5liSJPr6+oiMjGT+/PnU1NQExULB+9FWCQkJrFq1irlz517QbYaGhpKWlkZaWpqYRre0tOB0OtHpdPT09BAXF0dkZOQHvgd2796N2+1maGiIm2++eQrPwOVHe3u7oK1PtVl2uVx87GMfw2w2s3PnzmtuoPdByMzMJDExkd27d4uCabFYOHLkCJ/73Oeu7Z2bxjSmcVWhUCgwGo08+OCDPPjgg1gsFl5//XU2b97M6tWrSUhIEM1zoJHV5YLf76euro7h4WEWLFgwgRYsp0VERUUxa9YsYWbV0NCA2+0OcoK+HlIWWltbaWtro7i4eMrRiv7+fpAk8PmQBofgfUUV3ro68HoJue8j+BobUaamogpo2rynTmG9/6Mo9HoiX30F43tHLug21Wo1iYmJJCYm4vf7GR4epr29HZPJhFqtFkahMTExH/gesH/3e3heex2nTofxxDEU18HrIjfLs2bNIiUlZUp/Q5Ik/vu//5uf/exn7Ny584LPUdcS0/X+2uHav+uncdWhUChIS0vjC1/4Ak888YTIeduyZQvPPPMMc+bMETqo7OzsS26eHQ4Hx48fx2AwUFBQ8IEXZ5VKRVxcHHFxccyePRuTyUR/fz+nTp1CkiTRPF8LKpe8JZckiZKSkkuKFpo/fz7h4eFi6iujtraWiooKNBoNd955JytXrpzwu319fQCC3nYxr1FraytHjx4lIyND5DgvWbJEULdPnDiBWq0Oiqua7HnW6/W43e5rHmcmo6Ojg5aWFkpKSqbc5Lrdbj7xiU/Q09PD7t27Lygn+2pgbGyMpqYm8f+tra2cPHmS6Oho8Vn+7ne/y8yZM0XMRHJyclAUxTSmMY1/PkRGRnL//fdz//33Y7PZePPNN9myZQu33347RqORjRs3Ul5ezsKFCy95uxsouVqwYMEHMq8UCgUGgwGDwUBOTg5jY2PC46Smpobo6GgSEhLO6QR9JRG4JS8tLZ3yABZAc+ut6P/dAlot6hve16R7T53Cetc9IEmE//H3hP/3RMMmb2UVuFxILhe+5haUFxCVJMPX3MzYp/8VRUwM3h/+AIvFwrz/396dhjV1bX0A/4epzKMM4oSAgigKxAlHtCgoQoK1tfXWqWpvveq9tr1Wq63audUOvq2VaieqVquSAM4KCI5YIcwItA5IBRPmeUjIOe+HvjmvKCqEQADX73n8YBIOO9En66y9117bywt6enooLi5Gbm4uFArFEycpdP5vJVPH1hboBuXzVVVVSE1Nhaur60ON19qKZVmEhYXhs88+w+nTpzF69GgNj1J9FO+7J9rDTDgsy6K0tBRRUVEQiUQ4d+4c3N3dueTZ3d293clzTU0NUlJSNHLuIsuyXClXcXFxl5dyKRQKLpn08vLqtN+XmpqK7Oxs8Hg8zJs3jzvDWtUhVdUcLTs7G/3798egQYPadX3VOdIA4OTk9FBJOcMwLY6rUu03U01SqN63QqFAZWVlm2aoO9tff/2FGzduwMfHR+2O6wqFAsuWLUNubi7i4+O7xZFYKgkJCa2u4i9evBjh4eFgWRZbtmzBnj17UFlZiUmTJmHXrl0YOnSoFkZLCOnuGhoacPbsWYjFYhw7dgxGRkYIDg6GUCjEhAkT2r26e/+WKy8vL7Urr1RUE7gymQy1tbVc40o7O7sOX/tJ7m/myefzO21SWHH1KmoXLgYAmOz6FgYz/LnnmjMywFZWQtfHB41f7gDPwhyGq1c9tK/5cRq//wEN27YDAP58Yy1cXnihxfGdLMtyfWQe1yCUVSqhzMiErqtLu8+T1rSqqiqur4u65yOzLIsff/wR7777Lk6cOIFJkyZpeJQdQ/G+e6KEmbSKZVlUVFRw+6BiYmLg7OzMlW23ZaW4oqICaWlpGDRoEAYPHqzRMu/7zyWUyWSdXsrV1NSElJQUGBkZwdPTs1OT8+bmZty6dQtWVlYtkra8vDwkJSWBx+NBKBSqHcQLCwtx9epVGBkZYfr06Y9dBbh/kqKkpIT7nFUVAN2hZE6VLHt7e6tdMtfc3Ix//vOfSE9Px7lz57q88zUhhGiLXC5HbGwsxGIxoqOjwePxuOR5ypQpT1zdvX/L1ahRozQeHxsaGrhYX11dDQsLC67HiTr9Qx6HYRjk5OSgoqICfD4fRkZGGr3+g+QxsYBcDv3Zs7h7JOWNm6ieHQSwLIw/345nBCFqXZu5J0X5mn+jWl8Pll99CesnxDXVJEVJSQmqq6u5BqG2trad/jm0RXV1NSQSCZydndu9UKDCsiz27duHdevW4dixY/Dz89PsIEmvRQkzaZOqqiocP34cIpEIZ86cgaOjI7cPysvL66HkuaSkBJmZmRgyZEinn7vIsixqa2shk8m4WVIbGxvui76jpVwNDQ1ISUmBubl5myYKHiSXy5GYmAgA8PX1VXt2PDc3F8nJyR1KmO9vVsbn87nV6ydRKpXg8XgtOm7X1dW1mI1u67U06e7du/jjjz86tL9MqVRi9erVSExMRHx8vNr7oQghpKdTKBS4cOECjhw5gujoaMjlcsyZMwcCgQDTpk176Hu+vVuuOqqxsRElJSXcEZvm5ubcynNHm08yDIPMzEzU1dW1Kz7er2HH/6D592swevcd6HkMU2scyj//RHVQ8N8J8/bP8IyapbaqZmXe3t5t3l7EMgzQ3IwmhuE6bldUVHDbx1THVXV1I9aamhpIJBI4OTnByclJrWuwLIuDBw9i7dq1iIqKgr+//5N/iJD/Qwkzabfa2lqcPHkSIpEIp06dgo2NDYKDgxEaGooxY8YgLCwMsbGx+O677x557nBn0mQpV11dHVJSUmBjY6P20Ry3b9/G5cuXAQATJ058qIFXWzEMg7/++gumpqYtyqra8/OZmZmor68Hn89v82dRXFyMuLg4GBkZYfbs2dzP1dfXc8mzatZf9Tl3xWx0YWEh8vLy2nUz8CCGYbB27VqcO3cOCQkJapd4EUJIb6NUKnHp0iVEREQgKioKNTU1mDVrFoRCIfz9/ZGZmYn//Oc/2LlzJ3x8fLo8iZLL5VwMKi8vb5HUtfdkA6VSifT0dMjlcvj4+Kg1sc2UlaNqvC8AwCA0FCbbPm33NVSaU1LAlJdD/9ln1fpcCwoKcPPmzXZVXjHV1agRhIIpLYXZ3nDoeXsD+HsS5f7jqgwNDbnPuS0NQjtKE8kyAERERGDlypU4cuQIZs+erbkBkqfCU5kw5+fn44MPPsC5c+cglUrh6OiIl19+GZs2bWrxJZmRkYFVq1YhKSkJtra2WLNmDd566y0tjrz7qa+vx5kzZyAWi3H8+HEwDIP6+nps3LgR//3vf7V+RERDQwO38nx/iVFbSrlU+6/79u2LIUOGqB0U6urqEBMTAwCYOXNmlx3BxLIsCgoKwDAMBg4ciMzMTDQ2Nrb7ZiAjIwMZGRkAgMDAQPTp0+eh16hm/btqNlp1Jqa6x3wAfyfLb731Fk6cOIH4+PgW518TQno+ivWawzAMrl69yiXPUqkUCoUC/v7+CA8P71BTLE1QKBTc0ZRlZWUwMjJq9Qzi1jQ3NyM1NRXA38041d1qxDIMal9bieZkCUy//AL6flPVuo46mjMz0ZySimfmzsWdslLcvn273T09mtPSUfP8CwAAwzdeh9HK1x56jeoI0OLiYpSWlnb6KSa1tbVITk7mtvap6+jRo1i2bBkOHDgAgUCgwRGSp8VTmTCfPn0ahw4dwksvvQRXV1dkZWVhxYoVWLhwIT7//HMAf++VGDp0KPz9/fH2228jMzMTr7zyCnbs2IFXX31Vy++g+2FZFm+99Rb27NmDSZMm4erVq9DX1+f2QU2aNKnLu1w+qD2lXKrGEp2x/7qrSKVSxMbGAgAGDBgAQ0ND+Pj4tPvfobGxEcnJyTA1NcWoUaOe+FmoblxUAfWZZ57hPmdNnKl979495OTkdDhZ3rRpE0QiEeLj4x95hjUhpOeiWN85jh49ihdffBGTJk1Cfn4+CgsL4e/vD6FQiFmzZmn9KL7m5maUlZVBJpOhtLQUBgYGj4xBcrmcO5WiM/ZfdwW2sRGVY8YCjU1omhOEXEEIfHx82v3vwDIMGr/aAWXRPRhvfBs6No+PrwzDoKKiglvlZ1mW6yWjiUastbW1kEgkGDBgQIcmtE+ePInFixfjl19+wbx58zo0JvL0eioT5tZs374dYWFhuHXrFgAgLCwMmzZtglQq5WaiN2zYgKioKOTm5mpzqN2OUqnEa6+9hrNnzyImJgZDhw6FQqFAfHw8RCIRoqKioFQqMWfOHAiFQvj5+XV6l8sneVwpl1wuR3p6eocaS3QEwzC4cOECampqMHnyZLX35paVleHUqVMAgP79+2PixIldPmmhVCpRVlbGNRLR0dHhPmcrK6t2z0arkuVRo0apVZYO/D25895772Hv3r1ISEiAu7v7k3+IENIrUKzvmL1792LlypVc8sEwDDIyMiASiSAWi3Hz5k08++yzEAgECAoKgqWlpVYnnB+MQfeviBobGyM1NRXGxsbw9PTUymkPjXu+R9OBgzB8fa3azb1YuRxVU6eBLS2FbPYs9Pvwgy5f8WdZFlVVVdx9VVNTU4tGrO2996irq0NycjL69+8PFxcXtccVExODBQsW4IcffsBLL72k9nUIoYT5/7zzzjs4ffo0kpOTAQCLFi1CdXU1oqKiuNfEx8dj+vTpKC8v7zbns3YHDMNg69at+Oc//9lqw6Tm5mZcunQJR44cQVRUFOrr6xEUFISQkBD4+/trvMtle92/P6e0tJSbJXV1deXOKe5K9ye6I0aM4A6nby+lUomrV6+CYRj4+vpqvaP1/bPRJSUlUCqV7ToWTCqV4vr16x1Olj/55BPs3r0b8fHxGDFihFrXIYT0TBTrO2bfvn1wdHTEs88++9BzLMsiJycHEREREIvFuH79Ovz8/CAQCDBnzhz06dNHq8mzKgaptmkpFAoYGRnBzc1Na8cjVvqMBltTA91hw2B+NEqta7Asi1vJyahISYHbiy/CTM2jFTVF1YhV3QahqmS5X79+cHFxUfv/TEJCAl544QV8++23WLRoUY+sFCTdByXMAG7cuAE+n4/PP/8cK1asAPD3XtPBgwdj9+7d3OuuX7+O4cOH4/r16xg2TL3uh087pVKJxMREbh9URUUFAgICIBQKu3R/b2tkMhkyMzMxYMAANDU1PbGUq7MwDIOLFy+iurpa7RVm1Z4sHo8Hb2/vNpdG3bt3D8XFxXBzc+vUiQzVbLRqoqKxsbHFcVUPzkbLZDJkZ2dj5MiRre6hbuvv/PLLL7Fjxw7ExcWpPRFBCOmZKNZ3HZZlcePGDS55TktLw6RJkyAQCBASEgJ7e3utJTB1dXWQSCQwNzeHoaEhiouL2z2BqymN3/+Apl8PwOiN12EQEtzun1d9zkVFReDz+W1udqa8UwC5SAT9mTOg18kTx6oGoSUlJaiqqoKFhQX3WT94z1dfX4/k5GT07dsXrq6uav8fuXTpEp577jl8+eWXWL58OSXLpMN6VcK8YcMGfPbZZ499TU5OTosSzMLCQkydOhV+fn744YcfuMcpiHY+hmGQlJSEiIgIREZGQiqVYsaMGRAKhQgMDOzSkiJVEylPT0/u7OPHlXJZWVl12y/g5uZmpKSkQFdXF15eXm0O/AqFAocPHwbLsnB1dcX48eM7eaR/Y1m2xXFVtbW1sLKy4majq6urkZmZiZEjR7Y4l7q9v+Obb77Btm3bcObMGYwZM0bD74IQ0lUo1vcsLMsiPz8fIpEIkZGRuHbtGsaNGweBQACBQIB+/fp1WTxVNfN0dHTkErIHy4nlcnmLcmJtV2c9Csuy+OOPPyCTycDn89t11GTNSwvQnCwBz84OlpcvduIoW2pqauImysvLy2FiYsLdV+no6EAikcDBwaFDjVavXr2K0NBQfPzxx/jXv/7Vbe/VSM/SqxLmkpISlJWVPfY1zs7O3D6loqIi+Pn5Yfz48QgPD29RjkNlWl2LYRikpaVx+6Dy8/Ph7+8PgUCA2bNnd+rqbkFBAW7cuPHYJlIMw6C8vJwLqDweD7a2trC3t1drL66mJSUl4datW/D29kZFRYVaDUwYhkF0dDTq6urg7e2N4cOHd+KIH62hoYH7nCsrKwEAffv2hbOzs1oVCCzLYvfu3Xj//fdx6tQp+Pr6anjEhJCuRLG+52JZFoWFhRCLxRCJRLhy5Qp8fHwgFAohEAgwaNCgTov1qmaeTk5Oj+y4rConVpVtNzQ0wMbGhpvA1XbzUvmp06jf9A70Zs7A3SWLUVJSAj6f3+7YWLdxE+RHIqA3dizMft3XSaN9vAcbhLIsC1NTU7i5uam9910ikSA4OBhbt27Ff/7zH0qWicb0qoS5PQoLCzFt2jTw+Xzs37//ocRC1QhEJpNxX5AbN26EWCymRiCdjGVZZGdnc6VceXl5mDZtGrcPytraWmNfgrdv30Z+fn67zipkWbZFZ0htlXLd78CBA2AYBoaGhnBxccGoUaPUSuIVCgVqa2u13qgF+PumOD09Hf369UNDQwM3G62aqGjL/nKWZfHzzz9j48aNOH78OKZMmdJFoyeEdAcU67svlmUhlUoRFRUFkUiE8+fPw9PTk0ueO1KS+6Dy8nKkpaXB1dUVAwcObPPP3b8Xt7a2ltuLa2dnp5XmpTWvrURz3DkAQPbuMPB9fWFkZNTu67BKJZS5edB1dQXvGe02YW1oaEBSUhLMzMygr6+P0tJSblHCzs4O1tbWbbqfSU9PR1BQEDZs2IB169Zp/R6G9C5PZcJcWFgIPz8/DBo0CL/88kuLAOrg4ADg75lINzc3zJw5E+vXr0dWVhZeeeUVfPXVV3TURBdSlRyJRCKIRCJkZGRg8uTJEAqFCA4Ohp2dnVpfivfv+/Hx8VG7/PtRpVz29vawsbHpslKurKws5OTkoG/fvpgwYYLWV7w7qrS0FBkZGRg+fDjs7e0B/F1qfv9stL6+fovzHx/8f8CyLPbt24d169bh6NGjmDZtmjbeCiFESyjW9xwsy6KsrAzR0dGIiIjAuXPn4ObmxpVtDxs2TO0EqKSkBJmZmXB3d4ejo6PaY1TtxS0uLkZ1dTUsLS25GNRVzUsV15JQvnUrKkaOhNPWLVpvmtpRqmMr+/TpAzc3N/B4PDAMg8rKyhaLEveXyLe2KJGVlYXZs2fjP//5D9555x1KlonGPZUJc3h4OJYuXdrqc/d/HBkZGVi1ahWSkpLQp08frFmzBuvXr++qYZIHsCyLW7ducWXbEokEvr6+XBMRR0fHNn1JsiyL3NxcrpSpPft+nnRdbZRyyeVySCQSmJiYYMSIEW1OllmW7ZZBpaysDOnp6fDw8OBuah+kVCq5EvmSkhJuNprH48HJyQmGhoY4dOgQ/v3vf0MkEiEgIKCL30Xrvv32W2zfvh1SqRSjRo3CN998g7Fjx2p7WIT0ShTreyaWZVFZWYmjR49CJBIhJiYGTk5OCAkJQWhoaLvinFQqRXZ2NkaMGMFNvmpCY2Nji61D5ubmsLOzg729vVorvm2hqr6rqqoCn89vc7Ks+r/e3eK9Klm2sbGBu7t7q+NjWRbV1dXcZ93Y2AgbGxuYmJjAwsICdnZ2yMnJwezZs/Hqq6/i/fff7xbvk2J97/NUJsyk52NZFn/99RfXRCQxMRGjR4/mZqMHDhzY6pcmwzC4fv06KisrwefzOy2wAV1TytXU1ASJRAIzMzMMHz68zTcR+fn5uHLlChwdHTF16tRuEWCA/0+Whw0bhr59+7bpZ+6fjd68eTPi4+Ph6uqK3Nxc/Prrr5g3b14nj7ptDh06hEWLFuG7777DuHHjsGPHDhw5cgR5eXmws7PT9vAIIaRbqq6uxvHjxyESiXD69Gn07duXS569vb0fGfcKCwuRl5fXodMV2kIul3Oxvry8HKamprC3t4ednZ3GJuQZhkF2djZqamrA5/OfeDSTivLOHdTMfwk8w2dgduQwdNRsnKlpjY2NkEgksLKyalf1gOq+SiQS4YMPPoC7uzsKCgrwj3/8A99++223qK6jWN87UcJMejyWZVFUVITIyEiIxWJcvHgRo0aN4vZBOTs7g8fjoaGhAfv27cOIESPaFXA0obVSLnt7e9ja2qpdUqUKOBYWFhg+fHi7kt4LFy6goKAAAPDiiy92iy6gqj1m7UmWH8QwDLZt24ZPPvkEDg4OKCkpwYwZMzB37lyEhISofX6zJowbNw5jxozBzp07ubEOGDAAa9aswYYNG7Q2LkII6Slqa2tx6tQpiMVinDhxAtbW1ggODkZoaCjGjBnDlevu27cPDg4O4PP5j2zm2RkUCgXXBbqsrAxGRkbcynNb+m60hmEYZGZmor6+Hnw+v10T7k2HDqP+nXcBACZh38LA37/dv1/TmpqakJycDEtLS3h4eKg9YX/u3DksWLAAZmZmXKfw0NBQzJ07F0OHDtXwqNuOYn3vRAlzN/LRRx/hxIkTSEtLg4GBAdch+H4FBQVYuXIl4uPjYWpqisWLF+OTTz7pFglPd8CyLEpKSrgmIvHx8Rg2bBhmzZqFkydPorm5GRcuXNDqec+aKOVqaGiARCKBtbW1Wnu7ysrKkJqain79+nWLY1MqKiqQmpra4T1mp06dwqJFixAeHo7nn38eeXl53ETKq6++iuXLl2tw1G0nl8thbGyMiIgICIVC7vHFixejsrIS0dHRWhkXIaTrUazXjIaGBpw9exYikQjHjx+HkZERgoODUVxcjNjYWJw+fRpeXl5aG9+DfTcMDAy4lWdzc/M2xW2GYZCRkYHGxkb4+Pi0uzqNqa5G/eYt4Bkawvi9reB14UJBa1RVcebm5u2e6L9fQUEBAgICEBQUhJ07d6KsrAzHjh1DZGQkLC0tsW+fdjp/U6zvvShh7ka2bNkCS0tL3L17Fz/++ONDQVSpVMLLywsODg7Yvn077t27h0WLFmHFihX4+OOPtTPobkzVzfrgwYN49913UVlZiSFDhmDu3LkIDQ2Fh4eH1st31Cnlamho4JpkPGrfT0+iSpbd3NzQr18/ta8TFxeHl156Cbt378aCBQtabQKmrc+qqKgI/fr1w5UrV1oca/XWW2/h/Pnz+P3337UyLkJI16NYr3lNTU2IjY3F22+/jaysLFhaWmLu3LkQCoWYPHmy1o+DUiqVKCsr4/pu6OrqchPljzqVgmEYpKeno6mpCXw+X+vvoaPkcjmSk5NhZmaGESNGqB2Pi4qKMHPmTEyfPh179ux56D6OYj3pDDRV2Y289957AP5uVNKas2fP4vr164iNjYW9vT28vLzwwQcfYP369di6datWjjjozng8Hnes0Pjx4/Hjjz8iLi4OIpEIfn5+6NevHwQCAUJDQ9U+hqmjDAwM0L9/f/Tv358r5ZLJZLh16xaMjIy45FlVylVfXw+JRAJbW1uuo2RPVllZidTUVAwdOrRDyfKFCxewYMECfPPNN60my0D3a3hCCHk6UazXPH19fRw/fhxVVVXIyspCUVERIiIisHz5cigUCgQHB0MgEMDPz69Lt2OpqBJkOzs7MAzDNa1MT0/nmlba29vDysoKOjo6UCqVSE9PR3Nzc69JliUSCUxNTTu0siyVSjF79mxMmjQJu3fvbvW+jWI96QyUMPcgiYmJ8PT0bNHpMSAgACtXrkR2dja8vb21OLruaeXKlXBycsKBAwdgYGCAl19+GS+//DJqampw8uRJiEQiBAYGok+fPlwTkdGjR2sledbX14ejoyMcHR1blHIlJSXBwMAAVlZWKCkpQd++fTF06NAeHxSqqqqQmpqKIUOGoH///mpf5/Lly3jhhRfwxRdfYMmSJd3yc1EdhSGTyVo8LpPJHtkJnBDydKJY334//fQT4uLicPHiRQwcOBAeHh7w9/fHzp07cenSJURERGDNmjWora3F7NmzIRQK8eyzz3Zq489H0dHRQZ8+fbgqMVXTyuzsbDAMAxsbG9TW1kJXVxc+Pj49vgxf3ZM8HlRcXIw5c+aAz+fjp59+avV4KW2jWN97ab+dHGkzqVT60LEIqr9LpVJtDKnbCwsLw2+//fbQjLyZmRnmz5+Pw4cPQyaT4YsvvkBZWRmEQiGGDRuGdevW4fLly1AqlVoZt56eHhwcHDBy5EhMnToVAwcOhFQqRXNzM2QyGf744w9UVFSgp+6oqKqqQkpKClxdXTFgwAC1r3Pt2jXMmzcPH3/8MVasWNEtk2Xg70oCPp+PuLg47jGGYRAXF9eibIsQQijWt9+SJUuQmJiIgQMHtnhcT08Pfn5+2LlzJ+7cuYMTJ07AwcEB69evx+DBg7F48WJERkairq5OK+PW0dGBtbU13N3dMXnyZHh6eqKiogL19fWora3F9evXIZPJtHYv0lEKhQIpKSkwNjbuULJcVlaGkJAQDBs2DHv37u22kwgU63svSpg72YYNG8Dj8R77Jzc3V9vD7LVsbGye+MVqbGyMuXPnYv/+/ZBKpdi1axfq6+vx4osvYujQoVi7di0SEhKgUCi6aNQt1dfX49atW3BycsK0adPg4eHBlWtduHABOTk5KCsrA8MwWhlfe1VXVyMlJQUuLi4dSpZTUlIQGhqKLVu2YNWqVd02WVZ544038P333+OXX35BTk4OVq5cibq6ukeeE0sI6Tko1muXnp7eE09B0NXVxcSJE/Hll1/i5s2biI2NhbOzM9577z04OTlhwYIFOHz4MKqrq7to1C0plUrcunULJiYmmDp1KkaPHg1jY2PcuHEDCQkJSE9Px71797R2L9JeCoUCEokEhoaG8PT0VDtZrqiogEAggJOTEw4ePNjty9Mp1vdO3XOKphd58803sWTJkse+xtnZuU3XcnBwwLVr11o8pir7oFIPzTA0NERwcDCCg4OhUCgQHx+PiIgILF26FAzDICgoCKGhoZg6dWqX7COrqamBRCLBwIEDuf8nrZVyZWVlgWVZ2Nraws7ODjY2NlpvaNaa6upqSCQSODs7P7QS0B4ZGRkICQnB+vXr8frrr3f7ZBkA5s+fj5KSEmzevBlSqRReXl44ffr0QytJhJCeh2J9z6Kjo4OxY8di7Nix+OSTT5CRkYGIiAhs27YNr732Gvz9/SEQCBAUFAQLC4tOjzEKhQKpqanQ09PDqFGjoKurC3Nzc5ibm8PFxQV1dXUoLi5Gfn4+srOzYWNjAzs7O9ja2nbLPe2qleVnnnkGI0eOVPt+pKqqCqGhobC3t8fhw4e75Xt9EMX63om6ZHdD4eHhWLt27UOdM0+dOoU5c+bg3r173OHne/bswbp161BcXKyVRhZPi+bmZly8eBFHjhxBdHQ06uvrERQUBIFAgGeffVbts5QfR5VcOjk5YfDgwY99LcuyqKqqgkwmQ3FxMRQKBZc8q/bUaJsq+XdycoKTk5Pa17l+/ToCAwOxZs0abN68uUcky4QQ8iCK9d0Py7K4fv06IiIiIBaLkZOTg2nTpkEgEGDOnDmwsbHReMxRJZcGBgYYOXLkE+N1fX09iouLIZPJUFNTAysrK66hWHf4v9Hc3IyUlBTo6+t3qKFqTU0NQkNDYWxsjGPHjmllvzkhKpQwdyMFBQUoLy/H0aNHsX37dly8eBEA4OrqClNTU+6oCUdHR2zbtg1SqRQLFy7E8uXL6aiJLqRUKnHlyhVEREQgKioKlZWVCAwMhFAoxIwZMzRyxrNqj6+zszMGDRrUrp9lWRY1NTVcQG1sbESfPn245Fkb5Uy1tbVITk7GoEGDnpj8P05ubi5mzZqF5cuX48MPP6RkmRDS41Cs7xlYlsWff/7JJc/p6emYPHkyBAIBgoODYW9v3+EYJJfLkZKSAkNDQ7VWYhsbG7lYX1VVBQsLCy551kaCqUqW718pV0ddXR2ee+458Hg8nDhxAqamphoeKSHtQwlzN7JkyRL88ssvDz0eHx8PPz8/AMCdO3ewcuVKJCQkwMTEBIsXL8ann37abRsg9HYMw+DatWtc8iyVSjFz5kwIhUIEBATAzMys3ddUHbXk4uLSobJl4O+AX1dXx60819XVdXkplypZvr+sXB03btxAYGAgFixYgG3btnXLknNCCHkSivU9D8uyuH37NkQiESIjI5GUlITx48dDIBBAIBDA0dGx3cmzqnu0sbFxh/b4qjQ1NXFHU1ZUVMDU1JQ7mtLExKRD126L5uZmpKamQkdHB15eXmonyw0NDXj++efR1NSE06dPq3UfRYimUcJMiIYwDIPU1FSIRCKIxWLcuXMH/v7+EAqFmD17NszNzZ8YUCsqKrijljrSEOtR6uvrueS5K0q56urqkJycjP79+8PFxUXt6+Tn53Or+Dt27KBkmRBCiFawLIu7d+9CLBZDLBbj8uXLGD16NJc8Dxo06ImxvqmpiTuXuCPdox9FoVBwyXNZWRlMTEy4WG9qaqrx6iylUonU1FTweLwOJctNTU146aWXUFFRgbNnz8LCwkKj4yREXZQwE9IJWJZFVlYWV8r1xx9/YPr06VwTEWtr64cCVnl5OdLS0uDm5oZ+/fp1+hgbGhq4gNoZpVyqZLlfv35wcXFRO0D/9ddfCAgIQGBgIHbt2kXJMiGEkG6BZVlIpVJERkZCJBLhwoULGDlyJIRCIQQCQauxr7GxERKJBBYWFvDw8Oj0mNbc3IySkhIUFxejtLQUhoaGXKxvy0T+k6iSZQDw9vZWO1mWy+VYuHAhCgsLERsbC2tr6w6NixBNooSZPNG3336L7du3QyqVYtSoUfjmm28wduxYbQ+rx2BZFnl5edzKc2ZmJiZPngyhUIjg4GDY2toiKioKJ0+exHvvvQdHR8cuH2NTUxOKi4tRXFyMiooKmJmZcQFVnVIuVbLs6OgIV1dXtQPyvXv3EBAQgClTpuD777/vFs3LCCGkN6JY3zEsy6K0tBRRUVEQiUSIj4+Hm5sblzy7u7vj1q1bePPNN/Huu+/Cx8eny/twKJVKlJWVQSaTobS0FHp6elyst7S0bPd4lEol0tLSwDAMfHx81I7RCoUCS5Yswc2bN3Hu3Dn06dNHresQ0lkoYSaPdejQISxatAjfffcdxo0bhx07duDIkSPIy8vjuneStmNZFrdu3UJERAQiIyMhkUgwZMgQ/Pnnn3jnnXfw3//+V+uNrORyOUpLS9Uu5aqvr0dycjL69u3boWRZKpVi1qxZGDt2LMLDwylZJoSQTkKxXrNYlkVFRQWOHj0KkUiEmJgY9O/fHzKZDGPHjoVYLNb6ecIMw6CsrAzFxcUoKSkBj8fjYr2VldUTV76VSiXS09OhVCrh7e2t9v765uZmrFixApmZmYiPj6fjl0i3RAkzeaxx48ZhzJgx2LlzJ4C/v2AHDBiANWvWYMOGDVoeXc/Gsix++OEHrF69Gk5OTrh58ybGjh3L7YMaMGCA1pPn9pZyNTQ0IDk5GXZ2dhg6dKja4y8pKcHs2bMxYsQI/Prrr9TohhBCOhHF+s6Vnp6OZ599FmZmZpDJZHB0dIRAIEBoaCi8vLy0vtWIYRhUVlZyPU5YluWOprSxsXlofAzDIC0tDc3NzfDx8VE7RiuVSqxcuRLXrl3D+fPn0bdvX028HUI0jhJm8khyuRzGxsaIiIiAUCjkHl+8eDEqKysRHR2tvcH1AiKRCIsWLcKvv/4KgUCAoqIironIpUuX4OXlxSXPzs7OWk+elUolSktLueRZVcplb28PCwsLNDY2aiRZLisrQ1BQEFxcXHD48GGtz8ITQkhvRrG+c/3555+YPn065s2bhy+//BJ1dXU4efIkxGIxTp48CWtra4SEhEAoFGLMmDFar6ZiWRZVVVVc8tzc3NziaEoej4f09HQoFIoOJcsMw2DNmjW4ePEi4uPjO6XRKSGaQgkzeaSioiL069cPV65cga+vL/f4W2+9hfPnz+P333/X4uh6NpZlMXfuXCxbtgxz5sx56Lni4mJuH1RCQgI8PDwgEAggFAo7lIxqSmulXEqlEtbW1vD09FQ74FdWVmLOnDlwdHSEWCzukmOvCCHkaUaxvnN99dVXuHfvHj777LOHYnd9fT3Onj0LkUiE48ePw8TEBCEhIRAIBPD19dV6dRXLsqiuruZ6nDQ2NkJPTw+6urrg8/lqNwhlGAZvvvkmzpw5g4SEBDg5OWl24IRoGCXM5JEoiHYulmWfmPiyLIvy8nJER0dDJBIhLi4Orq6uCAkJQWhoKIYNG6b1Uq6GhgZcu3YN+vr6UCgUTyzlepTq6moIBAJYWloiOjoahoaGnTxyQgghFOs7X1vifWNjI+Li4iASiXD06FHo6ekhODgYQqEQkyZN0nq1larBV21tLfT19VFfXw8bGxvY2dnB1ta2zRPcDMPg7bffRlRUFOLj4+Hq6trJIyek42hjIHmkPn36QFdXFzKZrMXjMpkMDg4OWhpV79GWVWIejwcbGxu88sorWLp0KaqqqnDs2DGIxWLs2LED/fv35/ZBjRw5ssuTZ9XxGLa2thg2bBiAv1eJi4uLkZuby5Vy2dvbw8bG5pErz7W1tXjuuedgYmKCqKgoSpYJIaSLUKzvfG2J94aGhggKCkJQUBAUCgUSEhIQERGBZcuWobm5GcHBwRAIBPDz8+vy6iuGYZCVlQWFQoEJEyZAX18fdXV1KC4uxt27d5GTkwMrKyuux8kzzzzzyOts2bKF6yJOyTLpKehAU/JIBgYG4PP5iIuL4x5jGAZxcXEtZqFJ1+DxeLC0tMTChQsRGRkJmUyG999/H3fu3EFAQAA8PT2xceNGXLt2DQzDdPp4mpqaIJFIYGVlhWHDhoHH44HH48HKygpubm6YNGkSfHx8YGhoiD///BMJCQlIT0/HvXv30NzczF2nvr4ezz//PPT09HD06FGNnAHdUR999BEmTJgAY2NjWFpatvqagoICBAUFwdjYGHZ2dli3bl2L90UIIT0BxfruR19fHzNmzMDu3btx9+5dREREwMTEBKtWrcLgwYOxYsUKHD9+HI2NjZ0+FlWyXF9fDx8fH26l28TEBIMHD8a4ceMwceJE9OnTB1KpFBcvXkRSUhIKCgpajI9lWXz88cfYv38/YmJi4Obm1uljbwuK96QtqCSbPNahQ4ewePFi7N69G2PHjsWOHTtw+PBh5ObmUuv/bqSurg6nT5+GWCzGiRMnYG5uzu2DGj9+vMabiKiSZQsLC3h4eLSptLy2tpbbBxUbG4sLFy5g1qxZOHv2LJqbm3H69GmYm5trdJzq2rJlCywtLXH37l38+OOPqKysbPG8UqmEl5cXHBwcsH37dty7dw+LFi3CihUr8PHHH2tn0IQQoiaK9T2DUqlEYmIiRCIRIiMjUV5ejsDAQAiFQsyYMQMmJiYa/X0syyIrKwu1tbXg8/ltWtluamriYv3t27fx6aefIjAwEA0NDThy5AjOnTuHkSNHanScHUHxnrQFJczkiXbu3Int27dDKpXCy8sLX3/9NcaNG6ftYZFHaGhoQExMDMRiMY4ePYpnnnkGwcHBCA0NxcSJEzvcREQulyM5ORnm5uYYPny4Wg3IcnNz8fPPP+Pnn39GXV0d/Pz8MH/+fAiFwm5VAhgeHo61a9c+FEBPnTqFOXPmoKioiLuZ/O6777B+/XqUlJRQszJCSI9Dsb5nYRgGSUlJXPJcVFSEmTNnQiAQYNasWTAzM+vQ9VmWRXZ2NqqrqzF69Gi14lp5eTn27t2LPXv24M6dOxgyZAhefvllzJ07V+37h85C8Z48DpVkkydavXo17ty5g6amJvz+++8UQLs5IyMjhISEIDw8HFKpFOHh4WBZFosXL4arqytWrVqF2NhYyOXydl9bLpdDIpHAzMysQ8HO2dkZ+fn5GDJkCFJSUhAcHIz9+/ejf//++Ne//qXWNbtSYmIiPD09W6y8BAQEoLq6GtnZ2VocGSGEqIdifc+io6ODcePGYdu2bcjLy8OlS5fg4eGBzz77DE5OTpg/fz5+/fVXVFZWor1rYyzL4vr166iurm7zynJrrKysYGBggMrKSsTGxmLLli1IS0vD2LFj4enpCYVCodZ1uxLFewJQ0y9CejUDAwMEBAQgICAAYWFhuHDhAo4cOYLXXnsNjY2NCAoKglAoxLRp057YaEuVLJuYmHQoWVYoFFi2bBny8/Nx7tw52NrawtvbG2+88Qbu3bsHqVSq1nW7klQqfahMUfX3njB+QgghvYeOjg68vb3h7e2NDz/8ENnZ2YiIiMDOnTuxevVqTJs2DQKBAHPmzIG1tfVj47cqWa6srMTo0aMf2cDrSViWxY8//ogPPvgAJ06cwKRJkwAA//jHP1BXV4fk5GStd/5uC4r3BKAVZkKeGnp6epg+fTrCwsLw119/ISoqClZWVnj99dcxePBgvPLKKzh69Cjq6+sf+lmFQoGUlBQYGxtjxIgRanfjbm5uxmuvvYacnBzExMTA1ta2xfN9+/aFt7e3Wtd+kg0bNnCNyR71Jzc3t1N+NyGEENIVeDweRowYga1btyItLQ0ZGRmYMmUKfvzxRzg7OyM4OBg//PADZDLZQyvPLMsiJycHFRUV4PP5HUqW9+7di02bNiE6OppLllVMTEwwdepUtd/jk1C8J5pGCTPpES5cuIDg4GA4OjqCx+MhKiqqxfMsy2Lz5s3o27cvjIyM4O/vjz///FM7g+0BdHV1MWXKFHz99dfIz8/H6dOn0a9fP2zatAlOTk5YuHAhIiIiUFtbi5KSEkyfPh0ymQyenp5qJ8tKpRKrV6+GRCJBbGxsl+9VfvPNN5GTk/PYP87Ozm26loODQ6tHsKieI4QQ0n4U6zWLx+PBzc0NGzduRFJSEnJzcxEYGIiDBw9i6NChmDVrFsLCwlBYWAilUomlS5fi8OHDGD16tNrHO7Isi4MHD2LdunWIjIyEn5+fZt9UG1C8J5pGCTPpEerq6jBq1Ch8++23rT6/bds2fP311/juu+/w+++/w8TEBAEBAV1y5EJPp6OjA19fX3zxxRfc8U9Dhw7FRx99hEGDBsHT0xO1tbUYP3682mXYDMNg7dq1uHz5MmJjY+Ho6Kjhd/Fktra2cHd3f+yftu7T8vX1RWZmJoqLi7nHYmJiYG5uDg8Pj856C4QQ0qtRrO88PB4PLi4ueOutt3DlyhXcvHkTc+fORXR0NNzd3eHi4oLTp09j2rRpaq8sA4BIJMLatWtx+PBh+Pv7a/AdtB3Fe6Jp1CWb9Dg8Hg+RkZEQCoUA/p7NdHR0xJtvvon//ve/AICqqirY29sjPDwcL774ohZH23NVVlZi8uTJaGxshL6+Pm7evInp06dz+6CsrKzalEAzDIN169bh5MmTSEhIwODBg7tg9B1TUFCA8vJyHD16FNu3b8fFixcBAK6urjA1NeWOmXB0dMS2bdsglUqxcOFCLF++nI6ZIIQQDaBY3zUYhsGrr74KsViMoUOHQiKRYNSoURAIBBAIBHBxcWnzZHl0dDSWL1+OgwcPIiQkpJNHrhkU70lb0Aoz6fFu374NqVTaYibTwsIC48aNQ2JiohZH1nPV1NRg9uzZGDBgALKyspCdnY20tDRMmDABe/bsgbOzMwQCAX766SeUlJQ8sgMnwzDYuHEjjh07htjY2B6RLAPA5s2b4e3tjS1btqC2tpZrppKcnAzg75L248ePQ1dXF76+vnj55ZexaNEivP/++1oeOSGE9E4U6zWPZVmsW7cOZ8+eRXJyMhITE1FUVIRXX30Vly5dwujRozFhwgR8+umnyM3NfWy37RMnTmD58uXYu3dvj0mWAYr3pG1ohZn0OA/OOl+5cgUTJ05EUVER+vbty73uhRdeAI/Hw6FDh7Q00p4rNTUVH3/8Mfbt2/fQPiaWZXHz5k1EREQgMjISKSkpmDBhAoRCIUJCQuDg4AAejweWZbF161bs378f8fHxcHd319K7IYQQ0tNQrO98tbW1ePHFF7Fjxw64urq2eI5lWVRUVCA6OhpisRgxMTFwcXFBSEgIQkND4eHhwfU0iYmJwYIFC/DDDz/gpZde0sZbIaRT0bFShJCHeHt748iRI60+x+Px4Orqig0bNmD9+vW4c+cOxGIxRCIR1q1bh3HjxkEgEODu3bv47bffcO7cOUqWCSGEkG7G1NQUx48fb/U5Ho8Ha2trLF26FEuXLkVVVRWOHTsGsVgMPz8/9OvXDwKBAAMHDsTGjRsRFhZGZfGk16KSbNLjqboUttbFkDoYdi4ejwcnJye88cYbuHjxIvLz8zF//nwcOXIEO3fuxJkzZzBixAhtD5MQQkgPR7FeuywsLPDyyy9DLBZDJpPhww8/xJ07d7B27Vq8/vrrWLhwodqNQQnp7ihhJj3e4MGD4eDggLi4OO6x6upq/P777/D19dXiyJ4uPB4P/fv3x7///W9cu3YNhYWFnXamMiGEkKcLxfruw8zMjJscLyoqwnvvvUfJMunVqCSb9Ai1tbW4ceMG9/fbt28jLS0N1tbWGDhwINauXYsPP/wQQ4YMweDBg/Huu+/C0dGR2/tEuhaPx2uxx4wQQgh5Eor1PQ+t7pOnATX9Ij1CQkICpk2b9tDjixcvRnh4OFiWxZYtW7Bnzx5UVlZi0qRJ2LVrF4YOHaqF0RJCCCGkvSjWE0K6I0qYCSGEEEIIIYSQVtAeZkIIIYQQQgghpBWUMBNCCCGEEEIIIa2ghJmQDvjkk08wZswYmJmZwc7ODkKhEHl5eS1e09jYiFWrVsHGxgampqZ47rnnHjoWgxBCCCHdE8V6Qp5ulDAT0gHnz5/HqlWrcPXqVcTExEChUGDmzJmoq6vjXvP666/j2LFjOHLkCM6fP4+ioiLMnTtXi6MmhBBCSFtRrCfk6UZNvwjRoJKSEtjZ2eH8+fOYMmUKqqqqYGtriwMHDmDevHkAgNzcXAwbNgyJiYkYP368lkdMCCGEkPagWE/I04VWmAnRoKqqKgCAtbU1AEAikUChUMDf3597jbu7OwYOHIjExEStjLE3yc/Px7JlyzB48GAYGRnBxcUFW7ZsgVwub/G6jIwMTJ48GYaGhhgwYAC2bdumpRETQgjp6SjWdy2K9UTb9LQ9AEJ6C4ZhsHbtWkycOBEjRowAAEilUhgYGMDS0rLFa+3t7SGVSrUwyt4lNzcXDMNg9+7dcHV1RVZWFlasWIG6ujp8/vnnAIDq6mrMnDkT/v7++O6775CZmYlXXnkFlpaWePXVV7X8DgghhPQkFOu7HsV6om2UMBOiIatWrUJWVhYuXbqk7aE8NQIDAxEYGMj93dnZGXl5eQgLC+OC6K+//gq5XI6ffvoJBgYGGD58ONLS0vDll19SECWEENIuFOu7HsV6om1Ukk2IBqxevRrHjx9HfHw8+vfvzz3u4OAAuVyOysrKFq+XyWRwcHDo4lE+HaqqqrgyOQBITEzElClTYGBgwD0WEBCAvLw8VFRUaGOIhBBCeiCK9d0HxXrSlShhJqQDWJbF6tWrERkZiXPnzmHw4MEtnufz+dDX10dcXBz3WF5eHgoKCuDr69vVw+31bty4gW+++Qb//Oc/ucekUins7e1bvE71dyqVI4QQ8iQU67sXivWkq1HCTEgHrFq1Cvv378eBAwdgZmYGqVQKqVSKhoYGAICFhQWWLVuGN954A/Hx8ZBIJFi6dCl8fX2pa+ZjbNiwATwe77F/cnNzW/xMYWEhAgMD8fzzz2PFihVaGjkhhJDehmJ956BYT3oKOlaKkA7g8XitPv7zzz9jyZIlAIDGxka8+eabOHjwIJqamhAQEIBdu3ZRmdZjlJSUoKys7LGvcXZ25kqvioqK4Ofnh/HjxyM8PBw6Ov8/F7ho0SJUV1cjKiqKeyw+Ph7Tp09HeXk5rKysOuU9EEII6R0o1ncOivWkp6CEmRDSoxUWFmLatGng8/nYv38/dHV1WzwfFhaGTZs2QSaTQV9fHwCwceNGiMXih2auCSGEENL9UKwn2kQJMyGkxyosLISfnx8GDRqEX375pUUAVc3qV1VVwc3NDTNnzsT69euRlZWFV155BV999RV1ziSEEEK6OYr1RNsoYSaE9Fjh4eFYunRpq8/d/9WWkZGBVatWISkpCX369MGaNWuwfv36rhomIYQQQtREsZ5oGyXMhPRiYWFhCAsLQ35+PgBg+PDh2Lx5M2bNmgXg//dc/fbbby32XD3YaZIQQggh3RPFekI6FyXMhPRix44dg66uLoYMGQKWZfHLL79g+/btSE1NxfDhw7Fy5UqcOHEC4eHhsLCwwOrVq6Gjo4PLly9re+iEEEIIaQOK9YR0LkqYCXnKWFtbY/v27Zg3bx5sbW1x4MABzJs3DwCQm5uLYcOGITExkY7CIIQQQnooivWEaA6dw0zIU0KpVOK3335DXV0dfH19IZFIoFAo4O/vz73G3d0dAwcORGJiohZHSgghhBB1UKwnRPP0tD0AQkjnyszMhK+vLxobG2FqaorIyEh4eHggLS0NBgYGsLS0bPF6e3t7SKVS7QyWEEIIIe1GsZ6QzkMJMyG9nJubG9LS0lBVVYWIiAgsXrwY58+f1/awCCGEEKIhFOsJ6TyUMBPSyxkYGMDV1RUAwOfzkZSUhP/5n//B/PnzIZfLUVlZ2WLmWSaTcecaEkIIIaT7o1hPSOehPcyEPGUYhkFTUxP4fD709fURFxfHPZeXl4eCggL4+vpqcYSEEEII6QiK9YRoDq0wE9KLvf3225g1axYGDhyImpoaHDhwAAkJCThz5gwsLCywbNkyvPHGG7C2toa5uTnWrFkDX19f6ppJCCGE9BAU6wnpXJQwE9KLFRcXY9GiRbh37x4sLCwwcuRInDlzBjNmzAAAfPXVV9DR0cFzzz2HpqYmBAQEYNeuXVoeNSGEEELaimI9IZ2LzmEmhBBCCCGEEEJaQXuYCSGEEEIIIYSQVlDCTAghhBBCCCGEtIISZkIIIYQQQgghpBWUMBNCCCGEEEIIIa2ghJkQQgghhBBCCGkFJcyEEEIIIYQQQkgrKGEmhBBCCCGEEEJaQQkzIYQQQgghhBDSCkqYCSGEEEIIIYSQVlDCTAghhBBCCCGEtIISZkIIIYQQQgghpBWUMBNCCCGEEEIIIa34X7HjrV1AEQ35AAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Lets setup the boundary conditions\n", + "\n", + "\n", + "def get_boundary_masks(mesh: dict, Lx: float, Lz: float):\n", + " \"\"\"Get boundary condition masks for the adaptive mesh.\n", + "\n", + " Args:\n", + " mesh: Dictionary containing 'points' array.\n", + " Lx: Size of the domain in x-direction.\n", + " Lz: Size of the domain in z-direction.\n", + "\n", + " Returns:\n", + " dirichlet_mask: Boolean array for Dirichlet boundary condition.\n", + " van_neumann_mask: Boolean array for Van Neumann boundary condition.\n", + " \"\"\"\n", + " pts = mesh[\"points\"]\n", + "\n", + " dirichlet_mask = pts[:, 0] <= -Lx / 2 + Lx / 10\n", + " van_neumann_mask = jnp.logical_and(\n", + " jnp.isclose(pts[:, 0], Lx / 2, atol=Lx / 5),\n", + " jnp.isclose(pts[:, 2], -Lz / 2, atol=Lz / 3),\n", + " )\n", + "\n", + " return dirichlet_mask, van_neumann_mask\n", + "\n", + "\n", + "dirichlet_mask, van_neumann_mask = get_boundary_masks(adaptive_mesh, Lx, Lz)\n", + "\n", + "fig, axs = plt.subplots(1, 2, subplot_kw={\"projection\": \"3d\"}, figsize=(12, 6))\n", + "# set the colormap to Set1\n", + "plt.suptitle(\"Boundary Conditions\")\n", + "# remove the axis ticks\n", + "colors = jnp.where(dirichlet_mask[: adaptive_mesh[\"n_points\"]], 0.1, 0.2)\n", + "\n", + "pts = adaptive_mesh[\"points\"][: adaptive_mesh[\"n_points\"]]\n", + "\n", + "axs[0].scatter(\n", + " pts[:, 0],\n", + " pts[:, 1],\n", + " pts[:, 2],\n", + " c=jnp.where(dirichlet_mask[: adaptive_mesh[\"n_points\"]], 0.1, 0.2),\n", + " s=1,\n", + " alpha=1.0,\n", + " cmap=\"Set1\",\n", + ")\n", + "axs[0].set_title(\"Dirichlet Boundary (x = -Lx/2)\")\n", + "\n", + "axs[1].scatter(\n", + " pts[:, 0],\n", + " pts[:, 1],\n", + " pts[:, 2],\n", + " c=jnp.where(van_neumann_mask[: adaptive_mesh[\"n_points\"]], 0.1, 0.2),\n", + " s=1,\n", + " alpha=1.0,\n", + " cmap=\"Set1\",\n", + ")\n", + "axs[1].set_title(\"Van Neumann Boundary (x = Lx/2)\")\n", + "\n", + "# convert to int arrays for tesseract input\n", + "dirichlet_mask = dirichlet_mask.astype(jnp.int32)\n", + "van_neumann_mask = van_neumann_mask.astype(jnp.int32)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "4f9e6ab6", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# lets make a scatter plot of the mesh cell values as colors\n", + "fig, ax = plt.subplots(1, 1, figsize=(8, 6), subplot_kw={\"projection\": \"3d\"})\n", + "pts_coords = mesher_out[\"mesh\"][\"points\"][: mesher_out[\"mesh\"][\"n_points\"]]\n", + "hex_cells = mesher_out[\"mesh\"][\"faces\"][: mesher_out[\"mesh\"][\"n_faces\"]]\n", + "center_points = jnp.mean(pts_coords[hex_cells], axis=1)\n", + "rho_mesh = mesher_out[\"mesh_cell_values\"][: mesher_out[\"mesh\"][\"n_faces\"]]\n", + "scat = ax.scatter(\n", + " center_points[:, 0],\n", + " center_points[:, 1],\n", + " center_points[:, 2],\n", + " c=rho_mesh,\n", + " s=20,\n", + " # alpha=rho+0.3,\n", + " alpha=0.5,\n", + " cmap=\"viridis\",\n", + ")\n", + "# colorbar\n", + "cbar = plt.colorbar(scat, ax=ax, pad=0.1)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "80e15782", + "metadata": {}, + "outputs": [], + "source": [ + "fem_tess = Tesseract.from_tesseract_api(\"fem_tess/tesseract_api.py\")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "5af9fd28", + "metadata": {}, + "outputs": [], + "source": [ + "# compliance = apply_tesseract(\n", + "# fem_tess,\n", + "# {\n", + "# \"rho\": jnp.expand_dims(mesher_out[\"mesh_cell_values\"], axis=-1),\n", + "# \"hex_mesh\": adaptive_mesh,\n", + "# \"dirichlet_mask\": dirichlet_mask,\n", + "# \"dirichlet_values\": jnp.array([0.0]),\n", + "# \"van_neumann_mask\": van_neumann_mask,\n", + "# \"van_neumann_values\": jnp.array([[0.0, 0.0, 10.0]]),\n", + "# },\n", + "# )[\"compliance\"]\n", + "# print(f\"Compliance: {compliance:.4f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "86af5964", + "metadata": {}, + "outputs": [], + "source": [ + "from typing import TypeVar\n", + "\n", + "T = TypeVar(\"T\")\n", + "\n", + "\n", + "def stop_grads_int(x: T) -> T:\n", + " \"\"\"Stops gradient computation.\n", + "\n", + " We cannot use jax.lax.stop_gradient directly because Tesseract meshes are\n", + " nested dictionaries with arrays and integers, and jax.lax.stop_gradient\n", + " does not support integers.\n", + "\n", + " Args:\n", + " x: Input value.\n", + "\n", + " Returns:\n", + " Value with stopped gradients.\n", + " \"\"\"\n", + "\n", + " def stop(x):\n", + " return jax._src.ad_util.stop_gradient_p.bind(x)\n", + "\n", + " return jax.tree_util.tree_map(stop, x)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "bef46c77", + "metadata": {}, + "outputs": [], + "source": [ + "# def loss(\n", + "# cell_values: jnp.ndarray,\n", + "# mesh: dict,\n", + "# ) -> float:\n", + "# \"\"\"Compute structural compliance for given bar parameters.\n", + "\n", + "# Args:\n", + "# cell_values: Material density values for each mesh cell.\n", + "# mesh: Mesh dictionary.\n", + "\n", + "# Returns:\n", + "# Structural compliance (scalar). Lower values indicate better performance.\n", + "# \"\"\"\n", + "# mesh = stop_grads_int(mesh)\n", + "\n", + "# dirichlet_mask, van_neumann_mask = get_boundary_masks(mesh, Lx, Lz)\n", + "\n", + "# van_neumann_mask = jax.lax.stop_gradient(van_neumann_mask)\n", + "# dirichlet_mask = jax.lax.stop_gradient(dirichlet_mask)\n", + "# dirichlet_values = jnp.array([0.0])\n", + "# van_neumann_values = jnp.array([[0.0, 0.0, Lz]])\n", + "\n", + "# # Instead of passing all inputs and trying to stop_gradient on them,\n", + "# # we need to wrap the tesseract call to only allow gradients w.r.t. rho\n", + "# c = apply_tesseract(\n", + "# fem_tess,\n", + "# {\n", + "# \"rho\": cell_values,\n", + "# \"hex_mesh\": mesh,\n", + "# \"dirichlet_mask\": dirichlet_mask,\n", + "# \"dirichlet_values\": dirichlet_values,\n", + "# \"van_neumann_mask\": van_neumann_mask,\n", + "# \"van_neumann_values\": van_neumann_values,\n", + "# },\n", + "# )[\"compliance\"]\n", + "\n", + "# return c" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "b24121ef", + "metadata": {}, + "outputs": [], + "source": [ + "# # get the gradient of the loss w.r.t. rho\n", + "# grad_loss = jax.grad(loss)\n", + "# grad = grad_loss(\n", + "# jnp.expand_dims(mesher_out[\"mesh_cell_values\"], axis=-1), adaptive_mesh\n", + "# )\n", + "# print(\"Grad shape:\", grad.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "a00e877d", + "metadata": {}, + "outputs": [], + "source": [ + "# # print a 3D point cloud of the gradient field\n", + "# fig, ax = plt.subplots(1, 1, subplot_kw={\"projection\": \"3d\"}, figsize=(8, 8))\n", + "# pts_coords = mesher_out[\"mesh\"][\"points\"][: mesher_out[\"mesh\"][\"n_points\"]]\n", + "# hex_cells = mesher_out[\"mesh\"][\"faces\"][: mesher_out[\"mesh\"][\"n_faces\"]]\n", + "# voxel_center_points = jnp.mean(pts_coords[hex_cells], axis=1)\n", + "# print(\"Voxel center points shape:\", voxel_center_points.shape)\n", + "# print(mesher_out[\"mesh\"][\"n_faces\"])\n", + "# sc = ax.scatter(\n", + "# voxel_center_points[:, 0],\n", + "# voxel_center_points[:, 1],\n", + "# voxel_center_points[:, 2],\n", + "# c=grad[: mesher_out[\"mesh\"][\"n_faces\"], 0],\n", + "# cmap=\"viridis\",\n", + "# alpha=1.0,\n", + "# )\n", + "# # lets add a colorbar\n", + "# plt.colorbar(sc, ax=ax, label=\"Gradient of Compliance w.r.t. rho\")" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "4c2e42b3", + "metadata": {}, + "outputs": [], + "source": [ + "# max_points = 9000\n", + "# max_cells = 9000\n", + "\n", + "\n", + "# def loss(\n", + "# rho: jnp.ndarray,\n", + "# ) -> float:\n", + "# \"\"\"Compute structural compliance for given bar parameters.\n", + "\n", + "# Args:\n", + "# rho: Bar parameter array with shape (n_chains, n_nodes, 3).\n", + "\n", + "# Returns:\n", + "# Structural compliance (scalar). Lower values indicate better performance.\n", + "# \"\"\"\n", + "# sizing = sizing_field(\n", + "# sdf, min_size=sizing_min, max_size=sizing_max, scale=sizing_scale\n", + "# )\n", + "\n", + "# sizing = jax.lax.stop_gradient(sizing)\n", + "\n", + "# mesher_out = apply_tesseract(\n", + "# mesher,\n", + "# {\n", + "# \"domain_size\": [Lx, Ly, Lz],\n", + "# \"sizing_field\": sizing, # jnp.ones_like(sdf) * (Lx / 10),\n", + "# \"field_values\": rho,\n", + "# \"max_subdivision_levels\": 5,\n", + "# \"max_points\": max_points,\n", + "# \"max_cells\": max_cells,\n", + "# },\n", + "# )\n", + "\n", + "# mesh = stop_grads_int(mesher_out[\"mesh\"])\n", + "\n", + "# dirichlet_mask, van_neumann_mask = get_boundary_masks(mesh, Lx, Lz)\n", + "\n", + "# van_neumann_mask = jax.lax.stop_gradient(van_neumann_mask)\n", + "# dirichlet_mask = jax.lax.stop_gradient(dirichlet_mask)\n", + "# dirichlet_values = jnp.array([0.0])\n", + "# van_neumann_values = jnp.array([[0.0, 0.0, 10.0]])\n", + "\n", + "# # Instead of passing all inputs and trying to stop_gradient on them,\n", + "# # we need to wrap the tesseract call to only allow gradients w.r.t. rho\n", + "# c = apply_tesseract(\n", + "# fem_tess,\n", + "# {\n", + "# \"rho\": jnp.expand_dims(mesher_out[\"mesh_cell_values\"], axis=-1),\n", + "# \"hex_mesh\": mesh,\n", + "# \"dirichlet_mask\": dirichlet_mask,\n", + "# \"dirichlet_values\": dirichlet_values,\n", + "# \"van_neumann_mask\": van_neumann_mask,\n", + "# \"van_neumann_values\": van_neumann_values,\n", + "# },\n", + "# )[\"compliance\"]\n", + "\n", + "# return c" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "6cda0f6f", + "metadata": {}, + "outputs": [], + "source": [ + "# # get grads of loss w.r.t. rho\n", + "# grad_loss = jax.grad(loss)\n", + "# print(rho.shape)\n", + "# grad = grad_loss(rho)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "f288b441", + "metadata": {}, + "outputs": [], + "source": [ + "# # plot the grad field\n", + "# plot_grid(grad, Lx, Ly, Lz, Nx, Ny, Nz)\n", + "# print(\"Grad min:\", jnp.min(grad), \"Grad max:\", jnp.max(grad))" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "701f3e71", + "metadata": {}, + "outputs": [], + "source": [ + "from jax import custom_vjp\n", + "\n", + "grad_storage = {}\n", + "\n", + "\n", + "def store_values(x, x_dot, hash_val: int):\n", + " global grad_storage\n", + " print(\"Storing values in hash\", hash_val)\n", + " grad_storage[int(hash_val)] = (x, x_dot)\n", + "\n", + "\n", + "@custom_vjp\n", + "def identity_and_store_grads(x, hash_val: int):\n", + " return x\n", + "\n", + "\n", + "def identity_fwd(x, hash_val):\n", + " return x, (x, hash_val)\n", + "\n", + "\n", + "def identity_bwd(residuals, g):\n", + " x, hash_val = residuals\n", + " jax.debug.callback(store_values, x, g, hash_val, ordered=False)\n", + " return (g, None)\n", + "\n", + "\n", + "identity_and_store_grads.defvjp(identity_fwd, identity_bwd)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "18aa327a", + "metadata": {}, + "outputs": [], + "source": [ + "@jax.custom_gradient\n", + "def gradient_clipping(x):\n", + " return x, lambda g: (jnp.clip(g, -1.0, 1.0))" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "09825bdd", + "metadata": {}, + "outputs": [], + "source": [ + "max_points = 40000\n", + "max_cells = 40000\n", + "\n", + "\n", + "def loss(\n", + " params: jnp.ndarray,\n", + " iteration: int = 0,\n", + ") -> tuple[float, dict]:\n", + " \"\"\"Compute structural compliance for given bar parameters.\n", + "\n", + " Args:\n", + " params: Geometry parameter array.\n", + " iteration: Current iteration number.\n", + "\n", + " Returns:\n", + " Structural compliance (scalar). Lower values indicate better performance.\n", + " \"\"\"\n", + " sdf = identity_and_store_grads(params, iteration + 0)\n", + " design_out = apply_tesseract(\n", + " design_tess,\n", + " {\n", + " \"differentiable_parameters\": params,\n", + " **design_inputs,\n", + " },\n", + " )\n", + "\n", + " sdf = design_out[\"sdf\"]\n", + "\n", + " sdf = gradient_clipping(sdf)\n", + "\n", + " sdf = identity_and_store_grads(sdf, iteration + 1000)\n", + "\n", + " # Convert SDF to material density distribution\n", + " rho_grid = sdf_to_rho(sdf, scale=rho_scale, offset=rho_offset)\n", + "\n", + " rho_grid = identity_and_store_grads(rho_grid, iteration + 2000)\n", + "\n", + " sizing = sizing_field(\n", + " sdf, min_size=sizing_min, max_size=sizing_max, scale=sizing_scale\n", + " )\n", + "\n", + " sizing = jax.lax.stop_gradient(sizing)\n", + "\n", + " mesher_out = apply_tesseract(\n", + " mesher,\n", + " {\n", + " \"domain_size\": [Lx, Ly, Lz],\n", + " # \"sizing_field\": sizing, # jnp.ones_like(sdf) * (Lx / 10),\n", + " \"sizing_field\": jnp.ones_like(sdf) * sizing_min,\n", + " \"field_values\": rho_grid,\n", + " \"max_subdivision_levels\": 6,\n", + " \"max_points\": max_points,\n", + " \"max_cells\": max_cells,\n", + " },\n", + " )\n", + "\n", + " rho_cell = jnp.expand_dims(mesher_out[\"mesh_cell_values\"], axis=-1)\n", + " print(rho_cell)\n", + " rho_cell = identity_and_store_grads(rho_cell, iteration + 3000)\n", + "\n", + " mesh = stop_grads_int(mesher_out[\"mesh\"])\n", + "\n", + " dirichlet_mask, van_neumann_mask = get_boundary_masks(mesh, Lx, Lz)\n", + "\n", + " van_neumann_mask = jax.lax.stop_gradient(van_neumann_mask)\n", + " dirichlet_mask = jax.lax.stop_gradient(dirichlet_mask)\n", + " dirichlet_values = jnp.array([0.0])\n", + " van_neumann_values = jnp.array([[0.0, 0.0, Lz]])\n", + "\n", + " # Instead of passing all inputs and trying to stop_gradient on them,\n", + " # we need to wrap the tesseract call to only allow gradients w.r.t. rho\n", + " c = apply_tesseract(\n", + " fem_tess,\n", + " {\n", + " \"rho\": rho_cell,\n", + " \"hex_mesh\": mesh,\n", + " \"dirichlet_mask\": dirichlet_mask,\n", + " \"dirichlet_values\": dirichlet_values,\n", + " \"van_neumann_mask\": van_neumann_mask,\n", + " \"van_neumann_values\": van_neumann_values,\n", + " },\n", + " )[\"compliance\"]\n", + "\n", + " # lets store all intermediate results in a dictionary to return\n", + " # for visualization purposes\n", + " surface_mesh = {\n", + " \"points\": design_out[\"mesh\"][\"points\"][: design_out[\"mesh\"][\"n_points\"]],\n", + " \"faces\": design_out[\"mesh\"][\"faces\"][: design_out[\"mesh\"][\"n_faces\"]],\n", + " }\n", + "\n", + " hex_mesh = {\n", + " \"points\": mesher_out[\"mesh\"][\"points\"][: mesher_out[\"mesh\"][\"n_points\"]],\n", + " \"faces\": mesher_out[\"mesh\"][\"faces\"][: mesher_out[\"mesh\"][\"n_faces\"]],\n", + " \"rho\": mesher_out[\"mesh_cell_values\"][: mesher_out[\"mesh\"][\"n_faces\"]],\n", + " }\n", + "\n", + " print(\n", + " f\"max points : {mesher_out['mesh']['n_points']}, max cells: {mesher_out['mesh']['n_faces']}\"\n", + " )\n", + "\n", + " return c, {\n", + " \"sdf\": sdf,\n", + " \"rho_grid\": rho_grid,\n", + " \"rho_cell\": rho_cell,\n", + " \"sizing\": sizing,\n", + " \"hex_mesh\": hex_mesh,\n", + " \"surface_mesh\": surface_mesh,\n", + " }" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "0c19654f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.4 0.4 0. 0.49999997 0.0621019 0.56210184\n", + " 0.12579617 0.62579614 0.18789807 0.68789804 0.24999999 0.74999994\n", + " 0.3121019 0.81369424 0.37579614 0.8757961 0.43789804 0.937898 ]\n", + "Starting Jacobian precomputation thread...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-17 15:03:42][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-17 15:03:42][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-17 15:03:42][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "LinearizeTracer\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-17 15:03:48][DEBUG] jax_fem: Done pre-computations, took 6.057549953460693 [s]\n", + "[11-17 15:03:48][INFO] jax_fem: Solving a problem with 32768 cells, 38025x3 = 114075 dofs.\n", + "[11-17 15:03:48][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-17 15:03:50][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-17 15:03:50][DEBUG] jax_fem: Start timing\n", + "[11-17 15:03:50][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-17 15:03:51][DEBUG] jax_fem: Function split_and_compute_cell took 0.7136 seconds\n", + "[11-17 15:03:53][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-17 15:03:53][DEBUG] jax_fem: Before, l_2 res = 342.4178934181307, relative l_2 res = 1.0\n", + "[11-17 15:03:53][DEBUG] jax_fem: Solving linear system...\n", + "[11-17 15:03:53][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n", + "[11-17 15:06:23][DEBUG] jax_fem: Scipy Solver - Finished solving, linear solve res = 4.116186115114194e-07\n", + "[11-17 15:06:23][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-17 15:06:23][DEBUG] jax_fem: Function split_and_compute_cell took 0.2215 seconds\n", + "[11-17 15:06:23][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-17 15:06:24][DEBUG] jax_fem: l_2 res = 4.121471168758109e-07, relative l_2 res = 1.2036377911259825e-09\n", + "[11-17 15:06:24][INFO] jax_fem: Solve took 153.7966628074646 [s]\n", + "[11-17 15:06:24][INFO] jax_fem: max of dofs = 8.939142962978792\n", + "[11-17 15:06:24][INFO] jax_fem: min of dofs = -110.80395988811222\n", + "[11-17 15:06:26][DEBUG] jax_fem: Computing shape function values, gradients, etc.\n", + "[11-17 15:06:26][DEBUG] jax_fem: ele_type = HEX8, quad_points.shape = (num_quads, dim) = (8, 3)\n", + "[11-17 15:06:26][DEBUG] jax_fem: face_quad_points.shape = (num_faces, num_face_quads, dim) = (6, 4, 3)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "max points : LinearizeTracer, max cells: LinearizeTracer\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[11-17 15:06:32][DEBUG] jax_fem: Done pre-computations, took 6.263654947280884 [s]\n", + "[11-17 15:06:32][INFO] jax_fem: Solving a problem with 32768 cells, 38025x3 = 114075 dofs.\n", + "[11-17 15:06:32][INFO] jax_fem: Element type is HEX8, using 8 quad points per element.\n", + "[11-17 15:06:35][DEBUG] jax_fem: Calling the row elimination solver for imposing Dirichlet B.C.\n", + "[11-17 15:06:35][DEBUG] jax_fem: Start timing\n", + "[11-17 15:06:35][DEBUG] jax_fem: Computing cell Jacobian and cell residual...\n", + "[11-17 15:06:36][DEBUG] jax_fem: Function split_and_compute_cell took 0.7195 seconds\n", + "[11-17 15:06:37][DEBUG] jax_fem: Creating sparse matrix with scipy...\n", + "[11-17 15:06:38][DEBUG] jax_fem: Before, l_2 res = 342.4178934181307, relative l_2 res = 1.0\n", + "[11-17 15:06:38][DEBUG] jax_fem: Solving linear system...\n", + "[11-17 15:06:38][DEBUG] jax_fem: Scipy Solver - Solving linear system with UMFPACK\n" + ] + }, + { + "ename": "JaxRuntimeError", + "evalue": "INTERNAL: CpuCallback error calling callback: Traceback (most recent call last):\n File \"\", line 198, in _run_module_as_main\n File \"\", line 88, in _run_code\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/ipykernel_launcher.py\", line 18, in \n File \"/anaconda/envs/fem/lib/python3.13/site-packages/traitlets/config/application.py\", line 1075, in launch_instance\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/ipykernel/kernelapp.py\", line 758, in start\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/tornado/platform/asyncio.py\", line 211, in start\n File \"/anaconda/envs/fem/lib/python3.13/asyncio/base_events.py\", line 683, in run_forever\n File \"/anaconda/envs/fem/lib/python3.13/asyncio/base_events.py\", line 2050, in _run_once\n File \"/anaconda/envs/fem/lib/python3.13/asyncio/events.py\", line 89, in _run\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/ipykernel/kernelbase.py\", line 701, in shell_main\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/ipykernel/kernelbase.py\", line 469, in dispatch_shell\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/ipykernel/ipkernel.py\", line 379, in execute_request\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/ipykernel/kernelbase.py\", line 899, in execute_request\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/ipykernel/ipkernel.py\", line 471, in do_execute\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/ipykernel/zmqshell.py\", line 632, in run_cell\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/IPython/core/interactiveshell.py\", line 3116, in run_cell\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/IPython/core/interactiveshell.py\", line 3171, in _run_cell\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/IPython/core/async_helpers.py\", line 128, in _pseudo_sync_runner\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/IPython/core/interactiveshell.py\", line 3394, in run_cell_async\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/IPython/core/interactiveshell.py\", line 3639, in run_ast_nodes\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/IPython/core/interactiveshell.py\", line 3699, in run_code\n File \"/tmp/ipykernel_151648/1411372838.py\", line 23, in \n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/traceback_util.py\", line 180, in reraise_with_filtered_traceback\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/api.py\", line 505, in value_and_grad_f\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/tree_util.py\", line 488, in __call__\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/traceback_util.py\", line 180, in reraise_with_filtered_traceback\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/api.py\", line 2105, in _vjp_pullback_wrapper\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/tree_util.py\", line 488, in __call__\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/interpreters/ad.py\", line 320, in unbound_vjp\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/interpreters/ad.py\", line 438, in backward_pass\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/tesseract_jax/primitive.py\", line 169, in tesseract_dispatch_transpose_rule\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/core.py\", line 632, in bind\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/core.py\", line 648, in _true_bind\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/core.py\", line 660, in bind_with_trace\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/core.py\", line 1189, in process_primitive\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/dispatch.py\", line 94, in apply_primitive\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/traceback_util.py\", line 180, in reraise_with_filtered_traceback\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/pjit.py\", line 263, in cache_miss\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/pjit.py\", line 146, in _python_pjit_helper\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/pjit.py\", line 1622, in _pjit_call_impl_python\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/profiler.py\", line 359, in wrapper\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/interpreters/pxla.py\", line 1371, in __call__\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/callback.py\", line 784, in _wrapped_callback\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/tesseract_jax/primitive.py\", line 208, in _dispatch\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/tesseract_jax/tesseract_compat.py\", line 253, in vector_jacobian_product\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/tesseract_core/sdk/tesseract.py\", line 35, in wrapper\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/tesseract_core/sdk/tesseract.py\", line 448, in vector_jacobian_product\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/tesseract_core/sdk/tesseract.py\", line 667, in run_tesseract\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/tesseract_core/runtime/core.py\", line 215, in vector_jacobian_product\n File \"/home/azureuser/localfiles/tesseract-jax/examples/ansys/fem_tess/tesseract_api.py\", line 343, in vector_jacobian_product\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/traceback_util.py\", line 181, in reraise_with_filtered_traceback\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/api.py\", line 2176, in vjp\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/api.py\", line 2190, in _vjp\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/interpreters/ad.py\", line 313, in vjp\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/interpreters/ad.py\", line 287, in linearize\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/interpreters/ad.py\", line 261, in direct_linearize\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/linear_util.py\", line 212, in call_wrapped\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/api_util.py\", line 90, in flatten_fun_nokwargs\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/linear_util.py\", line 421, in _get_result_paths_thunk\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/tesseract_core/runtime/tree_transforms.py\", line 170, in filtered_func\n File \"/home/azureuser/localfiles/tesseract-jax/examples/ansys/fem_tess/tesseract_api.py\", line 304, in apply_fn\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/traceback_util.py\", line 181, in reraise_with_filtered_traceback\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/custom_derivatives.py\", line 749, in __call__\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/core.py\", line 632, in bind\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/core.py\", line 650, in _true_bind\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/custom_derivatives.py\", line 1007, in bind_with_trace\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/interpreters/ad.py\", line 979, in process_custom_vjp_call\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/linear_util.py\", line 212, in call_wrapped\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/custom_derivatives.py\", line 850, in _flatten_fwd\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/linear_util.py\", line 421, in _get_result_paths_thunk\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax_fem/solver.py\", line 1003, in f_fwd\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/traceback_util.py\", line 181, in reraise_with_filtered_traceback\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/custom_derivatives.py\", line 749, in __call__\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/core.py\", line 632, in bind\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/core.py\", line 650, in _true_bind\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/custom_derivatives.py\", line 1007, in bind_with_trace\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/core.py\", line 1210, in process_custom_vjp_call\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/linear_util.py\", line 212, in call_wrapped\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/custom_derivatives.py\", line 87, in _flatten_fun_nokwargs\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/custom_derivatives.py\", line 759, in _check_primal_refs\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/linear_util.py\", line 421, in _get_result_paths_thunk\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax_fem/solver.py\", line 999, in fwd_pred\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax_fem/solver.py\", line 534, in solver\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax_fem/solver.py\", line 307, in linear_incremental_solver\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax_fem/solver.py\", line 179, in linear_solver\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax_fem/solver.py\", line 59, in umfpack_solve\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/scipy/sparse/linalg/_dsolve/linsolve.py\", line 286, in spsolve\nKeyboardInterrupt: ", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mJaxStackTraceBeforeTransformation\u001b[39m Traceback (most recent call last)", + "\u001b[36mFile \u001b[39m\u001b[32m:198\u001b[39m, in \u001b[36m_run_module_as_main\u001b[39m\u001b[34m()\u001b[39m\n", + "\u001b[36mFile \u001b[39m\u001b[32m:88\u001b[39m, in \u001b[36m_run_code\u001b[39m\u001b[34m()\u001b[39m\n", + "\u001b[36mFile \u001b[39m\u001b[32m/anaconda/envs/fem/lib/python3.13/site-packages/ipykernel_launcher.py:18\u001b[39m\n\u001b[32m 16\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mipykernel\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m kernelapp \u001b[38;5;28;01mas\u001b[39;00m app\n\u001b[32m---> \u001b[39m\u001b[32m18\u001b[39m app.launch_new_instance()\n", + "\u001b[36mFile \u001b[39m\u001b[32m/anaconda/envs/fem/lib/python3.13/site-packages/traitlets/config/application.py:1075\u001b[39m, in \u001b[36mlaunch_instance\u001b[39m\u001b[34m()\u001b[39m\n\u001b[32m 1074\u001b[39m app.initialize(argv)\n\u001b[32m-> \u001b[39m\u001b[32m1075\u001b[39m app.start()\n", + "\u001b[36mFile \u001b[39m\u001b[32m/anaconda/envs/fem/lib/python3.13/site-packages/ipykernel/kernelapp.py:758\u001b[39m, in \u001b[36mstart\u001b[39m\u001b[34m()\u001b[39m\n\u001b[32m 757\u001b[39m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[32m--> \u001b[39m\u001b[32m758\u001b[39m \u001b[38;5;28mself\u001b[39m.io_loop.start()\n\u001b[32m 759\u001b[39m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mKeyboardInterrupt\u001b[39;00m:\n", + "\u001b[36mFile \u001b[39m\u001b[32m/anaconda/envs/fem/lib/python3.13/site-packages/tornado/platform/asyncio.py:211\u001b[39m, in \u001b[36mstart\u001b[39m\u001b[34m()\u001b[39m\n\u001b[32m 210\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mstart\u001b[39m(\u001b[38;5;28mself\u001b[39m) -> \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m--> \u001b[39m\u001b[32m211\u001b[39m \u001b[38;5;28mself\u001b[39m.asyncio_loop.run_forever()\n", + "\u001b[36mFile \u001b[39m\u001b[32m/anaconda/envs/fem/lib/python3.13/asyncio/base_events.py:683\u001b[39m, in \u001b[36mrun_forever\u001b[39m\u001b[34m()\u001b[39m\n\u001b[32m 682\u001b[39m \u001b[38;5;28;01mwhile\u001b[39;00m \u001b[38;5;28;01mTrue\u001b[39;00m:\n\u001b[32m--> \u001b[39m\u001b[32m683\u001b[39m \u001b[38;5;28mself\u001b[39m._run_once()\n\u001b[32m 684\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m._stopping:\n", + "\u001b[36mFile \u001b[39m\u001b[32m/anaconda/envs/fem/lib/python3.13/asyncio/base_events.py:2050\u001b[39m, in \u001b[36m_run_once\u001b[39m\u001b[34m()\u001b[39m\n\u001b[32m 2049\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m-> \u001b[39m\u001b[32m2050\u001b[39m handle._run()\n\u001b[32m 2051\u001b[39m handle = \u001b[38;5;28;01mNone\u001b[39;00m\n", + "\u001b[36mFile \u001b[39m\u001b[32m/anaconda/envs/fem/lib/python3.13/asyncio/events.py:89\u001b[39m, in \u001b[36m_run\u001b[39m\u001b[34m()\u001b[39m\n\u001b[32m 88\u001b[39m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[32m---> \u001b[39m\u001b[32m89\u001b[39m \u001b[38;5;28mself\u001b[39m._context.run(\u001b[38;5;28mself\u001b[39m._callback, *\u001b[38;5;28mself\u001b[39m._args)\n\u001b[32m 90\u001b[39m \u001b[38;5;28;01mexcept\u001b[39;00m (\u001b[38;5;167;01mSystemExit\u001b[39;00m, \u001b[38;5;167;01mKeyboardInterrupt\u001b[39;00m):\n", + "\u001b[36mFile \u001b[39m\u001b[32m/anaconda/envs/fem/lib/python3.13/site-packages/ipykernel/kernelbase.py:701\u001b[39m, in \u001b[36mshell_main\u001b[39m\u001b[34m()\u001b[39m\n\u001b[32m 700\u001b[39m \u001b[38;5;28;01masync\u001b[39;00m \u001b[38;5;28;01mwith\u001b[39;00m asyncio_lock:\n\u001b[32m--> \u001b[39m\u001b[32m701\u001b[39m \u001b[38;5;28;01mawait\u001b[39;00m \u001b[38;5;28mself\u001b[39m.dispatch_shell(msg, subshell_id=subshell_id)\n", + "\u001b[36mFile \u001b[39m\u001b[32m/anaconda/envs/fem/lib/python3.13/site-packages/ipykernel/kernelbase.py:469\u001b[39m, in \u001b[36mdispatch_shell\u001b[39m\u001b[34m()\u001b[39m\n\u001b[32m 468\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m inspect.isawaitable(result):\n\u001b[32m--> \u001b[39m\u001b[32m469\u001b[39m \u001b[38;5;28;01mawait\u001b[39;00m result\n\u001b[32m 470\u001b[39m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m:\n", + "\u001b[36mFile \u001b[39m\u001b[32m/anaconda/envs/fem/lib/python3.13/site-packages/ipykernel/ipkernel.py:379\u001b[39m, in \u001b[36mexecute_request\u001b[39m\u001b[34m()\u001b[39m\n\u001b[32m 378\u001b[39m \u001b[38;5;28mself\u001b[39m._associate_new_top_level_threads_with(parent_header)\n\u001b[32m--> \u001b[39m\u001b[32m379\u001b[39m \u001b[38;5;28;01mawait\u001b[39;00m \u001b[38;5;28msuper\u001b[39m().execute_request(stream, ident, parent)\n", + "\u001b[36mFile \u001b[39m\u001b[32m/anaconda/envs/fem/lib/python3.13/site-packages/ipykernel/kernelbase.py:899\u001b[39m, in \u001b[36mexecute_request\u001b[39m\u001b[34m()\u001b[39m\n\u001b[32m 898\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m inspect.isawaitable(reply_content):\n\u001b[32m--> \u001b[39m\u001b[32m899\u001b[39m reply_content = \u001b[38;5;28;01mawait\u001b[39;00m reply_content\n\u001b[32m 900\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n", + "\u001b[36mFile \u001b[39m\u001b[32m/anaconda/envs/fem/lib/python3.13/site-packages/ipykernel/ipkernel.py:471\u001b[39m, in \u001b[36mdo_execute\u001b[39m\u001b[34m()\u001b[39m\n\u001b[32m 470\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m accepts_params[\u001b[33m\"\u001b[39m\u001b[33mcell_id\u001b[39m\u001b[33m\"\u001b[39m]:\n\u001b[32m--> \u001b[39m\u001b[32m471\u001b[39m res = shell.run_cell(\n\u001b[32m 472\u001b[39m code,\n\u001b[32m 473\u001b[39m store_history=store_history,\n\u001b[32m 474\u001b[39m silent=silent,\n\u001b[32m 475\u001b[39m cell_id=cell_id,\n\u001b[32m 476\u001b[39m )\n\u001b[32m 477\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n", + "\u001b[36mFile \u001b[39m\u001b[32m/anaconda/envs/fem/lib/python3.13/site-packages/ipykernel/zmqshell.py:632\u001b[39m, in \u001b[36mrun_cell\u001b[39m\u001b[34m()\u001b[39m\n\u001b[32m 631\u001b[39m \u001b[38;5;28mself\u001b[39m._last_traceback = \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m632\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28msuper\u001b[39m().run_cell(*args, **kwargs)\n", + "\u001b[36mFile \u001b[39m\u001b[32m/anaconda/envs/fem/lib/python3.13/site-packages/IPython/core/interactiveshell.py:3116\u001b[39m, in \u001b[36mrun_cell\u001b[39m\u001b[34m()\u001b[39m\n\u001b[32m 3115\u001b[39m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[32m-> \u001b[39m\u001b[32m3116\u001b[39m result = \u001b[38;5;28mself\u001b[39m._run_cell(\n\u001b[32m 3117\u001b[39m raw_cell, store_history, silent, shell_futures, cell_id\n\u001b[32m 3118\u001b[39m )\n\u001b[32m 3119\u001b[39m \u001b[38;5;28;01mfinally\u001b[39;00m:\n", + "\u001b[36mFile \u001b[39m\u001b[32m/anaconda/envs/fem/lib/python3.13/site-packages/IPython/core/interactiveshell.py:3171\u001b[39m, in \u001b[36m_run_cell\u001b[39m\u001b[34m()\u001b[39m\n\u001b[32m 3170\u001b[39m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[32m-> \u001b[39m\u001b[32m3171\u001b[39m result = runner(coro)\n\u001b[32m 3172\u001b[39m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mBaseException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n", + "\u001b[36mFile \u001b[39m\u001b[32m/anaconda/envs/fem/lib/python3.13/site-packages/IPython/core/async_helpers.py:128\u001b[39m, in \u001b[36m_pseudo_sync_runner\u001b[39m\u001b[34m()\u001b[39m\n\u001b[32m 127\u001b[39m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[32m--> \u001b[39m\u001b[32m128\u001b[39m coro.send(\u001b[38;5;28;01mNone\u001b[39;00m)\n\u001b[32m 129\u001b[39m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mStopIteration\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m exc:\n", + "\u001b[36mFile \u001b[39m\u001b[32m/anaconda/envs/fem/lib/python3.13/site-packages/IPython/core/interactiveshell.py:3394\u001b[39m, in \u001b[36mrun_cell_async\u001b[39m\u001b[34m()\u001b[39m\n\u001b[32m 3391\u001b[39m interactivity = \u001b[33m\"\u001b[39m\u001b[33mnone\u001b[39m\u001b[33m\"\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m silent \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28mself\u001b[39m.ast_node_interactivity\n\u001b[32m-> \u001b[39m\u001b[32m3394\u001b[39m has_raised = \u001b[38;5;28;01mawait\u001b[39;00m \u001b[38;5;28mself\u001b[39m.run_ast_nodes(code_ast.body, cell_name,\n\u001b[32m 3395\u001b[39m interactivity=interactivity, compiler=compiler, result=result)\n\u001b[32m 3397\u001b[39m \u001b[38;5;28mself\u001b[39m.last_execution_succeeded = \u001b[38;5;129;01mnot\u001b[39;00m has_raised\n", + "\u001b[36mFile \u001b[39m\u001b[32m/anaconda/envs/fem/lib/python3.13/site-packages/IPython/core/interactiveshell.py:3639\u001b[39m, in \u001b[36mrun_ast_nodes\u001b[39m\u001b[34m()\u001b[39m\n\u001b[32m 3638\u001b[39m asy = compare(code)\n\u001b[32m-> \u001b[39m\u001b[32m3639\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28;01mawait\u001b[39;00m \u001b[38;5;28mself\u001b[39m.run_code(code, result, async_=asy):\n\u001b[32m 3640\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;01mTrue\u001b[39;00m\n", + "\u001b[36mFile \u001b[39m\u001b[32m/anaconda/envs/fem/lib/python3.13/site-packages/IPython/core/interactiveshell.py:3699\u001b[39m, in \u001b[36mrun_code\u001b[39m\u001b[34m()\u001b[39m\n\u001b[32m 3698\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m-> \u001b[39m\u001b[32m3699\u001b[39m exec(code_obj, \u001b[38;5;28mself\u001b[39m.user_global_ns, \u001b[38;5;28mself\u001b[39m.user_ns)\n\u001b[32m 3700\u001b[39m \u001b[38;5;28;01mfinally\u001b[39;00m:\n\u001b[32m 3701\u001b[39m \u001b[38;5;66;03m# Reset our crash handler in place\u001b[39;00m\n", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[41]\u001b[39m\u001b[32m, line 23\u001b[39m\n\u001b[32m 22\u001b[39m \u001b[38;5;28mprint\u001b[39m(params)\n\u001b[32m---> \u001b[39m\u001b[32m23\u001b[39m (loss_value, aux), grads = grad_fn(params, iteration=i)\n\u001b[32m 24\u001b[39m aux_hist.append(aux)\n", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[40]\u001b[39m\u001b[32m, line 72\u001b[39m, in \u001b[36mloss\u001b[39m\u001b[34m()\u001b[39m\n\u001b[32m 70\u001b[39m \u001b[38;5;66;03m# Instead of passing all inputs and trying to stop_gradient on them,\u001b[39;00m\n\u001b[32m 71\u001b[39m \u001b[38;5;66;03m# we need to wrap the tesseract call to only allow gradients w.r.t. rho\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m72\u001b[39m c = apply_tesseract(\n\u001b[32m 73\u001b[39m fem_tess,\n\u001b[32m 74\u001b[39m {\n\u001b[32m 75\u001b[39m \u001b[33m\"\u001b[39m\u001b[33mrho\u001b[39m\u001b[33m\"\u001b[39m: rho_cell,\n\u001b[32m 76\u001b[39m \u001b[33m\"\u001b[39m\u001b[33mhex_mesh\u001b[39m\u001b[33m\"\u001b[39m: mesh,\n\u001b[32m 77\u001b[39m \u001b[33m\"\u001b[39m\u001b[33mdirichlet_mask\u001b[39m\u001b[33m\"\u001b[39m: dirichlet_mask,\n\u001b[32m 78\u001b[39m \u001b[33m\"\u001b[39m\u001b[33mdirichlet_values\u001b[39m\u001b[33m\"\u001b[39m: dirichlet_values,\n\u001b[32m 79\u001b[39m \u001b[33m\"\u001b[39m\u001b[33mvan_neumann_mask\u001b[39m\u001b[33m\"\u001b[39m: van_neumann_mask,\n\u001b[32m 80\u001b[39m \u001b[33m\"\u001b[39m\u001b[33mvan_neumann_values\u001b[39m\u001b[33m\"\u001b[39m: van_neumann_values,\n\u001b[32m 81\u001b[39m },\n\u001b[32m 82\u001b[39m )[\u001b[33m\"\u001b[39m\u001b[33mcompliance\u001b[39m\u001b[33m\"\u001b[39m]\n\u001b[32m 84\u001b[39m \u001b[38;5;66;03m# lets store all intermediate results in a dictionary to return\u001b[39;00m\n\u001b[32m 85\u001b[39m \u001b[38;5;66;03m# for visualization purposes\u001b[39;00m\n", + "\u001b[36mFile \u001b[39m\u001b[32m/anaconda/envs/fem/lib/python3.13/site-packages/tesseract_jax/primitive.py:384\u001b[39m, in \u001b[36mapply_tesseract\u001b[39m\u001b[34m()\u001b[39m\n\u001b[32m 383\u001b[39m \u001b[38;5;66;03m# Apply the primitive\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m384\u001b[39m out = tesseract_dispatch_p.bind(\n\u001b[32m 385\u001b[39m *array_args,\n\u001b[32m 386\u001b[39m static_args=static_args,\n\u001b[32m 387\u001b[39m input_pytreedef=input_pytreedef,\n\u001b[32m 388\u001b[39m output_pytreedef=output_pytreedef,\n\u001b[32m 389\u001b[39m output_avals=flat_avals,\n\u001b[32m 390\u001b[39m is_static_mask=is_static_mask,\n\u001b[32m 391\u001b[39m client=client,\n\u001b[32m 392\u001b[39m eval_func=\u001b[33m\"\u001b[39m\u001b[33mapply\u001b[39m\u001b[33m\"\u001b[39m,\n\u001b[32m 393\u001b[39m )\n\u001b[32m 395\u001b[39m \u001b[38;5;66;03m# Unflatten the output\u001b[39;00m\n", + "\u001b[36mFile \u001b[39m\u001b[32m/anaconda/envs/fem/lib/python3.13/site-packages/tesseract_jax/primitive.py:114\u001b[39m, in \u001b[36mtesseract_dispatch_jvp_rule\u001b[39m\u001b[34m()\u001b[39m\n\u001b[32m 105\u001b[39m tan_args_ = \u001b[38;5;28mtuple\u001b[39m(\n\u001b[32m 106\u001b[39m (\n\u001b[32m 107\u001b[39m jax.numpy.zeros_like(arg.aval)\n\u001b[32m (...)\u001b[39m\u001b[32m 111\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m arg \u001b[38;5;129;01min\u001b[39;00m tan_args\n\u001b[32m 112\u001b[39m )\n\u001b[32m--> \u001b[39m\u001b[32m114\u001b[39m jvp = tesseract_dispatch_p.bind(\n\u001b[32m 115\u001b[39m *in_args,\n\u001b[32m 116\u001b[39m *tan_args_,\n\u001b[32m 117\u001b[39m static_args=static_args,\n\u001b[32m 118\u001b[39m input_pytreedef=input_pytreedef,\n\u001b[32m 119\u001b[39m output_pytreedef=output_pytreedef,\n\u001b[32m 120\u001b[39m output_avals=output_avals,\n\u001b[32m 121\u001b[39m is_static_mask=is_static_mask,\n\u001b[32m 122\u001b[39m client=client,\n\u001b[32m 123\u001b[39m eval_func=\u001b[33m\"\u001b[39m\u001b[33mjacobian_vector_product\u001b[39m\u001b[33m\"\u001b[39m,\n\u001b[32m 124\u001b[39m )\n\u001b[32m 126\u001b[39m res = tesseract_dispatch_p.bind(\n\u001b[32m 127\u001b[39m *in_args,\n\u001b[32m 128\u001b[39m static_args=static_args,\n\u001b[32m (...)\u001b[39m\u001b[32m 134\u001b[39m eval_func=\u001b[33m\"\u001b[39m\u001b[33mapply\u001b[39m\u001b[33m\"\u001b[39m,\n\u001b[32m 135\u001b[39m )\n", + "\u001b[31mJaxStackTraceBeforeTransformation\u001b[39m: jax.errors.JaxRuntimeError: INTERNAL: CpuCallback error calling callback: Traceback (most recent call last):\n File \"\", line 198, in _run_module_as_main\n File \"\", line 88, in _run_code\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/ipykernel_launcher.py\", line 18, in \n File \"/anaconda/envs/fem/lib/python3.13/site-packages/traitlets/config/application.py\", line 1075, in launch_instance\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/ipykernel/kernelapp.py\", line 758, in start\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/tornado/platform/asyncio.py\", line 211, in start\n File \"/anaconda/envs/fem/lib/python3.13/asyncio/base_events.py\", line 683, in run_forever\n File \"/anaconda/envs/fem/lib/python3.13/asyncio/base_events.py\", line 2050, in _run_once\n File \"/anaconda/envs/fem/lib/python3.13/asyncio/events.py\", line 89, in _run\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/ipykernel/kernelbase.py\", line 701, in shell_main\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/ipykernel/kernelbase.py\", line 469, in dispatch_shell\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/ipykernel/ipkernel.py\", line 379, in execute_request\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/ipykernel/kernelbase.py\", line 899, in execute_request\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/ipykernel/ipkernel.py\", line 471, in do_execute\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/ipykernel/zmqshell.py\", line 632, in run_cell\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/IPython/core/interactiveshell.py\", line 3116, in run_cell\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/IPython/core/interactiveshell.py\", line 3171, in _run_cell\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/IPython/core/async_helpers.py\", line 128, in _pseudo_sync_runner\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/IPython/core/interactiveshell.py\", line 3394, in run_cell_async\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/IPython/core/interactiveshell.py\", line 3639, in run_ast_nodes\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/IPython/core/interactiveshell.py\", line 3699, in run_code\n File \"/tmp/ipykernel_151648/1411372838.py\", line 23, in \n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/traceback_util.py\", line 180, in reraise_with_filtered_traceback\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/api.py\", line 505, in value_and_grad_f\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/tree_util.py\", line 488, in __call__\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/traceback_util.py\", line 180, in reraise_with_filtered_traceback\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/api.py\", line 2105, in _vjp_pullback_wrapper\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/tree_util.py\", line 488, in __call__\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/interpreters/ad.py\", line 320, in unbound_vjp\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/interpreters/ad.py\", line 438, in backward_pass\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/tesseract_jax/primitive.py\", line 169, in tesseract_dispatch_transpose_rule\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/core.py\", line 632, in bind\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/core.py\", line 648, in _true_bind\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/core.py\", line 660, in bind_with_trace\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/core.py\", line 1189, in process_primitive\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/dispatch.py\", line 94, in apply_primitive\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/traceback_util.py\", line 180, in reraise_with_filtered_traceback\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/pjit.py\", line 263, in cache_miss\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/pjit.py\", line 146, in _python_pjit_helper\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/pjit.py\", line 1622, in _pjit_call_impl_python\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/profiler.py\", line 359, in wrapper\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/interpreters/pxla.py\", line 1371, in __call__\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/callback.py\", line 784, in _wrapped_callback\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/tesseract_jax/primitive.py\", line 208, in _dispatch\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/tesseract_jax/tesseract_compat.py\", line 253, in vector_jacobian_product\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/tesseract_core/sdk/tesseract.py\", line 35, in wrapper\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/tesseract_core/sdk/tesseract.py\", line 448, in vector_jacobian_product\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/tesseract_core/sdk/tesseract.py\", line 667, in run_tesseract\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/tesseract_core/runtime/core.py\", line 215, in vector_jacobian_product\n File \"/home/azureuser/localfiles/tesseract-jax/examples/ansys/fem_tess/tesseract_api.py\", line 343, in vector_jacobian_product\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/traceback_util.py\", line 181, in reraise_with_filtered_traceback\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/api.py\", line 2176, in vjp\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/api.py\", line 2190, in _vjp\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/interpreters/ad.py\", line 313, in vjp\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/interpreters/ad.py\", line 287, in linearize\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/interpreters/ad.py\", line 261, in direct_linearize\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/linear_util.py\", line 212, in call_wrapped\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/api_util.py\", line 90, in flatten_fun_nokwargs\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/linear_util.py\", line 421, in _get_result_paths_thunk\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/tesseract_core/runtime/tree_transforms.py\", line 170, in filtered_func\n File \"/home/azureuser/localfiles/tesseract-jax/examples/ansys/fem_tess/tesseract_api.py\", line 304, in apply_fn\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/traceback_util.py\", line 181, in reraise_with_filtered_traceback\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/custom_derivatives.py\", line 749, in __call__\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/core.py\", line 632, in bind\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/core.py\", line 650, in _true_bind\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/custom_derivatives.py\", line 1007, in bind_with_trace\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/interpreters/ad.py\", line 979, in process_custom_vjp_call\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/linear_util.py\", line 212, in call_wrapped\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/custom_derivatives.py\", line 850, in _flatten_fwd\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/linear_util.py\", line 421, in _get_result_paths_thunk\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax_fem/solver.py\", line 1003, in f_fwd\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/traceback_util.py\", line 181, in reraise_with_filtered_traceback\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/custom_derivatives.py\", line 749, in __call__\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/core.py\", line 632, in bind\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/core.py\", line 650, in _true_bind\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/custom_derivatives.py\", line 1007, in bind_with_trace\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/core.py\", line 1210, in process_custom_vjp_call\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/linear_util.py\", line 212, in call_wrapped\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/custom_derivatives.py\", line 87, in _flatten_fun_nokwargs\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/custom_derivatives.py\", line 759, in _check_primal_refs\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/linear_util.py\", line 421, in _get_result_paths_thunk\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax_fem/solver.py\", line 999, in fwd_pred\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax_fem/solver.py\", line 534, in solver\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax_fem/solver.py\", line 307, in linear_incremental_solver\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax_fem/solver.py\", line 179, in linear_solver\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax_fem/solver.py\", line 59, in umfpack_solve\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/scipy/sparse/linalg/_dsolve/linsolve.py\", line 286, in spsolve\nKeyboardInterrupt:\n\nThe preceding stack trace is the source of the JAX operation that, once transformed by JAX, triggered the following exception.\n\n--------------------", + "\nThe above exception was the direct cause of the following exception:\n", + "\u001b[31mJaxRuntimeError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[41]\u001b[39m\u001b[32m, line 23\u001b[39m\n\u001b[32m 21\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(n_steps):\n\u001b[32m 22\u001b[39m \u001b[38;5;28mprint\u001b[39m(params)\n\u001b[32m---> \u001b[39m\u001b[32m23\u001b[39m (loss_value, aux), grads = \u001b[43mgrad_fn\u001b[49m\u001b[43m(\u001b[49m\u001b[43mparams\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43miteration\u001b[49m\u001b[43m=\u001b[49m\u001b[43mi\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 24\u001b[39m aux_hist.append(aux)\n\u001b[32m 26\u001b[39m \u001b[38;5;28mprint\u001b[39m(grads)\n", + " \u001b[31m[... skipping hidden 8 frame]\u001b[39m\n", + "\u001b[36mFile \u001b[39m\u001b[32m/anaconda/envs/fem/lib/python3.13/site-packages/tesseract_jax/primitive.py:169\u001b[39m, in \u001b[36mtesseract_dispatch_transpose_rule\u001b[39m\u001b[34m(cotangent, static_args, input_pytreedef, output_pytreedef, output_avals, is_static_mask, client, eval_func, *args)\u001b[39m\n\u001b[32m 158\u001b[39m args = args[:n_primals]\n\u001b[32m 160\u001b[39m cotan_args_ = \u001b[38;5;28mtuple\u001b[39m(\n\u001b[32m 161\u001b[39m (\n\u001b[32m 162\u001b[39m jax.numpy.zeros_like(arg.aval)\n\u001b[32m (...)\u001b[39m\u001b[32m 166\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m arg \u001b[38;5;129;01min\u001b[39;00m cotangent\n\u001b[32m 167\u001b[39m )\n\u001b[32m--> \u001b[39m\u001b[32m169\u001b[39m vjp = \u001b[43mtesseract_dispatch_p\u001b[49m\u001b[43m.\u001b[49m\u001b[43mbind\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 170\u001b[39m \u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 171\u001b[39m \u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43mcotan_args_\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 172\u001b[39m \u001b[43m \u001b[49m\u001b[43mstatic_args\u001b[49m\u001b[43m=\u001b[49m\u001b[43mstatic_args\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 173\u001b[39m \u001b[43m \u001b[49m\u001b[43minput_pytreedef\u001b[49m\u001b[43m=\u001b[49m\u001b[43minput_pytreedef\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 174\u001b[39m \u001b[43m \u001b[49m\u001b[43moutput_pytreedef\u001b[49m\u001b[43m=\u001b[49m\u001b[43moutput_pytreedef\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 175\u001b[39m \u001b[43m \u001b[49m\u001b[43moutput_avals\u001b[49m\u001b[43m=\u001b[49m\u001b[43moutput_avals\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 176\u001b[39m \u001b[43m \u001b[49m\u001b[43mis_static_mask\u001b[49m\u001b[43m=\u001b[49m\u001b[43mis_static_mask\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 177\u001b[39m \u001b[43m \u001b[49m\u001b[43mclient\u001b[49m\u001b[43m=\u001b[49m\u001b[43mclient\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 178\u001b[39m \u001b[43m \u001b[49m\u001b[43meval_func\u001b[49m\u001b[43m=\u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mvector_jacobian_product\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m 179\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 180\u001b[39m \u001b[38;5;66;03m# TODO: I'm not sure this makes sense given these docs:\u001b[39;00m\n\u001b[32m 181\u001b[39m \u001b[38;5;66;03m# https://jax.readthedocs.io/en/latest/jax-primitives.html#transposition\u001b[39;00m\n\u001b[32m 182\u001b[39m \u001b[38;5;66;03m# \"A tuple with the cotangent of the inputs, with the value None corresponding to the constant arguments\"\u001b[39;00m\n\u001b[32m 183\u001b[39m \u001b[38;5;66;03m# ...but if I provide only cotangent, jax complains, and if I investigate its internals,\u001b[39;00m\n\u001b[32m 184\u001b[39m \u001b[38;5;66;03m# I see it chokes on map(partial(write_cotangent, eqn.primitive), eqn.invars, cts_out),\u001b[39;00m\n\u001b[32m 185\u001b[39m \u001b[38;5;66;03m# where eqn.invars ends up being longer than cts_out.\u001b[39;00m\n\u001b[32m 187\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mtuple\u001b[39m([\u001b[38;5;28;01mNone\u001b[39;00m] * \u001b[38;5;28mlen\u001b[39m(args) + vjp)\n", + " \u001b[31m[... skipping hidden 10 frame]\u001b[39m\n", + "\u001b[36mFile \u001b[39m\u001b[32m/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/interpreters/pxla.py:1371\u001b[39m, in \u001b[36mExecuteReplicated.__call__\u001b[39m\u001b[34m(self, *args)\u001b[39m\n\u001b[32m 1368\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m (\u001b[38;5;28mself\u001b[39m.ordered_effects \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m.has_unordered_effects\n\u001b[32m 1369\u001b[39m \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m.has_host_callbacks):\n\u001b[32m 1370\u001b[39m input_bufs = \u001b[38;5;28mself\u001b[39m._add_tokens_to_inputs(input_bufs)\n\u001b[32m-> \u001b[39m\u001b[32m1371\u001b[39m results = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mxla_executable\u001b[49m\u001b[43m.\u001b[49m\u001b[43mexecute_sharded\u001b[49m\u001b[43m(\u001b[49m\u001b[43minput_bufs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mwith_tokens\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[32m 1373\u001b[39m result_token_bufs = results.disassemble_prefix_into_single_device_arrays(\n\u001b[32m 1374\u001b[39m \u001b[38;5;28mlen\u001b[39m(\u001b[38;5;28mself\u001b[39m.ordered_effects))\n\u001b[32m 1375\u001b[39m sharded_runtime_token = results.consume_token()\n", + "\u001b[31mJaxRuntimeError\u001b[39m: INTERNAL: CpuCallback error calling callback: Traceback (most recent call last):\n File \"\", line 198, in _run_module_as_main\n File \"\", line 88, in _run_code\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/ipykernel_launcher.py\", line 18, in \n File \"/anaconda/envs/fem/lib/python3.13/site-packages/traitlets/config/application.py\", line 1075, in launch_instance\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/ipykernel/kernelapp.py\", line 758, in start\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/tornado/platform/asyncio.py\", line 211, in start\n File \"/anaconda/envs/fem/lib/python3.13/asyncio/base_events.py\", line 683, in run_forever\n File \"/anaconda/envs/fem/lib/python3.13/asyncio/base_events.py\", line 2050, in _run_once\n File \"/anaconda/envs/fem/lib/python3.13/asyncio/events.py\", line 89, in _run\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/ipykernel/kernelbase.py\", line 701, in shell_main\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/ipykernel/kernelbase.py\", line 469, in dispatch_shell\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/ipykernel/ipkernel.py\", line 379, in execute_request\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/ipykernel/kernelbase.py\", line 899, in execute_request\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/ipykernel/ipkernel.py\", line 471, in do_execute\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/ipykernel/zmqshell.py\", line 632, in run_cell\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/IPython/core/interactiveshell.py\", line 3116, in run_cell\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/IPython/core/interactiveshell.py\", line 3171, in _run_cell\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/IPython/core/async_helpers.py\", line 128, in _pseudo_sync_runner\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/IPython/core/interactiveshell.py\", line 3394, in run_cell_async\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/IPython/core/interactiveshell.py\", line 3639, in run_ast_nodes\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/IPython/core/interactiveshell.py\", line 3699, in run_code\n File \"/tmp/ipykernel_151648/1411372838.py\", line 23, in \n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/traceback_util.py\", line 180, in reraise_with_filtered_traceback\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/api.py\", line 505, in value_and_grad_f\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/tree_util.py\", line 488, in __call__\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/traceback_util.py\", line 180, in reraise_with_filtered_traceback\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/api.py\", line 2105, in _vjp_pullback_wrapper\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/tree_util.py\", line 488, in __call__\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/interpreters/ad.py\", line 320, in unbound_vjp\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/interpreters/ad.py\", line 438, in backward_pass\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/tesseract_jax/primitive.py\", line 169, in tesseract_dispatch_transpose_rule\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/core.py\", line 632, in bind\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/core.py\", line 648, in _true_bind\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/core.py\", line 660, in bind_with_trace\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/core.py\", line 1189, in process_primitive\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/dispatch.py\", line 94, in apply_primitive\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/traceback_util.py\", line 180, in reraise_with_filtered_traceback\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/pjit.py\", line 263, in cache_miss\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/pjit.py\", line 146, in _python_pjit_helper\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/pjit.py\", line 1622, in _pjit_call_impl_python\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/profiler.py\", line 359, in wrapper\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/interpreters/pxla.py\", line 1371, in __call__\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/callback.py\", line 784, in _wrapped_callback\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/tesseract_jax/primitive.py\", line 208, in _dispatch\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/tesseract_jax/tesseract_compat.py\", line 253, in vector_jacobian_product\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/tesseract_core/sdk/tesseract.py\", line 35, in wrapper\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/tesseract_core/sdk/tesseract.py\", line 448, in vector_jacobian_product\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/tesseract_core/sdk/tesseract.py\", line 667, in run_tesseract\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/tesseract_core/runtime/core.py\", line 215, in vector_jacobian_product\n File \"/home/azureuser/localfiles/tesseract-jax/examples/ansys/fem_tess/tesseract_api.py\", line 343, in vector_jacobian_product\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/traceback_util.py\", line 181, in reraise_with_filtered_traceback\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/api.py\", line 2176, in vjp\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/api.py\", line 2190, in _vjp\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/interpreters/ad.py\", line 313, in vjp\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/interpreters/ad.py\", line 287, in linearize\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/interpreters/ad.py\", line 261, in direct_linearize\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/linear_util.py\", line 212, in call_wrapped\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/api_util.py\", line 90, in flatten_fun_nokwargs\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/linear_util.py\", line 421, in _get_result_paths_thunk\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/tesseract_core/runtime/tree_transforms.py\", line 170, in filtered_func\n File \"/home/azureuser/localfiles/tesseract-jax/examples/ansys/fem_tess/tesseract_api.py\", line 304, in apply_fn\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/traceback_util.py\", line 181, in reraise_with_filtered_traceback\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/custom_derivatives.py\", line 749, in __call__\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/core.py\", line 632, in bind\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/core.py\", line 650, in _true_bind\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/custom_derivatives.py\", line 1007, in bind_with_trace\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/interpreters/ad.py\", line 979, in process_custom_vjp_call\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/linear_util.py\", line 212, in call_wrapped\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/custom_derivatives.py\", line 850, in _flatten_fwd\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/linear_util.py\", line 421, in _get_result_paths_thunk\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax_fem/solver.py\", line 1003, in f_fwd\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/traceback_util.py\", line 181, in reraise_with_filtered_traceback\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/custom_derivatives.py\", line 749, in __call__\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/core.py\", line 632, in bind\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/core.py\", line 650, in _true_bind\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/custom_derivatives.py\", line 1007, in bind_with_trace\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/core.py\", line 1210, in process_custom_vjp_call\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/linear_util.py\", line 212, in call_wrapped\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/custom_derivatives.py\", line 87, in _flatten_fun_nokwargs\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/custom_derivatives.py\", line 759, in _check_primal_refs\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax/_src/linear_util.py\", line 421, in _get_result_paths_thunk\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax_fem/solver.py\", line 999, in fwd_pred\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax_fem/solver.py\", line 534, in solver\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax_fem/solver.py\", line 307, in linear_incremental_solver\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax_fem/solver.py\", line 179, in linear_solver\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/jax_fem/solver.py\", line 59, in umfpack_solve\n File \"/anaconda/envs/fem/lib/python3.13/site-packages/scipy/sparse/linalg/_dsolve/linsolve.py\", line 286, in spsolve\nKeyboardInterrupt: " + ] + } + ], + "source": [ + "import optax\n", + "\n", + "n_steps = 3\n", + "# strong learning rate decay\n", + "schedule = optax.exponential_decay(\n", + " init_value=0.01, transition_steps=n_steps, decay_rate=0.9, staircase=False\n", + ")\n", + "optmizer = optax.adamw(learning_rate=schedule)\n", + "\n", + "params = init_diffable_params.copy()\n", + "opt_state = optmizer.init(params)\n", + "\n", + "# params = normalize(init_diffable_params.copy(), normalization_factors)\n", + "loss_hist = []\n", + "params_hist = []\n", + "\n", + "grad_fn = jax.value_and_grad(loss, has_aux=True)\n", + "\n", + "aux_hist = []\n", + "\n", + "for i in range(n_steps):\n", + " print(params)\n", + " (loss_value, aux), grads = grad_fn(params, iteration=i)\n", + " aux_hist.append(aux)\n", + "\n", + " print(grads)\n", + "\n", + " updates, opt_state = optmizer.update(\n", + " grads, opt_state, params, value=loss_value, grad=grads, value_fn=loss\n", + " )\n", + " params = optax.apply_updates(params, updates)\n", + "\n", + " params = params.at[..., 0].set(init_diffable_params[..., 0]) # fix x-coordinates\n", + "\n", + " loss_hist.append(loss_value)\n", + " params_hist.append(params)\n", + "\n", + " print(f\"Iteration {i + 1}, Loss: {loss_value:.2f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "id": "fb79413d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dict_keys([3000, 2000, 1000, 3001, 2001, 1001, 3002, 2002, 1002])\n" + ] + } + ], + "source": [ + "print(grad_storage.keys())" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "id": "69a8450a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(4096,)\n", + "(4096,)\n", + "(4096,)\n", + "(4096,)\n", + "(4096,)\n", + "(4096,)\n" + ] + } + ], + "source": [ + "for i in range(n_steps):\n", + " mesh = aux_hist[i][\"hex_mesh\"]\n", + " rho_dot = grad_storage[i + 3000][1][: len(mesh[\"faces\"])][:, 0]\n", + " print(mesh[\"rho\"].shape)\n", + " print(rho_dot.shape)\n", + " pv_mesh = hex_to_pyvista(\n", + " mesh[\"points\"], mesh[\"faces\"], {\"rho\": mesh[\"rho\"], \"rho_dot\": rho_dot}\n", + " )\n", + " pv_mesh.save(f\"vtks/fem_shapeopt_mesh{i + 1}.vtk\")" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "id": "148bc08d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
HeaderData Arrays
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
UnstructuredGridInformation
N Cells40000
N Points40000
X Bounds-2.500e+01, 2.500e+01
Y Bounds-2.000e+01, 2.000e+01
Z Bounds-2.000e+00, 2.000e+00
N Arrays1
\n", + "\n", + "		\n", + "\n", + "\n", + "\n", + "
NameFieldTypeN CompMinMax
rhoCellsfloat3210.000e+009.865e-01
\n", + "\n", + "
" + ], + "text/plain": [ + "UnstructuredGrid (0x737f4aabd060)\n", + " N Cells: 40000\n", + " N Points: 40000\n", + " X Bounds: -2.500e+01, 2.500e+01\n", + " Y Bounds: -2.000e+01, 2.000e+01\n", + " Z Bounds: -2.000e+00, 2.000e+00\n", + " N Arrays: 1" + ] + }, + "execution_count": 73, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# store intermediate grads as vtks\n", + "\n", + "hex_to_pyvista(pts_np, cells_np, {\"rho\": mesher_out[\"mesh_cell_values\"]})" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "id": "8c744938", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Compliance over Optimization')" + ] + }, + "execution_count": 77, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(loss_hist, marker=\"o\")\n", + "plt.yscale(\"log\")\n", + "plt.xlabel(\"Optimization Iteration\")\n", + "plt.ylabel(\"Compliance\")\n", + "plt.title(\"Compliance over Optimization\")" + ] + }, + { + "cell_type": "code", + "execution_count": 150, + "id": "a4d34382", + "metadata": {}, + "outputs": [], + "source": [ + "from matplotlib import animation\n", + "\n", + "# repeat the last frame a few times to show the final result\n", + "params_hist = params_hist + [params] * 20\n", + "\n", + "fig = plt.figure(figsize=(7, 4))\n", + "\n", + "design_inputs[\"precompute_jacobian\"] = False\n", + "\n", + "ims = []\n", + "for aux in aux_hist:\n", + " sdf = aux[\"sdf\"]\n", + "\n", + " im = plt.imshow((sdf[:, :, :] > 0).sum(axis=2).T, origin=\"lower\", cmap=\"viridis\")\n", + " ims.append([im])\n", + "\n", + "ani = animation.ArtistAnimation(fig, ims, interval=10, blit=False, repeat_delay=2)\n", + "plt.close(fig)\n", + "\n", + "ani.save(\"rho_optim_sum_2.gif\", writer=\"pillow\", fps=10)" + ] + }, + { + "cell_type": "code", + "execution_count": 147, + "id": "5bf4310b", + "metadata": {}, + "outputs": [], + "source": [ + "# lets visualize the 3d meshes over the optimization\n", + "for i, aux in enumerate(aux_hist):\n", + " plot_mesh(aux[\"surface_mesh\"], save_path=f\"tmp_img/mesh_optim_{i:03d}.png\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a3fcfc89", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "fem", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/ansys/out b/examples/ansys/out new file mode 100644 index 0000000..e69de29 diff --git a/examples/ansys/pymapdl_tess/tesseract_api.py b/examples/ansys/pymapdl_tess/tesseract_api.py new file mode 100644 index 0000000..33d04ad --- /dev/null +++ b/examples/ansys/pymapdl_tess/tesseract_api.py @@ -0,0 +1,689 @@ +# Copyright 2025 Pasteur Labs. All Rights Reserved. +# SPDX-License-Identifier: Apache-2.0 + +# create a temp directory to work in +import os + +# Check if HOME is writable, if not, set it to /tmp +if "HOME" not in os.environ or not os.access(os.environ.get("HOME", ""), os.W_OK): + os.environ["HOME"] = "/tmp" + + +import logging +import time +from collections.abc import Callable +from functools import wraps +from typing import ParamSpec, TypeVar + +import numpy as np +import pyvista as pv +from ansys.mapdl.core import Mapdl +from pydantic import BaseModel, Field +from tesseract_core.runtime import Array, Differentiable, Float32 + +# Set up module logger +logger = logging.getLogger(__name__) + +# Type variables for decorator +P = ParamSpec("P") +T = TypeVar("T") + + +def log_timing(func: Callable[P, T]) -> Callable[P, T]: + """Decorator to log the wall time of method execution.""" + + @wraps(func) + def wrapper(*args: P.args, **kwargs: P.kwargs) -> T: + method_name = func.__name__ + start_time = time.time() + logger.info(f"Starting {method_name}...") + result = func(*args, **kwargs) + end_time = time.time() + elapsed = end_time - start_time + logger.info(f"Completed {method_name} in {elapsed:.4f} seconds") + return result + + return wrapper + + +class InputSchema(BaseModel): + """Inputs for the tess_simp_compliance Tesseract. + + Relies on an instance of ANSYS MAPDL, as in: + `/f/Ansys/ANSYS Inc/v241/ansys/bin/winx64/ANSYS241.exe -grpc -port 50052` + """ + + host: str = Field(description="The IP of your MAPDL grpc server.") + port: str = Field(description="The port of your MAPDL grpc server.") + rho: Differentiable[ + Array[ + ( + None, + None, + ), + Float32, + ] + ] = Field(description="2D density field for topology optimization") + + Lx: float = Field( + default=60.0, description="Length of the simulation box in the x direction." + ) + Ly: float = Field( + default=30.0, + description=("Length of the simulation box in the y direction."), + ) + Lz: float = Field( + default=30.0, description="Length of the simulation box in the z direction." + ) + + Nx: int = Field( + default=60, + description=("Number of elements in the x direction."), + ) + Ny: int = Field( + default=30, + description=("Number of elements in the y direction."), + ) + Nz: int = Field( + default=30, + description=("Number of elements in the z direction."), + ) + + E0: float = Field( + default=1.0, + description="Base Young's modulus in Pa for SIMP material interpolation.", + ) + + rho_min: float = Field( + default=1e-6, + description="Minimum density value to avoid singular stiffness matrix in SIMP.", + ) + + total_force: float = Field( + default=5.0, + description="Total force magnitude in Newtons applied to the structure.", + ) + + p: float = Field( + default=3.0, + description="SIMP penalty parameter for material interpolation (default: 3.0).", + ) + + log_level: str = Field( + default="INFO", + description="Logging level for output messages (DEBUG, INFO, WARNING, ERROR).", + ) + + vtk_output: str | None = Field( + default=None, + description="The path to write the results in VTK format.", + ) + + +class OutputSchema(BaseModel): + """Outputs for the tess_simp_compliance Tesseract.""" + + compliance: Differentiable[ + Array[ + (), + Float32, + ] + ] = Field(description="Compliance of the structure, a measure of stiffness") + strain_energy: Array[(None,), Float32] = Field( + description="The element-wise strain energy of the solution." + ) + sensitivity: Array[(None,), Float32] = Field( + description="The deriviative of compliance with respect to each densitiy variable." + ) + + +class SIMPElasticity: + """SIMP-based topology optimization solver using ANSYS MAPDL. + + This class encapsulates the full workflow for running a SIMP + (Solid Isotropic Material with Penalization) topology optimization + analysis using ANSYS MAPDL for finite element analysis. + """ + + def __init__(self, inputs: InputSchema, mapdl: Mapdl) -> None: + """Initialize the SIMP elasticity solver. + + Args: + inputs: Input parameters for the simulation + mapdl: Active MAPDL instance + """ + # Store inputs + self.inputs = inputs + self.mapdl = mapdl + + # Extract input parameters + self.rho = inputs.rho + self.Lx = inputs.Lx + self.Ly = inputs.Ly + self.Lz = inputs.Lz + self.Nx = inputs.Nx + self.Ny = inputs.Ny + self.Nz = inputs.Nz + self.E0 = inputs.E0 + self.rho_min = inputs.rho_min + self.total_force = inputs.total_force + self.p = inputs.p + self.log_level = inputs.log_level + self.vtk_output = inputs.vtk_output + + # Configure logger + logger.setLevel(getattr(logging, self.log_level.upper(), logging.INFO)) + # Add console handler if not already present + if not logger.handlers: + console_handler = logging.StreamHandler() + console_handler.setLevel(logging.DEBUG) + formatter = logging.Formatter( + "%(asctime)s - %(name)s - %(levelname)s - %(message)s" + ) + console_handler.setFormatter(formatter) + logger.addHandler(console_handler) + + # Initialize result storage + self.element_numbers = None # Store actual MAPDL element numbers + self.n_elements = None + self.node_numbers = None # Store actual MAPDL node numbers + self.n_nodes = None + self.displacement_constraints = None + self.nodal_displacement = None + self.nodal_force = None + self.strain_energy = None + self.compliance = None + self.sensitivity = None + self.pvmesh = None + + @log_timing + def solve(self) -> OutputSchema: + """Run the complete SIMP analysis workflow. + + Returns: + OutputSchema containing compliance, strain energy, and sensitivity + """ + logger.info("Starting SIMP elasticity analysis...") + + self._create_geometry() + self._define_element() + self._create_mesh() + self._define_simp_materials() + self._assign_materials_to_elements() + self._apply_boundary_conditions() + self._run_analysis() + self._extract_displacement_constraints() + self._extract_nodal_displacement() + self._extract_nodal_force() + self._extract_strain_energy() + self._calculate_compliance() + self._calculate_sensitivity() + if self.vtk_output: + self._create_pvmesh() + + logger.info("SIMP analysis complete!") + logger.debug(f"MAPDL status: {self.mapdl}") + + return self._build_output_schema() + + @log_timing + def _create_geometry(self) -> None: + """Create a rectangular block geometry. + + Creates 8 keypoints at the corners of a rectangular box and defines + a volume from these keypoints. + """ + # start pre-processor + self.mapdl.prep7() + + k0 = self.mapdl.k("", 0, 0, 0) + k1 = self.mapdl.k("", self.Lx, 0, 0) + k2 = self.mapdl.k("", self.Lx, self.Ly, 0) + k3 = self.mapdl.k("", 0, self.Ly, 0) + k4 = self.mapdl.k("", 0, 0, self.Lz) + k5 = self.mapdl.k("", self.Lx, 0, self.Lz) + k6 = self.mapdl.k("", self.Lx, self.Ly, self.Lz) + k7 = self.mapdl.k("", 0, self.Ly, self.Lz) + + self.mapdl.v(k0, k1, k2, k3, k4, k5, k6, k7) + + @log_timing + def _define_simp_materials(self) -> None: + """Define materials using SIMP approach with batch commands for efficiency. + + Uses the SIMP (Solid Isotropic Material with Penalization) method to + scale material properties based on density values. Creates a unique + material for each element. + """ + # Flatten rho array and ensure it matches the number of elements + rho_flat = np.array(self.rho).flatten() + + if len(rho_flat) != self.n_elements: + raise ValueError( + f"Density field size {len(rho_flat)} does not match " + f"number of elements {self.n_elements} (Nx={self.Nx}, Ny={self.Ny}, Nz={self.Nz})" + ) + + # Apply minimum density constraint to avoid singular stiffness matrix + # Calculate all material properties at once + # SIMP formula: E = E0 * rho^p + E_values = self.E0 * (self.rho_min + (1 - self.rho_min) * (rho_flat**self.p)) + dens_values = self.rho_min + (1 - self.rho_min) * rho_flat + + # Build all commands as a list for batch execution + commands = [] + for i in range(len(rho_flat)): + mat_id = i + 1 + commands.append(f"MP,EX,{mat_id},{E_values[i]}") + commands.append(f"MP,DENS,{mat_id},{dens_values[i]}") + commands.append(f"MP,NUXY,{mat_id},0.3") + + # Execute all commands at once using input_strings + self.mapdl.input_strings(commands) + + @log_timing + def _define_element(self) -> None: + """Define element type for structural analysis. + + Sets element type 1 to SOLID186, a 20-node 3D structural solid element + with quadratic displacement behavior. + """ + self.mapdl.et(1, "SOLID186") + + @log_timing + def _assign_materials_to_elements(self) -> None: + """Assign materials to elements after meshing using batch commands. + + For a structured mesh with Nx x Ny x Nz elements, this assigns + material ID to each element based on the stored element numbers. + Material i+1 is assigned to the element at position i in the element_numbers array. + """ + # Get all element numbers from the mesh + self.mapdl.allsel() + + # Build all EMODIF commands as a list for batch execution + # Use actual element numbers instead of assuming sequential 1, 2, 3, ... + commands = [] + for i in range(self.n_elements): + elem_id = self.element_numbers[i] # Use actual element number from mesh + mat_id = i + 1 # Material index corresponds to density array index + commands.append(f"EMODIF,{elem_id},MAT,{mat_id}") + + # Execute all commands at once using input_strings + self.mapdl.input_strings(commands) + + @log_timing + def _create_mesh(self) -> None: + """Create structured hexahedral mesh with specified divisions. + + Sets line divisions for each direction and generates a swept mesh using + VSWEEP. The resulting mesh will have Nx * Ny * Nz elements with uniform + element sizes in each direction. + """ + # Set element divisions for lines in each direction using ndiv parameter + # Lines parallel to X-axis (select by 2 constant coordinates) + self.mapdl.lsel("s", "loc", "y", 0) + self.mapdl.lsel("r", "loc", "z", 0) + self.mapdl.lesize("all", ndiv=self.Nx, kforc=1) + + self.mapdl.lsel("s", "loc", "y", self.Ly) + self.mapdl.lsel("r", "loc", "z", 0) + self.mapdl.lesize("all", ndiv=self.Nx, kforc=1) + + self.mapdl.lsel("s", "loc", "y", 0) + self.mapdl.lsel("r", "loc", "z", self.Lz) + self.mapdl.lesize("all", ndiv=self.Nx, kforc=1) + + self.mapdl.lsel("s", "loc", "y", self.Ly) + self.mapdl.lsel("r", "loc", "z", self.Lz) + self.mapdl.lesize("all", ndiv=self.Nx, kforc=1) + + # Lines parallel to Y-axis (select by 2 constant coordinates) + self.mapdl.lsel("s", "loc", "x", 0) + self.mapdl.lsel("r", "loc", "z", 0) + self.mapdl.lesize("all", ndiv=self.Ny, kforc=1) + + self.mapdl.lsel("s", "loc", "x", self.Lx) + self.mapdl.lsel("r", "loc", "z", 0) + self.mapdl.lesize("all", ndiv=self.Ny, kforc=1) + + self.mapdl.lsel("s", "loc", "x", 0) + self.mapdl.lsel("r", "loc", "z", self.Lz) + self.mapdl.lesize("all", ndiv=self.Ny, kforc=1) + + self.mapdl.lsel("s", "loc", "x", self.Lx) + self.mapdl.lsel("r", "loc", "z", self.Lz) + self.mapdl.lesize("all", ndiv=self.Ny, kforc=1) + + # Lines parallel to Z-axis (select by 2 constant coordinates) + self.mapdl.lsel("s", "loc", "x", 0) + self.mapdl.lsel("r", "loc", "y", 0) + self.mapdl.lesize("all", ndiv=self.Nz, kforc=1) + + self.mapdl.lsel("s", "loc", "x", self.Lx) + self.mapdl.lsel("r", "loc", "y", 0) + self.mapdl.lesize("all", ndiv=self.Nz, kforc=1) + + self.mapdl.lsel("s", "loc", "x", 0) + self.mapdl.lsel("r", "loc", "y", self.Ly) + self.mapdl.lesize("all", ndiv=self.Nz, kforc=1) + + self.mapdl.lsel("s", "loc", "x", self.Lx) + self.mapdl.lsel("r", "loc", "y", self.Ly) + self.mapdl.lesize("all", ndiv=self.Nz, kforc=1) + + # Restore full selection of entities + self.mapdl.allsel() + + # Mesh the volume using the swept mesh command + self.mapdl.vsweep("all") + + # Store element numbers in the order they were created + # This is crucial for maintaining consistent indexing between + # density input and strain energy output + self.element_numbers = self.mapdl.mesh.enum + + # Validate and log element numbering + n_elements = self.Nx * self.Ny * self.Nz + if len(self.element_numbers) != n_elements: + raise ValueError( + f"Number of created elements {len(self.element_numbers)} does not match " + f"expected {n_elements} (Nx={self.Nx}, Ny={self.Ny}, Nz={self.Nz})" + ) + self.n_elements = n_elements + + # Repeat validation for nodes + self.node_numbers = self.mapdl.mesh.nnum + self.n_nodes = len(self.node_numbers) + + logger.debug( + f"Element numbers: min={self.element_numbers.min()}, " + f"max={self.element_numbers.max()}, " + f"first 5={self.element_numbers[:5]}" + ) + + # Check if element numbering is sequential starting from 1 + is_sequential = np.array_equal( + self.element_numbers, np.arange(1, n_elements + 1) + ) + if is_sequential: + logger.info("Element numbering is sequential (1, 2, 3, ...)") + else: + logger.warning( + "Element numbering is NOT sequential - reordering will be applied" + ) + + @log_timing + def _apply_boundary_conditions(self) -> None: + """Apply boundary conditions, forces, and visualize. + + Fixes all nodes on the x=0 plane by constraining all translational + degrees of freedom (UX, UY, UZ). Then applies a concentrated force + in the negative z-direction to nodes at x=Lx, y=Ly, and z between + 0.4*Lz and 0.6*Lz. + """ + # Select all nodes on the x=0 plane + self.mapdl.nsel("s", "loc", "x", 0) + + # Apply displacement constraints (fix all DOFs: UX, UY, UZ) + self.mapdl.d("all", "all", 0) + + # Reselect all nodes + self.mapdl.allsel() + + # Apply force to nodes at x=Lx, y=0, z between 0.4*Lz and 0.6*Lz + # Select nodes at x=Lx + self.mapdl.nsel("s", "loc", "x", self.Lx) + + # Refine selection between y=0 and y=0.2 Ly + y_max = 0.2 * self.Ly + self.mapdl.nsel("r", "loc", "y", 0, y_max) + + # Refine selection to z between 0.4*Lz and 0.6*Lz + z_min = 0.4 * self.Lz + z_max = 0.6 * self.Lz + self.mapdl.nsel("r", "loc", "z", z_min, z_max) + + # Get number of selected nodes + num_nodes = self.mapdl.mesh.n_node + + # Calculate force per node (negative for downward direction) + force_per_node = -self.total_force / num_nodes + + # Apply force in negative z-direction to all selected nodes + self.mapdl.f("all", "fz", force_per_node) + + # Reselect all nodes + self.mapdl.allsel() + + logger.info( + f"Applied total force of {self.total_force} N distributed over {num_nodes} nodes" + ) + + @log_timing + def _run_analysis(self) -> None: + """Run static structural analysis.""" + self.mapdl.slashsolu() + self.mapdl.allsel() # making sure all nodes and elements are selected. + self.mapdl.antype("STATIC") + self.mapdl.ematwrite("YES") + output = self.mapdl.solve() + self.mapdl.save("my_analysis") + self.mapdl.finish() + + logger.debug(f"Analysis output: {output}") + + @log_timing + def _extract_strain_energy(self) -> None: + """Extract strain energy for all elements and save to file. + + Uses APDL commands to extract strain energy from element table and + write to a text file, then reorders to match input density array indexing. + + The *VGET command retrieves data in element number order (sorted by element ID), + so we must reorder the results to match the element_numbers array order. + """ + logger.debug("Extracting strain energy data...") + + # Enter POST1 mode if not already there + self.mapdl.post1() + self.mapdl.set(1, 1) # Load first load step, first substep + + # Create element table for strain energy + self.mapdl.etable("SENE", "SENE") + + # Create array parameter and populate with strain energy values + # *VGET retrieves element table values into an array parameter + self.mapdl.run(f"*DIM,strain_e,ARRAY,{self.n_elements},1") + self.mapdl.run("*VGET,strain_e,ELEM,1,ETAB,SENE, , ,2") + + # Write strain energy to text file using non_interactive mode for file operations + # this is much faster than using a get command + with self.mapdl.non_interactive: + self.mapdl.run("*CFOPEN,strain_energy,txt") + self.mapdl.run("*VWRITE,strain_e(1,1)") + self.mapdl.run("(E15.7)") + self.mapdl.run("*CFCLOS") + + # Download the file from the MAPDL working directory + self.mapdl.download("strain_energy.txt", ".") + + # Read the data - this is in sorted element number order + strain_energy_sorted = np.loadtxt("strain_energy.txt") + + # Create mapping from element numbers to their position in sorted order + # The *VGET command returns data sorted by element ID + sorted_element_numbers = np.sort(self.element_numbers) + + # Create inverse mapping: for each element in self.element_numbers, + # find its position in the sorted array + # This tells us where to find each element's data in strain_energy_sorted + reorder_indices = np.searchsorted(sorted_element_numbers, self.element_numbers) + + # Reorder strain energy to match the order of self.element_numbers + # (which matches the input density array order) + self.strain_energy = strain_energy_sorted[reorder_indices] + + logger.debug( + f"Strain energy reordered: first 5 values = {self.strain_energy[:5]}" + ) + + @log_timing + def _extract_nodal_displacement(self) -> None: + nodal_displacement = np.zeros((self.n_nodes, 3)) + nnum, disp = self.mapdl.result.nodal_displacement(0) # 0 for first result set + # populate nodal_displacement using vectorized NumPy indexing + nodal_displacement[nnum - 1] = disp + self.nodal_displacement = nodal_displacement + + @log_timing + def _extract_nodal_force(self) -> None: + nodal_force = np.zeros((self.n_nodes, 3)) + # populate force using vectorized NumPy advanced indexing + nnum, dof_idx, f = self.mapdl.result.nodal_input_force(0) + node_indices = nnum - 1 + dof_indices = dof_idx - 1 + nodal_force[node_indices, dof_indices] = f + self.nodal_force = nodal_force + + @log_timing + def _extract_displacement_constraints(self) -> None: + displacement_constraints = np.zeros((self.n_nodes, 3)) + # Get a list of all nodal constraints and process with optimized mapping + nodal_constraints = self.mapdl.get_nodal_constrains() + + constraint_map = {"UX": 0, "UY": 1, "UZ": 2} + for idx, field, _, _ in nodal_constraints: + dof = constraint_map.get(field) + if dof is not None: + node_num = int(idx) - 1 + displacement_constraints[node_num, dof] = 1.0 + self.displacement_constraints = displacement_constraints + + @log_timing + def _calculate_compliance(self) -> None: + """Calculate compliance from nodal forces and displacements.""" + self.compliance = np.dot( + self.nodal_force.flatten(), self.nodal_displacement.flatten() + ) + + @log_timing + def _calculate_sensitivity(self) -> None: + """Calculate sensitivity of compliance with respect to density. + + For this special case, the adjoint solution is equal to -U, + so the sensitivity is equal to: + - U_e^T * (dK_e / drho) * U_e + = - (p/rho) * U_e^T * K_e * U_e + = - 2 * (p/rho) * strain_energy + """ + inverse_rho = np.nan_to_num(1 / self.rho.flatten(), nan=0.0) + self.sensitivity = -2.0 * self.p * inverse_rho * self.strain_energy.flatten() + + # TODO improve this cache? + # stash the sensitivity s.t. it may be loaded in the vjp + np.save("sensitivity.npy", self.sensitivity) + + @log_timing + def _create_pvmesh(self) -> None: + """Create PyVista grid with analysis results. + + Creates a PyVista grid containing the mesh geometry with density and + Young's modulus values stored as cell data, and displacement constraints, + applied forces, and nodal displacements stored as point data (node data). + """ + logger.debug("Creating PyVista results grid...") + + # Enter POST1 to access solution results + self.mapdl.post1() + self.mapdl.set(1, 1) + + # Try to get mesh directly from result object to avoid disk I/O + # The result.grid property provides direct access to PyVista mesh + try: + self.pvmesh = self.mapdl.result.grid + logger.debug("Successfully loaded mesh directly from result.grid") + except (AttributeError, Exception) as e: + # Fallback to file-based approach if direct access fails + logger.debug(f"Direct grid access failed ({e}), using file-based approach") + self.mapdl.download_result(".") + + show_progress = logger.level <= logging.INFO + self.mapdl.result.save_as_vtk("file.vtk", progress_bar=show_progress) + + self.pvmesh = pv.read("file.vtk") + + # add attributes + rho_flat = np.array(self.rho).flatten() + self.pvmesh.cell_data["density"] = self.__convert_celldata_for_pv(rho_flat) + self.pvmesh.cell_data["strain_energy"] = self.__convert_celldata_for_pv( + self.strain_energy + ) + self.pvmesh.cell_data["sensitivity"] = self.__convert_celldata_for_pv( + self.sensitivity + ) + self.pvmesh.point_data["displacement_constraints"] = ( + self.displacement_constraints + ) + self.pvmesh.point_data["nodal_displacement"] = self.nodal_displacement + self.pvmesh.point_data["nodal_force"] = self.nodal_force + + # Export to VTK + self.pvmesh.save(self.vtk_output) + + logger.info("Exported results to mesh_density.vtk") + + def __convert_celldata_for_pv(self, elem_array: np.array) -> np.array: + """Convert cell_data to follow pyvista cell ordering.""" + # PyVista cells may be ordered differently than our element_numbers array + # Get PyVista cell to MAPDL element number mapping + pv_elem_nums = self.pvmesh.cell_data["ansys_elem_num"] + + # Create mapping: for each PyVista cell, find the corresponding density + array_for_pv = np.zeros(len(pv_elem_nums)) + for pv_idx, mapdl_elem_num in enumerate(pv_elem_nums): + # Find where this MAPDL element number appears in self.element_numbers + array_idx = np.where(self.element_numbers == mapdl_elem_num)[0][0] + array_for_pv[pv_idx] = elem_array[array_idx] + return array_for_pv + + def _build_output_schema(self) -> OutputSchema: + """Build and return the output schema.""" + return OutputSchema( + compliance=self.compliance, + strain_energy=self.strain_energy.flatten(), + sensitivity=self.sensitivity, + ) + + +def apply(inputs: InputSchema) -> OutputSchema: + """Run the tess_simp_compliance Tesseract. + + Args: + inputs: Input parameters for the SIMP elasticity analysis + + Returns: + OutputSchema containing compliance, strain energy, and sensitivity + """ + # Initialize MAPDL + mapdl = Mapdl(inputs.host, port=inputs.port) + mapdl.clear() + + # Create solver instance and run analysis + solver = SIMPElasticity(inputs, mapdl) + return solver.solve() + + +# TODO +# def vector_jacobian_product( +# inputs: InputSchema, +# vjp_inputs: set[str], +# vjp_outputs: set[str], +# cotangent_vector: dict[str, Any], +# ): +# pass +# +# +# def abstract_eval(abstract_inputs): +# """Calculate output shape of apply from the shape of its inputs.""" +# return {"compliance": ShapeDType(shape=(), dtype="float32")} diff --git a/examples/ansys/pymapdl_tess/tesseract_config.yaml b/examples/ansys/pymapdl_tess/tesseract_config.yaml new file mode 100644 index 0000000..f2932ec --- /dev/null +++ b/examples/ansys/pymapdl_tess/tesseract_config.yaml @@ -0,0 +1,27 @@ +# Tesseract configuration file + +name: "tess_simp_compliance" +version: "0.0.0" +description: "Evaluate compliance using the SIMP material model" + +build_config: + # Base image to use for the container, must be Ubuntu or Debian-based + # with Python 3.9 or later + # base_image: "python:3.12-slim-bookworm" + + # Platform to build the container for. In general, images can only be executed + # on the platform they were built for. + # target_platform: "native" + + # Additional packages to install in the container (via apt-get) + # extra_packages: + # - package_name + + # Data to copy into the container, relative to the project root + # package_data: + # - [path/to/source, path/to/destination] + + # Additional Dockerfile commands to run during the build process + # custom_build_steps: + # - | + # RUN echo "Hello, World!" diff --git a/examples/ansys/pymapdl_tess/tesseract_requirements.txt b/examples/ansys/pymapdl_tess/tesseract_requirements.txt new file mode 100644 index 0000000..319ed74 --- /dev/null +++ b/examples/ansys/pymapdl_tess/tesseract_requirements.txt @@ -0,0 +1,3 @@ +ansys-mapdl-core +numpy==1.26.4 +pyvista==0.45.2 diff --git a/examples/ansys/pymapdl_tess/test.py b/examples/ansys/pymapdl_tess/test.py new file mode 100644 index 0000000..4187cba --- /dev/null +++ b/examples/ansys/pymapdl_tess/test.py @@ -0,0 +1,83 @@ +import os + +import numpy as np +from dotenv import load_dotenv +from tesseract_core import Tesseract + +load_dotenv() + +host = os.getenv("MAPDL_HOST") +if host is None: + raise ValueError("Unable to read $MAPDL_HOST from the environment.") +port = os.getenv("MAPDL_PORT") +if port is None: + raise ValueError("Unable to read $MAPDL_PORT from the environment.") + + +tess_simp_compliance = Tesseract.from_tesseract_api( + "tesseract_pymapdl/tess_simp_compiance/tesseract_api.py" +) +Lx, Ly, Lz = 3, 2, 1 +Nx, Ny, Nz = 60, 40, 20 +# Nx, Ny, Nz = 6, 4, 2 + +n_elem = Nx * Ny * Nz +# Create a test density field varying from 0 to 1 +rho = (np.arange(0, n_elem, 1) / n_elem).reshape((n_elem, 1)) +rho = 0.5 * np.ones((n_elem, 1)) + + +inputs = { + "host": host, + "port": port, + "rho": rho, + "Lx": Lx, + "Ly": Ly, + "Lz": Lz, + "Nx": Nx, + "Ny": Ny, + "Nz": Nz, + "E0": 1.0, + "rho_min": 1e-6, + "total_force": 0.1, + "log_level": "DEBUG", + "vtk_output": "mesh_density.vtk", +} + +outputs = tess_simp_compliance.apply(inputs) + +# Verify relationship between compliance and strain energy +# For static analysis: Total Strain Energy = 0.5 * Compliance +strain_energy = outputs["strain_energy"] +compliance = outputs["compliance"] +total_strain_energy = np.sum(strain_energy) +print(f"\nCompliance: {compliance:.6e}") +print(f"Total Strain Energy: {total_strain_energy:.6e}") +print(f"0.5 * Compliance: {0.5 * compliance:.6e}") +print(f"Ratio (should be ~1.0): {total_strain_energy / (0.5 * compliance):.6f}") + +# Finite difference check +num_tests = 0 # set to 0 if you don't want to run this check +FD_delta = 1.0e-3 +f0 = outputs["compliance"] +sensitivity = outputs["sensitivity"] +FD_sensitivity = 0 * sensitivity +for i in range(num_tests): + print(i) + inputs["rho"][i] += FD_delta + outputs = tess_simp_compliance.apply(inputs) + fupp = outputs["compliance"] + FD_sensitivity[i] = (fupp - f0) / FD_delta + inputs["rho"][i] -= FD_delta + + +if num_tests > 0: + sens = sensitivity[0:num_tests] + FD_sens = FD_sensitivity[0:num_tests] + print(sens) + print(FD_sens) + errors = sens - FD_sens + print(errors) + rel_abs_error = np.abs(errors / sens) + print(rel_abs_error) + print(f"Should be under 1e-5: {np.max(rel_abs_error)}") diff --git a/examples/ansys/requirements.txt b/examples/ansys/requirements.txt new file mode 100644 index 0000000..e43a86c --- /dev/null +++ b/examples/ansys/requirements.txt @@ -0,0 +1,6 @@ +jax[cpu]==0.5.3 +matplotlib==3.10.3 +optax==0.2.5 +pyvista==0.45.2 +tesseract-jax +tesseract-core[runtime] diff --git a/examples/ansys/rho_optim.gif b/examples/ansys/rho_optim.gif new file mode 100644 index 0000000..b80c32d Binary files /dev/null and b/examples/ansys/rho_optim.gif differ diff --git a/examples/ansys/rho_optim_sum_2.gif b/examples/ansys/rho_optim_sum_2.gif new file mode 100644 index 0000000..71b85d9 Binary files /dev/null and b/examples/ansys/rho_optim_sum_2.gif differ diff --git a/examples/ansys/rho_optim_x.gif b/examples/ansys/rho_optim_x.gif new file mode 100644 index 0000000..108bcaf Binary files /dev/null and b/examples/ansys/rho_optim_x.gif differ diff --git a/examples/ansys/sdf_fd_tess/tesseract_api.py b/examples/ansys/sdf_fd_tess/tesseract_api.py new file mode 100644 index 0000000..85f8d73 --- /dev/null +++ b/examples/ansys/sdf_fd_tess/tesseract_api.py @@ -0,0 +1,495 @@ +from concurrent.futures import ThreadPoolExecutor +from functools import lru_cache +from typing import Any + +import numpy as np +import trimesh +from pydantic import BaseModel, Field +from pysdf import SDF +from tesseract_core.runtime import Array, Differentiable, Float32, Int32, ShapeDType +from tesseract_core.runtime.experimental import TesseractReference + +# +# Schemata +# + + +class InputSchema(BaseModel): + """Input schema for bar geometry design and SDF generation.""" + + differentiable_parameters: Differentiable[ + Array[ + (None,), + Float32, + ] + ] = Field( + description="Flattened array of geometry parameters that are passed to the mesh_tesseract." + ) + + normalization_factors: Array[ + (None,), + Float32, + ] = Field( + description="Normalization factors for the differentiable geometry parameters." + ) + + normalization_bias: Array[ + (None,), + Float32, + ] = Field( + description="Normalization bias for the differentiable geometry parameters." + ) + + non_differentiable_parameters: Array[ + (None,), + Float32, + ] = Field(description="Flattened array of non-differentiable geometry parameters.") + + static_parameters: list[int] = Field( + description=("List of static integers used to construct the geometry.") + ) + + string_parameters: list[str] = Field( + description=("List of string parameters used to construct the geometry.") + ) + + mesh_tesseract: TesseractReference = Field(description="Tesseract to call.") + + scale_mesh: float = Field( + default=1.0, + description="Scaling factor applied to the generated mesh.", + ) + + grid_size: list[float] = Field( + description="Size of the bounding box in x, y, z directions." + ) + + grid_elements: list[int] = Field( + description="Number of elements in the bounding box in x, y, z directions." + ) + + grid_center: list[float] = Field( + description="Center of the bounding box in x, y, z directions." + ) + + epsilon: float = Field( + default=1e-5, + description=( + "Epsilon value for finite difference approximation of the Jacobian. " + ), + ) + normalize_jacobian: bool = Field( + default=False, + description=("Whether to normalize the Jacobian by the number of elements"), + ) + precompute_jacobian: bool = Field( + default=False, + description=("Whether to precompute the Jacobian for faster VJP computation."), + ) + max_points: int = Field( + default=1000, + description=("Maximum number of points in the output mesh."), + ) + max_faces: int = Field( + default=2000, + description=("Maximum number of faces in the output mesh."), + ) + + +class TriangularMesh(BaseModel): + """Triangular mesh representation with fixed-size arrays.""" + + points: Array[(None, 3), Float32] = Field(description="Array of vertex positions.") + faces: Array[(None, 3), Int32] = Field( + description="Array of triangular faces defined by indices into the points array." + ) + n_points: Int32 = Field( + default=0, description="Number of valid points in the points array." + ) + n_faces: Int32 = Field( + default=0, description="Number of valid faces in the faces array." + ) + + +class OutputSchema(BaseModel): + """Output schema for generated geometry and SDF field.""" + + mesh: TriangularMesh = Field( + description="Triangular mesh representation of the geometry" + ) + sdf: Differentiable[ + Array[ + (None, None, None), + Float32, + ] + ] = Field(description="SDF field of the geometry") + + +# +# Helper functions +# + + +def denormalize_parameters( + differentiable_parameters: list[np.ndarray], + normalization_factors: np.ndarray, + normalization_bias: np.ndarray, +) -> list[np.ndarray]: + """Denormalize the differentiable parameters.""" + denormalized_params = [] + for params in differentiable_parameters: + denormalized_params.append( + (params - normalization_bias) / normalization_factors + ) + return denormalized_params + + +def get_geometries( + target: TesseractReference, + differentiable_parameters: list[np.ndarray], + normalization_factors: np.ndarray, + normalization_bias: np.ndarray, + non_differentiable_parameters: list[np.ndarray], + static_parameters: list[list[int]], + string_parameters: list[str], +) -> list[trimesh.Trimesh]: + """Call the tesseract reference to get the geometries.""" + differentiable_parameters = denormalize_parameters( + differentiable_parameters, normalization_factors, normalization_bias + ) + + meshes = target.apply( + { + "differentiable_parameters": differentiable_parameters, + "non_differentiable_parameters": non_differentiable_parameters, + "static_parameters": static_parameters, + "string_parameters": string_parameters, + } + )["meshes"] + + meshes = [ + trimesh.Trimesh( + vertices=mesh["points"], + faces=mesh["faces"], + ) + for mesh in meshes + ] + + return meshes + + +@lru_cache(maxsize=1) +def grid_points( + Lx: float, + Ly: float, + Lz: float, + Nx: int, + Ny: int, + Nz: int, + grid_center: tuple[float, float, float], +) -> tuple[np.ndarray, np.ndarray, np.ndarray]: + """Create a regular grid in 3D space.""" + x, y, z = np.meshgrid( + np.linspace(-Lx / 2, Lx / 2, Nx) + grid_center[0], + np.linspace(-Ly / 2, Ly / 2, Ny) + grid_center[1], + np.linspace(-Lz / 2, Lz / 2, Nz) + grid_center[2], + indexing="ij", + ) + + return np.vstack((x.ravel(), y.ravel(), z.ravel())).T + + +def compute_sdf( + geometry: trimesh.Trimesh, + grid_center: list[float], + Lx: float, + Ly: float, + Lz: float, + Nx: int, + Ny: int, + Nz: int, +) -> np.ndarray: + """Compute the signed distance field of a geometry on a regular grid.""" + points, faces = geometry.vertices, geometry.faces + + sdf_function = SDF(points, faces) + + points = grid_points( + Lx=Lx, + Ly=Ly, + Lz=Lz, + Nx=Nx, + Ny=Ny, + Nz=Nz, + grid_center=tuple(grid_center), + ) + + sdf_values = sdf_function(points).astype(np.float32) + + sd_field = sdf_values.reshape((Nx, Ny, Nz)) + + return -sd_field + + +def geometries_and_sdf( + target: TesseractReference, + differentiable_parameters: list[np.ndarray], + non_differentiable_parameters: list[np.ndarray], + normalization_factors: np.ndarray, + normalization_bias: np.ndarray, + static_parameters: list[list[int]], + string_parameters: list[str], + scale_mesh: float, + grid_size: np.ndarray, + grid_elements: np.ndarray, + grid_center: np.ndarray, +) -> tuple[list[np.ndarray], list[trimesh.Trimesh]]: + """Get the sdf values of a the geometry defined by the parameters as a 2D array.""" + geos = get_geometries( + target=target, + differentiable_parameters=differentiable_parameters, + non_differentiable_parameters=non_differentiable_parameters, + normalization_factors=normalization_factors, + normalization_bias=normalization_bias, + static_parameters=static_parameters, + string_parameters=string_parameters, + ) + # scale the mesh + geos = [geo.apply_scale(scale_mesh) for geo in geos] + + sd_fields = [ + compute_sdf( + geo, + grid_center=grid_center, + Lx=grid_size[0], + Ly=grid_size[1], + Lz=grid_size[2], + Nx=grid_elements[0], + Ny=grid_elements[1], + Nz=grid_elements[2], + ) + for geo in geos + ] + + return sd_fields, geos + + +# +# Tesseract endpoints +# +jacobian_future = None +executor = None + + +def apply(inputs: InputSchema) -> OutputSchema: + """Generate mesh and SDF from bar geometry parameters. + + Args: + inputs: Input schema containing bar geometry parameters. + + Returns: + Output schema with generated mesh and SDF field. + """ + sdfs, meshes = geometries_and_sdf( + target=inputs.mesh_tesseract, + differentiable_parameters=[inputs.differentiable_parameters], + non_differentiable_parameters=[inputs.non_differentiable_parameters], + static_parameters=[inputs.static_parameters], + string_parameters=inputs.string_parameters, + normalization_factors=inputs.normalization_factors, + normalization_bias=inputs.normalization_bias, + grid_size=inputs.grid_size, + scale_mesh=inputs.scale_mesh, + grid_elements=inputs.grid_elements, + grid_center=inputs.grid_center, + ) + + sdf = sdfs[0] # only one geometry + mesh = meshes[0] + + points = np.zeros((inputs.max_points, 3), dtype=np.float32) + faces = np.zeros((inputs.max_faces, 3), dtype=np.int32) + + points[: mesh.vertices.shape[0], :] = mesh.vertices.astype(np.float32) + faces[: mesh.faces.shape[0], :] = mesh.faces.astype(np.int32) + + # start a new thread to precompute the jacobian if requested + if inputs.precompute_jacobian: + print("Starting Jacobian precomputation thread...") + executor = ThreadPoolExecutor(max_workers=1) + future = executor.submit( + jac_sdf_wrt_params, + target=inputs.mesh_tesseract, + differentiable_parameters=inputs.differentiable_parameters, + non_differentiable_parameters=inputs.non_differentiable_parameters, + static_parameters=inputs.static_parameters, + string_parameters=inputs.string_parameters, + normalization_factors=inputs.normalization_factors, + normalization_bias=inputs.normalization_bias, + scale_mesh=inputs.scale_mesh, + grid_size=inputs.grid_size, + grid_elements=inputs.grid_elements, + grid_center=inputs.grid_center, + epsilon=inputs.epsilon, + ) + + global jacobian_future + jacobian_future = future + + return OutputSchema( + sdf=sdf.astype(np.float32), + mesh=TriangularMesh( + points=points, + faces=faces, + n_points=mesh.vertices.shape[0], + n_faces=mesh.faces.shape[0], + ), + ) + + +def jac_sdf_wrt_params( + target: TesseractReference, + differentiable_parameters: np.ndarray, + non_differentiable_parameters: np.ndarray, + normalization_factors: np.ndarray, + normalization_bias: np.ndarray, + static_parameters: list[int], + string_parameters: list[str], + scale_mesh: float, + grid_size: np.ndarray, + grid_elements: np.ndarray, + grid_center: np.ndarray, + epsilon: float, +) -> np.ndarray: + """Compute the Jacobian of the SDF values with respect to the parameters. + + The Jacobian is computed by finite differences. + The shape of the Jacobian is (n_chains, n_edges_per_chain + 1, 3, Nx, Ny). + """ + jac = np.zeros( + ( + differentiable_parameters.size, + grid_elements[0], + grid_elements[1], + grid_elements[2], + ) + ) + + params = [] + params.append(differentiable_parameters.copy()) + + n_params = differentiable_parameters.size + + for i in range(n_params): + # we only care about the y and z coordinate + params_eps = differentiable_parameters.copy() + params_eps[i] += epsilon + params.append(params_eps) + + sdf_fields, _ = geometries_and_sdf( + target=target, + differentiable_parameters=params, + non_differentiable_parameters=[non_differentiable_parameters] * (n_params + 1), + normalization_factors=normalization_factors, + normalization_bias=normalization_bias, + static_parameters=[static_parameters] * (n_params + 1), + string_parameters=string_parameters, + scale_mesh=scale_mesh, + grid_elements=grid_elements, + grid_size=grid_size, + grid_center=grid_center, + ) + + for i in range(n_params): + jac[i] = (sdf_fields[i + 1] - sdf_fields[0]) / epsilon + + return jac.astype(np.float32) + + +def vector_jacobian_product( + inputs: InputSchema, + vjp_inputs: set[str], + vjp_outputs: set[str], + cotangent_vector: dict[str, Any], +) -> dict[str, Any]: + """Compute vector-Jacobian product for backpropagation. + + Args: + inputs: Input schema containing bar geometry parameters. + vjp_inputs: Set of input variable names for gradient computation. + vjp_outputs: Set of output variable names for gradient computation. + cotangent_vector: Cotangent vectors for the specified outputs. + + Returns: + Dictionary containing VJP for the specified inputs. + """ + assert vjp_inputs == {"differentiable_parameters"} + assert vjp_outputs == {"sdf"} + + # lets also check if the thread is still running + if jacobian_future is not None: + print("Using precomputed Jacobian...") + if not jacobian_future.done(): + print("Waiting for Jacobian precomputation to finish...") + jac = jacobian_future.result() + + print("Jacobian precomputation finished.") + print(f"Jacobian shape: {jac.shape} and type: {jac.dtype}") + else: + print("Computing Jacobian...") + jac = jac_sdf_wrt_params( + target=inputs.mesh_tesseract, + differentiable_parameters=inputs.differentiable_parameters, + non_differentiable_parameters=inputs.non_differentiable_parameters, + normalization_factors=inputs.normalization_factors, + normalization_bias=inputs.normalization_bias, + static_parameters=inputs.static_parameters, + string_parameters=inputs.string_parameters, + scale_mesh=inputs.scale_mesh, + grid_size=inputs.grid_size, + grid_elements=inputs.grid_elements, + epsilon=inputs.epsilon, + grid_center=inputs.grid_center, + ) + if inputs.normalize_jacobian: + n_elements = ( + inputs.grid_elements[0] * inputs.grid_elements[1] * inputs.grid_elements[2] + ) + jac = jac / n_elements + # Reduce the cotangent vector to the shape of the Jacobian, to compute VJP by hand + vjp = np.einsum("klmn,lmn->k", jac, cotangent_vector["sdf"]) + + return {"differentiable_parameters": vjp} + + +def abstract_eval(abstract_inputs: InputSchema) -> dict: + """Calculate output shape of apply from the shape of its inputs. + + Args: + abstract_inputs: Input schema with parameter shapes. + + Returns: + Dictionary describing output shapes and dtypes. + """ + return { + "sdf": ShapeDType( + shape=( + abstract_inputs.grid_elements[0], + abstract_inputs.grid_elements[1], + abstract_inputs.grid_elements[2], + ), + dtype="float32", + ), + "mesh": { + "points": ShapeDType( + shape=(abstract_inputs.max_points, 3), dtype="float32" + ), + "faces": ShapeDType(shape=(abstract_inputs.max_faces, 3), dtype="int32"), + "n_points": ShapeDType(shape=(), dtype="int32"), + "n_faces": ShapeDType(shape=(), dtype="int32"), + }, + } + + +if executor is not None: + executor.shutdown() diff --git a/examples/ansys/sdf_fd_tess/tesseract_config.yaml b/examples/ansys/sdf_fd_tess/tesseract_config.yaml new file mode 100644 index 0000000..64e2cb6 --- /dev/null +++ b/examples/ansys/sdf_fd_tess/tesseract_config.yaml @@ -0,0 +1,8 @@ +name: sdf_fd_tess +version: "0.2.0" +description: | + Tesseract that takes a .stl generating tesseract reference and uses finite difference gradients + to compute gradients for a signed distance field. + +build_config: + target_platform: "linux/x86_64" diff --git a/examples/ansys/sdf_fd_tess/tesseract_requirements.txt b/examples/ansys/sdf_fd_tess/tesseract_requirements.txt new file mode 100644 index 0000000..f95b514 --- /dev/null +++ b/examples/ansys/sdf_fd_tess/tesseract_requirements.txt @@ -0,0 +1,5 @@ +numpy==1.26.4 +pyvista==0.45.2 +manifold3d==3.2.1 +trimesh==4.9.0 +pysdf==0.1.9 diff --git a/examples/ansys/spaceclaim/run_4736b3de-2a21-402f-b9c8-e14d3978add1/logs/metrics.csv b/examples/ansys/spaceclaim/run_4736b3de-2a21-402f-b9c8-e14d3978add1/logs/metrics.csv new file mode 100644 index 0000000..c45133d --- /dev/null +++ b/examples/ansys/spaceclaim/run_4736b3de-2a21-402f-b9c8-e14d3978add1/logs/metrics.csv @@ -0,0 +1 @@ +timestamp,key,value,step diff --git a/examples/ansys/spaceclaim/run_53075c93-3b1d-4dc5-b09c-4e438ed09720/logs/metrics.csv b/examples/ansys/spaceclaim/run_53075c93-3b1d-4dc5-b09c-4e438ed09720/logs/metrics.csv new file mode 100644 index 0000000..c45133d --- /dev/null +++ b/examples/ansys/spaceclaim/run_53075c93-3b1d-4dc5-b09c-4e438ed09720/logs/metrics.csv @@ -0,0 +1 @@ +timestamp,key,value,step diff --git a/examples/ansys/spaceclaim/run_91d7bf4b-a0e1-4bd6-820c-89a1e113b937/logs/metrics.csv b/examples/ansys/spaceclaim/run_91d7bf4b-a0e1-4bd6-820c-89a1e113b937/logs/metrics.csv new file mode 100644 index 0000000..c45133d --- /dev/null +++ b/examples/ansys/spaceclaim/run_91d7bf4b-a0e1-4bd6-820c-89a1e113b937/logs/metrics.csv @@ -0,0 +1 @@ +timestamp,key,value,step diff --git a/examples/ansys/spaceclaim/run_c75f7ae9-996f-41b4-9fee-b08c8b99ae1e/logs/metrics.csv b/examples/ansys/spaceclaim/run_c75f7ae9-996f-41b4-9fee-b08c8b99ae1e/logs/metrics.csv new file mode 100644 index 0000000..c45133d --- /dev/null +++ b/examples/ansys/spaceclaim/run_c75f7ae9-996f-41b4-9fee-b08c8b99ae1e/logs/metrics.csv @@ -0,0 +1 @@ +timestamp,key,value,step diff --git a/examples/ansys/spaceclaim/run_db1249cd-f9dd-463c-814e-6ecf194f10d3/logs/metrics.csv b/examples/ansys/spaceclaim/run_db1249cd-f9dd-463c-814e-6ecf194f10d3/logs/metrics.csv new file mode 100644 index 0000000..c45133d --- /dev/null +++ b/examples/ansys/spaceclaim/run_db1249cd-f9dd-463c-814e-6ecf194f10d3/logs/metrics.csv @@ -0,0 +1 @@ +timestamp,key,value,step diff --git a/examples/ansys/spaceclaim_tess/geometry_generation.scscript b/examples/ansys/spaceclaim_tess/geometry_generation.scscript new file mode 100644 index 0000000..e879575 Binary files /dev/null and b/examples/ansys/spaceclaim_tess/geometry_generation.scscript differ diff --git a/examples/ansys/spaceclaim_tess/tesseract_api.py b/examples/ansys/spaceclaim_tess/tesseract_api.py new file mode 100644 index 0000000..56121e5 --- /dev/null +++ b/examples/ansys/spaceclaim_tess/tesseract_api.py @@ -0,0 +1,283 @@ +# Copyright 2025 Pasteur Labs. All Rights Reserved. +# SPDX-License-Identifier: Apache-2.0 + +import os +import shutil +import subprocess +import zipfile +from pathlib import Path, WindowsPath +from tempfile import TemporaryDirectory + +import numpy as np +import trimesh +from pydantic import BaseModel, Field +from tesseract_core.runtime import Array, Float32 + +# Example spaceclaim .exe and script file Paths +# spaceclaim_exe = "F:\\Ansys installations\\ANSYS Inc\\v241\\scdm\\SpaceClaim.exe" +# spaceclaim_script = "geometry_generation.scscript" # Relies on being executed in same directory as tesseract_api.py + +# +# Schemata +# + + +class InputSchema(BaseModel): + """Input schema for bar geometry design and SDF generation.""" + + differentiable_parameters: list[ + Array[ + (None,), + Float32, + ] + ] = Field( + description=( + "Angular positions around the unit circle for the bar geometry. " + "The shape is (num_bars+1, 2), where num_bars is the number of bars " + "and the second dimension has the start then end location of each bar." + "The first (+1) entry represents the two z height coordinates for the cutting plane which combine with " + "a third fixed coordinate centered on the grid with z = grid_height / 2" + ) + ) + + non_differentiable_parameters: list[ + Array[ + (None,), + Float32, + ] + ] = Field( + description=( + "Flattened array of non-differentiable geometry parameters. " + "The shape is (2), the first float is the maximum height (mm) of the " + "grid (pre z-plane cutting). The second is the beam thickness (mm)." + ) + ) + + static_parameters: list[list[int]] = Field( + description=("List of integers used to construct the geometry."), + default=[], + ) + + string_parameters: list[str] = Field( + description=( + "Two string parameters for geometry construction. " + "First str is Path to Spaceclaim executable. " + "Second str is Path to Spaceclaim Script (.scscript)." + ) + ) + + +class TriangularMesh(BaseModel): + """Triangular mesh representation with fixed-size arrays.""" + + points: Array[(None, 3), Float32] = Field(description="Array of vertex positions.") + faces: Array[(None, 3), Float32] = Field( + description="Array of triangular faces defined by indices into the points array." + ) + + +class OutputSchema(BaseModel): + """Output schema for generated geometry.""" + + meshes: list[TriangularMesh] = Field( + description="Triangular meshes representing the geometries" + ) + + +# +# Helper functions +# + + +def build_geometries( + differentiable_parameters: list[np.ndarray], + non_differentiable_parameters: list[np.ndarray], + static_parameters: list[list[int]], + string_parameters: list[str], +) -> list[trimesh.Trimesh]: + """Build a Spaceclaim geometry from the parameters by modifying template .scscript. + + Return a trimesh object. + """ + spaceclaim_exe = Path(string_parameters[0]) + spaceclaim_script = Path(string_parameters[1]) + + # TODO: Want to stop using TemporaryDirectory for spaceclaim script + # and instead use the unique run directory created everytime the + # tesseract is run (so there is history). + with TemporaryDirectory() as temp_dir: + prepped_script_path = _prep_scscript( + temp_dir, + spaceclaim_script, + differentiable_parameters, + non_differentiable_parameters, + ) + run_spaceclaim(spaceclaim_exe, prepped_script_path) + + meshes = [] + for output_stl in sorted(Path(temp_dir).glob("*.stl")): + mesh = trimesh.load(output_stl) + meshes.append(mesh) + + return meshes + + +def _prep_scscript( + temp_dir: TemporaryDirectory, + spaceclaim_script: Path, + differentiable_parameters: list[np.ndarray], + non_differentiable_parameters: list[np.ndarray], +) -> list[str]: + """Take tesseract inputs and place into a temp .scscript that will be used to run Spaceclaim. + + Return the Path location of this script and the output .stl + """ + # Define output file name and location + # TODO: Same as before: can we output grid_fin.stl in the tesseract + # unique run directory instead of temp dir to keep history? + output_file = os.path.join( + temp_dir, "grid_fin" + ) # .stl ending is included in .scscript + prepped_script_path = os.path.join(temp_dir, os.path.basename(spaceclaim_script)) + shutil.copy(spaceclaim_script, prepped_script_path) + + # Define dict used to input params to .scscript + # Converts np.float32 to python floats so string substitution is clean + keyvalues = {} + keyvalues["__output__"] = output_file + keyvalues["__params__.zeds"] = [ + [float(geom_params[0]), float(geom_params[1])] + for geom_params in differentiable_parameters + ] + keyvalues["__params__.height"] = non_differentiable_parameters[0][0] + keyvalues["__params__.thickness"] = non_differentiable_parameters[0][1] + + num_of_batches = len(differentiable_parameters) # number of geometries requested + num_of_bars = ( + len(differentiable_parameters[0]) - 2 + ) // 2 # Use firt geometry in batch to test number of beams + + assert num_of_bars == 8 + + batch_starts = [] + batch_ends = [] + for i in range(num_of_batches): + geom_starts = [] + geom_ends = [] + for j in range(num_of_bars): + geom_starts.append(float(differentiable_parameters[i][j * 2 + 2])) + geom_ends.append(float(differentiable_parameters[i][j * 2 + 3])) + + batch_starts.append(geom_starts) + batch_ends.append(geom_ends) + + keyvalues["__params__.starts"] = ( + batch_starts # convert to string to ease injection into file text + ) + keyvalues["__params__.ends"] = batch_ends + + _find_and_replace_keys_in_archive(prepped_script_path, keyvalues) + + return prepped_script_path + + +def _safereplace(filedata: str, key: str, value: str) -> str: + # ensure double backspace in windows path + if isinstance(value, WindowsPath): + value = str(value) + value = value.replace("\\", "\\\\") + else: + value = str(value) + return filedata.replace(key, value) + + +def _find_and_replace_keys_in_archive(file: Path, keyvalues: dict) -> None: + # work on the zip in a temporary directory + with TemporaryDirectory() as temp_dir: + # extract zip + with zipfile.ZipFile(file, "r") as zip_ref: + zip_ref.extractall(temp_dir) + + # walk through the extracted files/folders + for foldername, _subfolders, filenames in os.walk(temp_dir): + for filename in filenames: + # read in file + filepath = os.path.join(foldername, filename) + try: + with open(filepath) as f: + filedata = f.read() + except Exception: + filedata = None + + # find/replace + if filedata: + for key, value in keyvalues.items(): + if value is not None: + filedata = _safereplace(filedata, key, value) + + # write to file + with open(filepath, "w") as f: + f.write(filedata) + + # write out all files back to zip + with zipfile.ZipFile(file, "w") as zip_ref: + for foldername, _subfolders, filenames in os.walk(temp_dir): + for filename in filenames: + filepath = os.path.join(foldername, filename) + zip_ref.write( + filepath, + arcname=os.path.relpath(filepath, start=temp_dir), + ) + + +def run_spaceclaim(spaceclaim_exe: Path, spaceclaim_script: Path) -> None: + """Runs Spaceclaim subprocess with .exe and script Path locations. + + Returns the subprocess return code as a placeholder. + """ + env = os.environ.copy() + cmd = str( + f'"{spaceclaim_exe}" /UseLicenseMode=True /Welcome=False /Splash=False ' + + f'/RunScript="{spaceclaim_script}" /ExitAfterScript=True /Headless=True' + ) + + # TODO: Not very robust, should probably try use some error handling + # or timeout logic to prevent stalling if Spaceclaim fails. + result = subprocess.run( + cmd, + shell=True, + check=False, + capture_output=True, + text=True, + env=env, + ) + + return result.returncode + + +# +# Tesseract endpoints +# + + +def apply(inputs: InputSchema) -> OutputSchema: + """Create a Spaceclaim geometry based on input parameters. + + Returns TraingularMesh objects. + """ + trimeshes = build_geometries( + differentiable_parameters=inputs.differentiable_parameters, + non_differentiable_parameters=inputs.non_differentiable_parameters, + static_parameters=inputs.static_parameters, + string_parameters=inputs.string_parameters, + ) + + return OutputSchema( + meshes=[ + TriangularMesh( + points=mesh.vertices.astype(np.float32), + faces=mesh.faces.astype(np.int32), + ) + for mesh in trimeshes + ] + ) diff --git a/examples/ansys/spaceclaim_tess/tesseract_config.yaml b/examples/ansys/spaceclaim_tess/tesseract_config.yaml new file mode 100644 index 0000000..2ba52cb --- /dev/null +++ b/examples/ansys/spaceclaim_tess/tesseract_config.yaml @@ -0,0 +1,24 @@ +name: "spaceclaim" +version: "1.0.0" +description: "Testing wrapping Spaceclaim in a runtime tesseract" + +build_config: + # Base image to use for the container, must be Ubuntu or Debian-based + # base_image: "debian:bookworm-slim" + + # Platform to build the container for. In general, images can only be executed + # on the platform they were built for. + # target_platform: "native" + + # Additional packages to install in the container (via apt-get) + # extra_packages: + # - package_name + + # Data to copy into the container, relative to the project root + # package_data: + # - [path/to/source, path/to/destination] + + # Additional Dockerfile commands to run during the build process + # custom_build_steps: + # - | + # RUN echo "Hello, World!" diff --git a/examples/ansys/spaceclaim_tess/tesseract_requirements.txt b/examples/ansys/spaceclaim_tess/tesseract_requirements.txt new file mode 100644 index 0000000..ca8a8c8 --- /dev/null +++ b/examples/ansys/spaceclaim_tess/tesseract_requirements.txt @@ -0,0 +1,2 @@ +# Add Python requirements like this: +# numpy==1.18.1 diff --git a/examples/ansys/vtks/fem_shapeopt_mesh1.vtk b/examples/ansys/vtks/fem_shapeopt_mesh1.vtk new file mode 100644 index 0000000..67509f0 Binary files /dev/null and b/examples/ansys/vtks/fem_shapeopt_mesh1.vtk differ diff --git a/examples/ansys/vtks/fem_shapeopt_mesh2.vtk b/examples/ansys/vtks/fem_shapeopt_mesh2.vtk new file mode 100644 index 0000000..64a1d77 Binary files /dev/null and b/examples/ansys/vtks/fem_shapeopt_mesh2.vtk differ diff --git a/examples/ansys/vtks/fem_shapeopt_mesh3.vtk b/examples/ansys/vtks/fem_shapeopt_mesh3.vtk new file mode 100644 index 0000000..0deb2e1 Binary files /dev/null and b/examples/ansys/vtks/fem_shapeopt_mesh3.vtk differ