diff --git a/demo/cfd/cfd-tesseract/tesseract_api.py b/demo/cfd/cfd-tesseract/tesseract_api.py index eda9bee..5b3ab39 100644 --- a/demo/cfd/cfd-tesseract/tesseract_api.py +++ b/demo/cfd/cfd-tesseract/tesseract_api.py @@ -1,15 +1,15 @@ # Copyright 2025 Pasteur Labs. All Rights Reserved. # SPDX-License-Identifier: Apache-2.0 -from functools import partial +from typing import Any +import equinox as eqx import jax import jax.numpy as jnp import jax_cfd.base as cfd from pydantic import BaseModel, Field -from tesseract_core.runtime import Array, Differentiable, Float32, ShapeDType - -# TODO: !! Use JAX recipe for this, to avoid re-jitting of VJPs etc. !! +from tesseract_core.runtime import Array, Differentiable, Float32 +from tesseract_core.runtime.tree_transforms import filter_func, flatten_with_paths class InputSchema(BaseModel): @@ -22,13 +22,13 @@ class InputSchema(BaseModel): ), Float32, ] - ] = Field(description="3D Array defining the initial velocity field [...]") + ] = Field(description="3D Array defining the initial velocity field") density: float = Field(description="Density of the fluid") viscosity: float = Field(description="Viscosity of the fluid") - inner_steps: float = Field( + inner_steps: int = Field( description="Number of solver steps for each timestep", default=25 ) - outer_steps: float = Field(description="Number of timesteps steps", default=10) + outer_steps: int = Field(description="Number of timesteps steps", default=10) max_velocity: float = Field(description="Maximum velocity", default=2.0) cfl_safety_factor: float = Field(description="CFL safety factor", default=0.5) domain_size_x: float = Field(description="Domain size x", default=1.0) @@ -36,31 +36,11 @@ class InputSchema(BaseModel): class OutputSchema(BaseModel): - result: Differentiable[ - Array[ - ( - None, - None, - None, - ), - Float32, - ] - ] = Field(description="3D Array defining the final velocity field [...]") - - -@partial( - jax.jit, - static_argnames=( - "density", - "viscosity", - "inner_steps", - "outer_steps", - "max_velocity", - "cfl_safety_factor", - "domain_size_x", - "domain_size_y", - ), -) + result: Differentiable[Array[(None, None, None), Float32]] = Field( + description="3D Array defining the final velocity field" + ) + + def cfd_fwd( v0: jnp.ndarray, density: float, @@ -72,6 +52,22 @@ def cfd_fwd( domain_size_x: float, domain_size_y: float, ) -> tuple[jax.Array, jax.Array]: + """Compute the final velocity field using the semi-implicit Navier-Stokes equations. + + Args: + v0: Initial velocity field. + density: Density of the fluid. + viscosity: Viscosity of the fluid. + inner_steps: Number of solver steps for each timestep. + outer_steps: Number of timesteps steps. + max_velocity: Maximum velocity. + cfl_safety_factor: CFL safety factor. + domain_size_x: Domain size in x direction. + domain_size_y: Domain size in y direction. + + Returns: + Final velocity field. + """ vx0 = v0[..., 0] vy0 = v0[..., 1] bc = cfd.boundaries.HomogeneousBoundaryConditions( @@ -89,7 +85,7 @@ def cfd_fwd( vx0 = cfd.grids.GridArray(vx0, grid=grid, offset=(1.0, 0.5)) vy0 = cfd.grids.GridArray(vy0, grid=grid, offset=(0.5, 1.0)) - # reconstrut GridVariable from input + # reconstruct GridVariable from input vx0 = cfd.grids.GridVariable(vx0, bc) vy0 = cfd.grids.GridVariable(vy0, bc) v0 = (vx0, vy0) @@ -106,80 +102,120 @@ def cfd_fwd( ), steps=inner_steps, ) - rollout_fn = jax.jit(cfd.funcutils.trajectory(step_fn, outer_steps)) + rollout_fn = cfd.funcutils.trajectory(step_fn, outer_steps) _, trajectory = jax.device_get(rollout_fn(v0)) - vxn = trajectory[0].array.data[-1] - vyn = trajectory[1].array.data[-1] - return jnp.stack([vxn, vyn], axis=-1) -def apply(inputs: InputSchema) -> OutputSchema: # - vn = cfd_fwd( - v0=inputs.v0, - density=inputs.density, - viscosity=inputs.viscosity, - inner_steps=inputs.inner_steps, - outer_steps=inputs.outer_steps, - max_velocity=inputs.max_velocity, - cfl_safety_factor=inputs.cfl_safety_factor, - domain_size_x=inputs.domain_size_x, - domain_size_y=inputs.domain_size_y, - ) +@eqx.filter_jit +def apply_jit(inputs: dict) -> dict: + vn = cfd_fwd(**inputs) + return dict(result=vn) - return OutputSchema(result=vn) +def apply(inputs: InputSchema) -> OutputSchema: + return apply_jit(inputs.model_dump()) + + +def jacobian( + inputs: InputSchema, + jac_inputs: set[str], + jac_outputs: set[str], +): + return jac_jit(inputs.model_dump(), tuple(jac_inputs), tuple(jac_outputs)) -def abstract_eval(abstract_inputs): - """Calculate output shape of apply from the shape of its inputs.""" - return { - "result": ShapeDType(shape=abstract_inputs.v0.shape, dtype="float32"), - } + +def jacobian_vector_product( + inputs: InputSchema, + jvp_inputs: set[str], + jvp_outputs: set[str], + tangent_vector: dict[str, Any], +): + return jvp_jit( + inputs.model_dump(), + tuple(jvp_inputs), + tuple(jvp_outputs), + tangent_vector, + ) def vector_jacobian_product( inputs: InputSchema, vjp_inputs: set[str], vjp_outputs: set[str], - cotangent_vector, + cotangent_vector: dict[str, Any], ): - signature = [ - "v0", - "density", - "viscosity", - "inner_steps", - "outer_steps", - "max_velocity", - "cfl_safety_factor", - "domain_size_x", - "domain_size_y", - ] - # We need to do this, rather than just use jvp inputs, as the order in jvp_inputs - # is not necessarily the same as the ordering of the args in the function signature. - static_args = [arg for arg in signature if arg not in vjp_inputs] - nonstatic_args = [arg for arg in signature if arg in vjp_inputs] - - def cfd_fwd_reordered(*args, **kwargs): - return cfd_fwd( - **{**{arg: args[i] for i, arg in enumerate(nonstatic_args)}, **kwargs} - ) + return vjp_jit( + inputs.model_dump(), + tuple(vjp_inputs), + tuple(vjp_outputs), + cotangent_vector, + ) - out = {} - if "result" in vjp_outputs: - # Make the function depend only on nonstatic args, as jax.jvp - # differentiates w.r.t. all free arguments. - func = partial( - cfd_fwd_reordered, **{arg: getattr(inputs, arg) for arg in static_args} - ) - _, vjp_func = jax.vjp( - func, *tuple(inputs.model_dump(include=vjp_inputs).values()) - ) +def abstract_eval(abstract_inputs): + """Calculate output shape of apply from the shape of its inputs.""" + is_shapedtype_dict = lambda x: type(x) is dict and (x.keys() == {"shape", "dtype"}) + is_shapedtype_struct = lambda x: isinstance(x, jax.ShapeDtypeStruct) + + jaxified_inputs = jax.tree.map( + lambda x: jax.ShapeDtypeStruct(**x) if is_shapedtype_dict(x) else x, + abstract_inputs.model_dump(), + is_leaf=is_shapedtype_dict, + ) + dynamic_inputs, static_inputs = eqx.partition( + jaxified_inputs, filter_spec=is_shapedtype_struct + ) + + def wrapped_apply(dynamic_inputs): + inputs = eqx.combine(static_inputs, dynamic_inputs) + return apply_jit(inputs) + + jax_shapes = jax.eval_shape(wrapped_apply, dynamic_inputs) + return jax.tree.map( + lambda x: ( + {"shape": x.shape, "dtype": str(x.dtype)} if is_shapedtype_struct(x) else x + ), + jax_shapes, + is_leaf=is_shapedtype_struct, + ) + + +@eqx.filter_jit +def jac_jit( + inputs: dict, + jac_inputs: tuple[str], + jac_outputs: tuple[str], +): + filtered_apply = filter_func(apply_jit, inputs, jac_outputs) + return jax.jacrev(filtered_apply)( + flatten_with_paths(inputs, include_paths=jac_inputs) + ) - vals = vjp_func(cotangent_vector["result"]) - for arg, val in zip(nonstatic_args, vals, strict=False): - out[arg] = out.get(arg, 0.0) + val - return out +@eqx.filter_jit +def jvp_jit( + inputs: dict, jvp_inputs: tuple[str], jvp_outputs: tuple[str], tangent_vector: dict +): + filtered_apply = filter_func(apply_jit, inputs, jvp_outputs) + return jax.jvp( + filtered_apply, + [flatten_with_paths(inputs, include_paths=jvp_inputs)], + [tangent_vector], + ) + + +@eqx.filter_jit +def vjp_jit( + inputs: dict, + vjp_inputs: tuple[str], + vjp_outputs: tuple[str], + cotangent_vector: dict, +): + filtered_apply = filter_func(apply_jit, inputs, vjp_outputs) + _, vjp_func = jax.vjp( + filtered_apply, flatten_with_paths(inputs, include_paths=vjp_inputs) + ) + return vjp_func(cotangent_vector)[0] diff --git a/demo/cfd/cfd-tesseract/tesseract_requirements.txt b/demo/cfd/cfd-tesseract/tesseract_requirements.txt index a00f16a..c4607fb 100644 --- a/demo/cfd/cfd-tesseract/tesseract_requirements.txt +++ b/demo/cfd/cfd-tesseract/tesseract_requirements.txt @@ -1,3 +1,4 @@ numpy==1.26.4 jax-cfd==0.2.1 -jax[cpu]==0.4.34 +jax[cpu]==0.6.0 +equinox diff --git a/demo/cfd/demo.ipynb b/demo/cfd/demo.ipynb index 80dc69d..0f2656b 100644 --- a/demo/cfd/demo.ipynb +++ b/demo/cfd/demo.ipynb @@ -19,8 +19,8 @@ "output_type": "stream", "text": [ "\u001b[2K \u001b[1;2m[\u001b[0m\u001b[34mi\u001b[0m\u001b[1;2m]\u001b[0m Building image \u001b[33m...\u001b[0m\n", - "\u001b[2K\u001b[37m⠇\u001b[0m \u001b[37mProcessing\u001b[0m\n", - "\u001b[1A\u001b[2K \u001b[1;2m[\u001b[0m\u001b[34mi\u001b[0m\u001b[1;2m]\u001b[0m Built image sh\u001b[1;92ma256:b5e2\u001b[0m455fe251, \u001b[1m[\u001b[0m\u001b[32m'jax-cfd:latest'\u001b[0m\u001b[1m]\u001b[0m\n" + "\u001b[2K\u001b[37m⠏\u001b[0m \u001b[37mProcessing\u001b[0m\n", + "\u001b[1A\u001b[2K \u001b[1;2m[\u001b[0m\u001b[34mi\u001b[0m\u001b[1;2m]\u001b[0m Built image sh\u001b[1;92ma256:fd2a\u001b[0m8eca0747, \u001b[1m[\u001b[0m\u001b[32m'jax-cfd:latest'\u001b[0m\u001b[1m]\u001b[0m\n" ] }, { @@ -390,7 +390,7 @@ "Loss: 0.500 Iteration: 34\n", "Loss: 0.496 Iteration: 35\n", "Loss: 0.491 Iteration: 36\n", - "Loss: 0.487 Iteration: 37\n", + "Loss: 0.488 Iteration: 37\n", "Loss: 0.484 Iteration: 38\n", "Loss: 0.480 Iteration: 39\n", "Loss: 0.476 Iteration: 40\n", @@ -403,19 +403,19 @@ "Loss: 0.446 Iteration: 47\n", "Loss: 0.442 Iteration: 48\n", "Loss: 0.438 Iteration: 49\n", - "Loss: 0.433 Iteration: 50\n", + "Loss: 0.434 Iteration: 50\n", "Loss: 0.429 Iteration: 51\n", "Loss: 0.425 Iteration: 52\n", "Loss: 0.421 Iteration: 53\n", "Loss: 0.418 Iteration: 54\n", "Loss: 0.421 Iteration: 55\n", - "Loss: 0.412 Iteration: 56\n", - "Loss: 0.404 Iteration: 57\n", + "Loss: 0.413 Iteration: 56\n", + "Loss: 0.405 Iteration: 57\n", "Loss: 0.401 Iteration: 58\n", - "Loss: 0.400 Iteration: 59\n", + "Loss: 0.401 Iteration: 59\n", "Loss: 0.398 Iteration: 60\n", "Loss: 0.392 Iteration: 61\n", - "Loss: 0.394 Iteration: 62\n", + "Loss: 0.395 Iteration: 62\n", "Loss: 0.390 Iteration: 63\n", "Loss: 0.387 Iteration: 64\n", "Loss: 0.387 Iteration: 65\n", @@ -424,333 +424,333 @@ "Loss: 0.379 Iteration: 68\n", "Loss: 0.379 Iteration: 69\n", "Loss: 0.376 Iteration: 70\n", - "Loss: 0.375 Iteration: 71\n", + "Loss: 0.376 Iteration: 71\n", "Loss: 0.373 Iteration: 72\n", "Loss: 0.372 Iteration: 73\n", "Loss: 0.370 Iteration: 74\n", - "Loss: 0.368 Iteration: 75\n", + "Loss: 0.369 Iteration: 75\n", "Loss: 0.367 Iteration: 76\n", - "Loss: 0.365 Iteration: 77\n", + "Loss: 0.366 Iteration: 77\n", "Loss: 0.364 Iteration: 78\n", - "Loss: 0.362 Iteration: 79\n", + "Loss: 0.363 Iteration: 79\n", "Loss: 0.361 Iteration: 80\n", - "Loss: 0.359 Iteration: 81\n", + "Loss: 0.360 Iteration: 81\n", "Loss: 0.358 Iteration: 82\n", "Loss: 0.357 Iteration: 83\n", "Loss: 0.355 Iteration: 84\n", - "Loss: 0.354 Iteration: 85\n", + "Loss: 0.355 Iteration: 85\n", "Loss: 0.353 Iteration: 86\n", "Loss: 0.352 Iteration: 87\n", - "Loss: 0.350 Iteration: 88\n", - "Loss: 0.349 Iteration: 89\n", + "Loss: 0.351 Iteration: 88\n", + "Loss: 0.350 Iteration: 89\n", "Loss: 0.348 Iteration: 90\n", "Loss: 0.347 Iteration: 91\n", "Loss: 0.346 Iteration: 92\n", - "Loss: 0.344 Iteration: 93\n", - "Loss: 0.343 Iteration: 94\n", + "Loss: 0.345 Iteration: 93\n", + "Loss: 0.344 Iteration: 94\n", "Loss: 0.342 Iteration: 95\n", "Loss: 0.341 Iteration: 96\n", "Loss: 0.340 Iteration: 97\n", - "Loss: 0.338 Iteration: 98\n", - "Loss: 0.337 Iteration: 99\n", + "Loss: 0.339 Iteration: 98\n", + "Loss: 0.338 Iteration: 99\n", "Loss: 0.336 Iteration: 100\n", "Loss: 0.335 Iteration: 101\n", "Loss: 0.334 Iteration: 102\n", - "Loss: 0.332 Iteration: 103\n", - "Loss: 0.331 Iteration: 104\n", + "Loss: 0.333 Iteration: 103\n", + "Loss: 0.332 Iteration: 104\n", "Loss: 0.330 Iteration: 105\n", "Loss: 0.329 Iteration: 106\n", - "Loss: 0.327 Iteration: 107\n", + "Loss: 0.328 Iteration: 107\n", "Loss: 0.326 Iteration: 108\n", "Loss: 0.325 Iteration: 109\n", - "Loss: 0.323 Iteration: 110\n", + "Loss: 0.324 Iteration: 110\n", "Loss: 0.322 Iteration: 111\n", - "Loss: 0.320 Iteration: 112\n", - "Loss: 0.319 Iteration: 113\n", + "Loss: 0.321 Iteration: 112\n", + "Loss: 0.320 Iteration: 113\n", "Loss: 0.318 Iteration: 114\n", - "Loss: 0.316 Iteration: 115\n", + "Loss: 0.317 Iteration: 115\n", "Loss: 0.315 Iteration: 116\n", - "Loss: 0.313 Iteration: 117\n", + "Loss: 0.314 Iteration: 117\n", "Loss: 0.312 Iteration: 118\n", - "Loss: 0.310 Iteration: 119\n", + "Loss: 0.311 Iteration: 119\n", "Loss: 0.309 Iteration: 120\n", - "Loss: 0.307 Iteration: 121\n", - "Loss: 0.305 Iteration: 122\n", - "Loss: 0.304 Iteration: 123\n", - "Loss: 0.302 Iteration: 124\n", + "Loss: 0.308 Iteration: 121\n", + "Loss: 0.306 Iteration: 122\n", + "Loss: 0.305 Iteration: 123\n", + "Loss: 0.303 Iteration: 124\n", "Loss: 0.301 Iteration: 125\n", - "Loss: 0.299 Iteration: 126\n", - "Loss: 0.297 Iteration: 127\n", - "Loss: 0.296 Iteration: 128\n", - "Loss: 0.294 Iteration: 129\n", - "Loss: 0.293 Iteration: 130\n", - "Loss: 0.291 Iteration: 131\n", - "Loss: 0.290 Iteration: 132\n", - "Loss: 0.288 Iteration: 133\n", - "Loss: 0.287 Iteration: 134\n", + "Loss: 0.300 Iteration: 126\n", + "Loss: 0.298 Iteration: 127\n", + "Loss: 0.297 Iteration: 128\n", + "Loss: 0.295 Iteration: 129\n", + "Loss: 0.294 Iteration: 130\n", + "Loss: 0.292 Iteration: 131\n", + "Loss: 0.291 Iteration: 132\n", + "Loss: 0.289 Iteration: 133\n", + "Loss: 0.288 Iteration: 134\n", "Loss: 0.286 Iteration: 135\n", - "Loss: 0.284 Iteration: 136\n", - "Loss: 0.283 Iteration: 137\n", + "Loss: 0.285 Iteration: 136\n", + "Loss: 0.284 Iteration: 137\n", "Loss: 0.282 Iteration: 138\n", - "Loss: 0.280 Iteration: 139\n", - "Loss: 0.279 Iteration: 140\n", + "Loss: 0.281 Iteration: 139\n", + "Loss: 0.280 Iteration: 140\n", "Loss: 0.278 Iteration: 141\n", - "Loss: 0.276 Iteration: 142\n", - "Loss: 0.275 Iteration: 143\n", + "Loss: 0.277 Iteration: 142\n", + "Loss: 0.276 Iteration: 143\n", "Loss: 0.274 Iteration: 144\n", - "Loss: 0.272 Iteration: 145\n", - "Loss: 0.271 Iteration: 146\n", - "Loss: 0.270 Iteration: 147\n", + "Loss: 0.273 Iteration: 145\n", + "Loss: 0.272 Iteration: 146\n", + "Loss: 0.271 Iteration: 147\n", "Loss: 0.269 Iteration: 148\n", - "Loss: 0.267 Iteration: 149\n", - "Loss: 0.266 Iteration: 150\n", - "Loss: 0.265 Iteration: 151\n", - "Loss: 0.263 Iteration: 152\n", - "Loss: 0.262 Iteration: 153\n", - "Loss: 0.261 Iteration: 154\n", - "Loss: 0.259 Iteration: 155\n", - "Loss: 0.258 Iteration: 156\n", - "Loss: 0.257 Iteration: 157\n", - "Loss: 0.255 Iteration: 158\n", - "Loss: 0.254 Iteration: 159\n", - "Loss: 0.253 Iteration: 160\n", - "Loss: 0.251 Iteration: 161\n", - "Loss: 0.250 Iteration: 162\n", - "Loss: 0.249 Iteration: 163\n", - "Loss: 0.247 Iteration: 164\n", - "Loss: 0.246 Iteration: 165\n", - "Loss: 0.245 Iteration: 166\n", - "Loss: 0.243 Iteration: 167\n", - "Loss: 0.242 Iteration: 168\n", - "Loss: 0.241 Iteration: 169\n", - "Loss: 0.239 Iteration: 170\n", - "Loss: 0.238 Iteration: 171\n", - "Loss: 0.236 Iteration: 172\n", - "Loss: 0.235 Iteration: 173\n", - "Loss: 0.233 Iteration: 174\n", - "Loss: 0.232 Iteration: 175\n", - "Loss: 0.230 Iteration: 176\n", - "Loss: 0.228 Iteration: 177\n", - "Loss: 0.226 Iteration: 178\n", - "Loss: 0.225 Iteration: 179\n", - "Loss: 0.223 Iteration: 180\n", - "Loss: 0.221 Iteration: 181\n", - "Loss: 0.219 Iteration: 182\n", - "Loss: 0.217 Iteration: 183\n", - "Loss: 0.215 Iteration: 184\n", - "Loss: 0.214 Iteration: 185\n", - "Loss: 0.212 Iteration: 186\n", - "Loss: 0.210 Iteration: 187\n", - "Loss: 0.209 Iteration: 188\n", - "Loss: 0.207 Iteration: 189\n", - "Loss: 0.206 Iteration: 190\n", - "Loss: 0.204 Iteration: 191\n", - "Loss: 0.203 Iteration: 192\n", - "Loss: 0.202 Iteration: 193\n", - "Loss: 0.201 Iteration: 194\n", - "Loss: 0.199 Iteration: 195\n", - "Loss: 0.198 Iteration: 196\n", - "Loss: 0.197 Iteration: 197\n", - "Loss: 0.196 Iteration: 198\n", - "Loss: 0.195 Iteration: 199\n", - "Loss: 0.193 Iteration: 200\n", - "Loss: 0.192 Iteration: 201\n", - "Loss: 0.191 Iteration: 202\n", - "Loss: 0.190 Iteration: 203\n", - "Loss: 0.189 Iteration: 204\n", - "Loss: 0.188 Iteration: 205\n", - "Loss: 0.187 Iteration: 206\n", - "Loss: 0.186 Iteration: 207\n", - "Loss: 0.185 Iteration: 208\n", - "Loss: 0.184 Iteration: 209\n", - "Loss: 0.182 Iteration: 210\n", - "Loss: 0.181 Iteration: 211\n", - "Loss: 0.180 Iteration: 212\n", - "Loss: 0.179 Iteration: 213\n", - "Loss: 0.178 Iteration: 214\n", - "Loss: 0.177 Iteration: 215\n", - "Loss: 0.176 Iteration: 216\n", - "Loss: 0.175 Iteration: 217\n", - "Loss: 0.173 Iteration: 218\n", - "Loss: 0.172 Iteration: 219\n", - "Loss: 0.171 Iteration: 220\n", - "Loss: 0.170 Iteration: 221\n", - "Loss: 0.169 Iteration: 222\n", - "Loss: 0.168 Iteration: 223\n", - "Loss: 0.167 Iteration: 224\n", - "Loss: 0.165 Iteration: 225\n", - "Loss: 0.164 Iteration: 226\n", - "Loss: 0.163 Iteration: 227\n", - "Loss: 0.162 Iteration: 228\n", - "Loss: 0.161 Iteration: 229\n", - "Loss: 0.160 Iteration: 230\n", - "Loss: 0.158 Iteration: 231\n", - "Loss: 0.157 Iteration: 232\n", - "Loss: 0.156 Iteration: 233\n", - "Loss: 0.155 Iteration: 234\n", - "Loss: 0.154 Iteration: 235\n", - "Loss: 0.152 Iteration: 236\n", - "Loss: 0.151 Iteration: 237\n", - "Loss: 0.150 Iteration: 238\n", - "Loss: 0.149 Iteration: 239\n", - "Loss: 0.147 Iteration: 240\n", - "Loss: 0.146 Iteration: 241\n", - "Loss: 0.145 Iteration: 242\n", - "Loss: 0.144 Iteration: 243\n", - "Loss: 0.142 Iteration: 244\n", - "Loss: 0.141 Iteration: 245\n", - "Loss: 0.140 Iteration: 246\n", - "Loss: 0.139 Iteration: 247\n", - "Loss: 0.138 Iteration: 248\n", - "Loss: 0.137 Iteration: 249\n", - "Loss: 0.136 Iteration: 250\n", - "Loss: 0.135 Iteration: 251\n", - "Loss: 0.133 Iteration: 252\n", - "Loss: 0.132 Iteration: 253\n", - "Loss: 0.131 Iteration: 254\n", - "Loss: 0.130 Iteration: 255\n", - "Loss: 0.129 Iteration: 256\n", - "Loss: 0.128 Iteration: 257\n", - "Loss: 0.127 Iteration: 258\n", - "Loss: 0.126 Iteration: 259\n", - "Loss: 0.125 Iteration: 260\n", - "Loss: 0.124 Iteration: 261\n", - "Loss: 0.124 Iteration: 262\n", - "Loss: 0.123 Iteration: 263\n", - "Loss: 0.122 Iteration: 264\n", - "Loss: 0.121 Iteration: 265\n", - "Loss: 0.120 Iteration: 266\n", - "Loss: 0.119 Iteration: 267\n", - "Loss: 0.118 Iteration: 268\n", - "Loss: 0.117 Iteration: 269\n", - "Loss: 0.116 Iteration: 270\n", - "Loss: 0.115 Iteration: 271\n", - "Loss: 0.114 Iteration: 272\n", - "Loss: 0.113 Iteration: 273\n", - "Loss: 0.112 Iteration: 274\n", - "Loss: 0.111 Iteration: 275\n", - "Loss: 0.111 Iteration: 276\n", - "Loss: 0.110 Iteration: 277\n", - "Loss: 0.109 Iteration: 278\n", - "Loss: 0.108 Iteration: 279\n", - "Loss: 0.107 Iteration: 280\n", - "Loss: 0.106 Iteration: 281\n", - "Loss: 0.105 Iteration: 282\n", - "Loss: 0.104 Iteration: 283\n", - "Loss: 0.103 Iteration: 284\n", - "Loss: 0.102 Iteration: 285\n", - "Loss: 0.102 Iteration: 286\n", - "Loss: 0.101 Iteration: 287\n", - "Loss: 0.100 Iteration: 288\n", - "Loss: 0.099 Iteration: 289\n", - "Loss: 0.098 Iteration: 290\n", - "Loss: 0.097 Iteration: 291\n", - "Loss: 0.097 Iteration: 292\n", - "Loss: 0.096 Iteration: 293\n", - "Loss: 0.095 Iteration: 294\n", - "Loss: 0.094 Iteration: 295\n", - "Loss: 0.093 Iteration: 296\n", - "Loss: 0.093 Iteration: 297\n", - "Loss: 0.092 Iteration: 298\n", - "Loss: 0.091 Iteration: 299\n", - "Loss: 0.090 Iteration: 300\n", - "Loss: 0.090 Iteration: 301\n", - "Loss: 0.089 Iteration: 302\n", - "Loss: 0.088 Iteration: 303\n", - "Loss: 0.087 Iteration: 304\n", - "Loss: 0.087 Iteration: 305\n", - "Loss: 0.086 Iteration: 306\n", - "Loss: 0.085 Iteration: 307\n", - "Loss: 0.085 Iteration: 308\n", - "Loss: 0.084 Iteration: 309\n", - "Loss: 0.083 Iteration: 310\n", - "Loss: 0.082 Iteration: 311\n", - "Loss: 0.082 Iteration: 312\n", - "Loss: 0.081 Iteration: 313\n", - "Loss: 0.080 Iteration: 314\n", - "Loss: 0.080 Iteration: 315\n", - "Loss: 0.079 Iteration: 316\n", - "Loss: 0.078 Iteration: 317\n", - "Loss: 0.078 Iteration: 318\n", - "Loss: 0.077 Iteration: 319\n", - "Loss: 0.076 Iteration: 320\n", - "Loss: 0.076 Iteration: 321\n", - "Loss: 0.075 Iteration: 322\n", - "Loss: 0.074 Iteration: 323\n", - "Loss: 0.074 Iteration: 324\n", - "Loss: 0.073 Iteration: 325\n", - "Loss: 0.073 Iteration: 326\n", - "Loss: 0.072 Iteration: 327\n", - "Loss: 0.071 Iteration: 328\n", - "Loss: 0.071 Iteration: 329\n", - "Loss: 0.070 Iteration: 330\n", - "Loss: 0.069 Iteration: 331\n", - "Loss: 0.069 Iteration: 332\n", - "Loss: 0.068 Iteration: 333\n", - "Loss: 0.068 Iteration: 334\n", - "Loss: 0.067 Iteration: 335\n", + "Loss: 0.268 Iteration: 149\n", + "Loss: 0.267 Iteration: 150\n", + "Loss: 0.266 Iteration: 151\n", + "Loss: 0.264 Iteration: 152\n", + "Loss: 0.263 Iteration: 153\n", + "Loss: 0.262 Iteration: 154\n", + "Loss: 0.260 Iteration: 155\n", + "Loss: 0.259 Iteration: 156\n", + "Loss: 0.258 Iteration: 157\n", + "Loss: 0.256 Iteration: 158\n", + "Loss: 0.255 Iteration: 159\n", + "Loss: 0.254 Iteration: 160\n", + "Loss: 0.252 Iteration: 161\n", + "Loss: 0.251 Iteration: 162\n", + "Loss: 0.250 Iteration: 163\n", + "Loss: 0.248 Iteration: 164\n", + "Loss: 0.247 Iteration: 165\n", + "Loss: 0.246 Iteration: 166\n", + "Loss: 0.244 Iteration: 167\n", + "Loss: 0.243 Iteration: 168\n", + "Loss: 0.242 Iteration: 169\n", + "Loss: 0.240 Iteration: 170\n", + "Loss: 0.239 Iteration: 171\n", + "Loss: 0.237 Iteration: 172\n", + "Loss: 0.236 Iteration: 173\n", + "Loss: 0.234 Iteration: 174\n", + "Loss: 0.233 Iteration: 175\n", + "Loss: 0.231 Iteration: 176\n", + "Loss: 0.229 Iteration: 177\n", + "Loss: 0.228 Iteration: 178\n", + "Loss: 0.226 Iteration: 179\n", + "Loss: 0.224 Iteration: 180\n", + "Loss: 0.222 Iteration: 181\n", + "Loss: 0.220 Iteration: 182\n", + "Loss: 0.219 Iteration: 183\n", + "Loss: 0.217 Iteration: 184\n", + "Loss: 0.215 Iteration: 185\n", + "Loss: 0.213 Iteration: 186\n", + "Loss: 0.212 Iteration: 187\n", + "Loss: 0.210 Iteration: 188\n", + "Loss: 0.209 Iteration: 189\n", + "Loss: 0.207 Iteration: 190\n", + "Loss: 0.206 Iteration: 191\n", + "Loss: 0.204 Iteration: 192\n", + "Loss: 0.203 Iteration: 193\n", + "Loss: 0.202 Iteration: 194\n", + "Loss: 0.200 Iteration: 195\n", + "Loss: 0.199 Iteration: 196\n", + "Loss: 0.198 Iteration: 197\n", + "Loss: 0.197 Iteration: 198\n", + "Loss: 0.196 Iteration: 199\n", + "Loss: 0.194 Iteration: 200\n", + "Loss: 0.193 Iteration: 201\n", + "Loss: 0.192 Iteration: 202\n", + "Loss: 0.191 Iteration: 203\n", + "Loss: 0.190 Iteration: 204\n", + "Loss: 0.189 Iteration: 205\n", + "Loss: 0.188 Iteration: 206\n", + "Loss: 0.187 Iteration: 207\n", + "Loss: 0.186 Iteration: 208\n", + "Loss: 0.185 Iteration: 209\n", + "Loss: 0.183 Iteration: 210\n", + "Loss: 0.182 Iteration: 211\n", + "Loss: 0.181 Iteration: 212\n", + "Loss: 0.180 Iteration: 213\n", + "Loss: 0.179 Iteration: 214\n", + "Loss: 0.178 Iteration: 215\n", + "Loss: 0.177 Iteration: 216\n", + "Loss: 0.176 Iteration: 217\n", + "Loss: 0.175 Iteration: 218\n", + "Loss: 0.173 Iteration: 219\n", + "Loss: 0.172 Iteration: 220\n", + "Loss: 0.171 Iteration: 221\n", + "Loss: 0.170 Iteration: 222\n", + "Loss: 0.169 Iteration: 223\n", + "Loss: 0.168 Iteration: 224\n", + "Loss: 0.167 Iteration: 225\n", + "Loss: 0.165 Iteration: 226\n", + "Loss: 0.164 Iteration: 227\n", + "Loss: 0.163 Iteration: 228\n", + "Loss: 0.162 Iteration: 229\n", + "Loss: 0.161 Iteration: 230\n", + "Loss: 0.160 Iteration: 231\n", + "Loss: 0.158 Iteration: 232\n", + "Loss: 0.157 Iteration: 233\n", + "Loss: 0.156 Iteration: 234\n", + "Loss: 0.155 Iteration: 235\n", + "Loss: 0.154 Iteration: 236\n", + "Loss: 0.152 Iteration: 237\n", + "Loss: 0.151 Iteration: 238\n", + "Loss: 0.150 Iteration: 239\n", + "Loss: 0.149 Iteration: 240\n", + "Loss: 0.148 Iteration: 241\n", + "Loss: 0.146 Iteration: 242\n", + "Loss: 0.145 Iteration: 243\n", + "Loss: 0.144 Iteration: 244\n", + "Loss: 0.143 Iteration: 245\n", + "Loss: 0.141 Iteration: 246\n", + "Loss: 0.140 Iteration: 247\n", + "Loss: 0.139 Iteration: 248\n", + "Loss: 0.138 Iteration: 249\n", + "Loss: 0.137 Iteration: 250\n", + "Loss: 0.136 Iteration: 251\n", + "Loss: 0.135 Iteration: 252\n", + "Loss: 0.134 Iteration: 253\n", + "Loss: 0.133 Iteration: 254\n", + "Loss: 0.132 Iteration: 255\n", + "Loss: 0.131 Iteration: 256\n", + "Loss: 0.130 Iteration: 257\n", + "Loss: 0.129 Iteration: 258\n", + "Loss: 0.128 Iteration: 259\n", + "Loss: 0.127 Iteration: 260\n", + "Loss: 0.126 Iteration: 261\n", + "Loss: 0.125 Iteration: 262\n", + "Loss: 0.124 Iteration: 263\n", + "Loss: 0.123 Iteration: 264\n", + "Loss: 0.122 Iteration: 265\n", + "Loss: 0.121 Iteration: 266\n", + "Loss: 0.120 Iteration: 267\n", + "Loss: 0.119 Iteration: 268\n", + "Loss: 0.118 Iteration: 269\n", + "Loss: 0.117 Iteration: 270\n", + "Loss: 0.116 Iteration: 271\n", + "Loss: 0.115 Iteration: 272\n", + "Loss: 0.114 Iteration: 273\n", + "Loss: 0.114 Iteration: 274\n", + "Loss: 0.113 Iteration: 275\n", + "Loss: 0.112 Iteration: 276\n", + "Loss: 0.111 Iteration: 277\n", + "Loss: 0.110 Iteration: 278\n", + "Loss: 0.109 Iteration: 279\n", + "Loss: 0.108 Iteration: 280\n", + "Loss: 0.107 Iteration: 281\n", + "Loss: 0.106 Iteration: 282\n", + "Loss: 0.105 Iteration: 283\n", + "Loss: 0.104 Iteration: 284\n", + "Loss: 0.104 Iteration: 285\n", + "Loss: 0.103 Iteration: 286\n", + "Loss: 0.102 Iteration: 287\n", + "Loss: 0.101 Iteration: 288\n", + "Loss: 0.100 Iteration: 289\n", + "Loss: 0.099 Iteration: 290\n", + "Loss: 0.098 Iteration: 291\n", + "Loss: 0.098 Iteration: 292\n", + "Loss: 0.097 Iteration: 293\n", + "Loss: 0.096 Iteration: 294\n", + "Loss: 0.095 Iteration: 295\n", + "Loss: 0.094 Iteration: 296\n", + "Loss: 0.094 Iteration: 297\n", + "Loss: 0.093 Iteration: 298\n", + "Loss: 0.092 Iteration: 299\n", + "Loss: 0.091 Iteration: 300\n", + "Loss: 0.091 Iteration: 301\n", + "Loss: 0.090 Iteration: 302\n", + "Loss: 0.089 Iteration: 303\n", + "Loss: 0.088 Iteration: 304\n", + "Loss: 0.088 Iteration: 305\n", + "Loss: 0.087 Iteration: 306\n", + "Loss: 0.086 Iteration: 307\n", + "Loss: 0.086 Iteration: 308\n", + "Loss: 0.085 Iteration: 309\n", + "Loss: 0.084 Iteration: 310\n", + "Loss: 0.083 Iteration: 311\n", + "Loss: 0.083 Iteration: 312\n", + "Loss: 0.082 Iteration: 313\n", + "Loss: 0.081 Iteration: 314\n", + "Loss: 0.081 Iteration: 315\n", + "Loss: 0.080 Iteration: 316\n", + "Loss: 0.079 Iteration: 317\n", + "Loss: 0.079 Iteration: 318\n", + "Loss: 0.078 Iteration: 319\n", + "Loss: 0.077 Iteration: 320\n", + "Loss: 0.077 Iteration: 321\n", + "Loss: 0.076 Iteration: 322\n", + "Loss: 0.075 Iteration: 323\n", + "Loss: 0.075 Iteration: 324\n", + "Loss: 0.074 Iteration: 325\n", + "Loss: 0.074 Iteration: 326\n", + "Loss: 0.073 Iteration: 327\n", + "Loss: 0.072 Iteration: 328\n", + "Loss: 0.072 Iteration: 329\n", + "Loss: 0.071 Iteration: 330\n", + "Loss: 0.070 Iteration: 331\n", + "Loss: 0.070 Iteration: 332\n", + "Loss: 0.069 Iteration: 333\n", + "Loss: 0.069 Iteration: 334\n", + "Loss: 0.068 Iteration: 335\n", "Loss: 0.067 Iteration: 336\n", - "Loss: 0.066 Iteration: 337\n", - "Loss: 0.065 Iteration: 338\n", - "Loss: 0.065 Iteration: 339\n", - "Loss: 0.064 Iteration: 340\n", - "Loss: 0.064 Iteration: 341\n", - "Loss: 0.063 Iteration: 342\n", - "Loss: 0.063 Iteration: 343\n", - "Loss: 0.062 Iteration: 344\n", - "Loss: 0.062 Iteration: 345\n", - "Loss: 0.061 Iteration: 346\n", - "Loss: 0.061 Iteration: 347\n", - "Loss: 0.060 Iteration: 348\n", - "Loss: 0.060 Iteration: 349\n", - "Loss: 0.059 Iteration: 350\n", - "Loss: 0.059 Iteration: 351\n", - "Loss: 0.058 Iteration: 352\n", - "Loss: 0.058 Iteration: 353\n", - "Loss: 0.057 Iteration: 354\n", - "Loss: 0.057 Iteration: 355\n", + "Loss: 0.067 Iteration: 337\n", + "Loss: 0.066 Iteration: 338\n", + "Loss: 0.066 Iteration: 339\n", + "Loss: 0.065 Iteration: 340\n", + "Loss: 0.065 Iteration: 341\n", + "Loss: 0.064 Iteration: 342\n", + "Loss: 0.064 Iteration: 343\n", + "Loss: 0.063 Iteration: 344\n", + "Loss: 0.063 Iteration: 345\n", + "Loss: 0.062 Iteration: 346\n", + "Loss: 0.062 Iteration: 347\n", + "Loss: 0.061 Iteration: 348\n", + "Loss: 0.061 Iteration: 349\n", + "Loss: 0.060 Iteration: 350\n", + "Loss: 0.060 Iteration: 351\n", + "Loss: 0.059 Iteration: 352\n", + "Loss: 0.059 Iteration: 353\n", + "Loss: 0.058 Iteration: 354\n", + "Loss: 0.058 Iteration: 355\n", "Loss: 0.057 Iteration: 356\n", - "Loss: 0.056 Iteration: 357\n", + "Loss: 0.057 Iteration: 357\n", "Loss: 0.056 Iteration: 358\n", - "Loss: 0.055 Iteration: 359\n", - "Loss: 0.055 Iteration: 360\n", - "Loss: 0.054 Iteration: 361\n", - "Loss: 0.054 Iteration: 362\n", - "Loss: 0.053 Iteration: 363\n", - "Loss: 0.053 Iteration: 364\n", - "Loss: 0.052 Iteration: 365\n", - "Loss: 0.052 Iteration: 366\n", - "Loss: 0.051 Iteration: 367\n", - "Loss: 0.051 Iteration: 368\n", - "Loss: 0.050 Iteration: 369\n", - "Loss: 0.050 Iteration: 370\n", + "Loss: 0.056 Iteration: 359\n", + "Loss: 0.056 Iteration: 360\n", + "Loss: 0.055 Iteration: 361\n", + "Loss: 0.055 Iteration: 362\n", + "Loss: 0.054 Iteration: 363\n", + "Loss: 0.054 Iteration: 364\n", + "Loss: 0.053 Iteration: 365\n", + "Loss: 0.053 Iteration: 366\n", + "Loss: 0.052 Iteration: 367\n", + "Loss: 0.052 Iteration: 368\n", + "Loss: 0.051 Iteration: 369\n", + "Loss: 0.051 Iteration: 370\n", "Loss: 0.050 Iteration: 371\n", - "Loss: 0.049 Iteration: 372\n", - "Loss: 0.049 Iteration: 373\n", + "Loss: 0.050 Iteration: 372\n", + "Loss: 0.050 Iteration: 373\n", "Loss: 0.049 Iteration: 374\n", - "Loss: 0.048 Iteration: 375\n", - "Loss: 0.048 Iteration: 376\n", + "Loss: 0.049 Iteration: 375\n", + "Loss: 0.049 Iteration: 376\n", "Loss: 0.048 Iteration: 377\n", - "Loss: 0.047 Iteration: 378\n", - "Loss: 0.047 Iteration: 379\n", + "Loss: 0.048 Iteration: 378\n", + "Loss: 0.048 Iteration: 379\n", "Loss: 0.047 Iteration: 380\n", - "Loss: 0.046 Iteration: 381\n", - "Loss: 0.046 Iteration: 382\n", + "Loss: 0.047 Iteration: 381\n", + "Loss: 0.047 Iteration: 382\n", "Loss: 0.046 Iteration: 383\n", - "Loss: 0.045 Iteration: 384\n", - "Loss: 0.045 Iteration: 385\n", + "Loss: 0.046 Iteration: 384\n", + "Loss: 0.046 Iteration: 385\n", "Loss: 0.045 Iteration: 386\n", "Loss: 0.045 Iteration: 387\n", - "Loss: 0.044 Iteration: 388\n", - "Loss: 0.044 Iteration: 389\n", + "Loss: 0.045 Iteration: 388\n", + "Loss: 0.045 Iteration: 389\n", "Loss: 0.044 Iteration: 390\n", "Loss: 0.044 Iteration: 391\n", - "Loss: 0.043 Iteration: 392\n", - "Loss: 0.043 Iteration: 393\n", + "Loss: 0.044 Iteration: 392\n", + "Loss: 0.044 Iteration: 393\n", "Loss: 0.043 Iteration: 394\n", "Loss: 0.043 Iteration: 395\n", - "Loss: 0.042 Iteration: 396\n", - "Loss: 0.042 Iteration: 397\n", + "Loss: 0.043 Iteration: 396\n", + "Loss: 0.043 Iteration: 397\n", "Loss: 0.042 Iteration: 398\n", "Loss: 0.042 Iteration: 399\n" ] @@ -798,7 +798,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAGFCAYAAAASI+9IAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAANG1JREFUeJztnVmS49iWXQkQbL2NjNeUmaykP41DY9GkNCJNQ196bUZmNO7OnoSMnqprVYW9XLgRLpOsaq3Pm0gQLU/QzvJ9mr7v+4mIiMhkMmn/Xx+AiIj8/4NFQUREChYFEREpWBRERKRgURARkYJFQUREChYFEREpWBRERKTQTUay/2//Ja5fdrO4ft4Pd92fp3nnTf77ubY75/XZefQ+ztt5XN98us/rn2/j+m6zHKztw9qVwz5fk75v4vp8fhysre42cVtaX9zuYH0b12dh+3hdX+9b/rfD5ZTXz4d8/qdwLw4vi7jt9ttNXP/26SGu//y3j4O1//mn38dt/8ff8r7/eplU8Y/h7fnP//glbvsf/9Of4/of/sPf4/rtx6fB2mx1yAcCzz7RTPOJttPh/Z8uTnHb6fJYtd7MTqOPYwLvyeWUvz8u4bvmt/Xhc3g5wLbwjE/g0jYtfGeF86Rr2MK1ahd0Dcc/oP0xn8/sv/73/+P/6y8FEREpWBRERKRgURARkYJFQUREChYFERGpt48Ov96OtozeMgXGduyvNGRVgCWT6C9gyBzz8Z3huNP2J9jHBT6TzqcNFkbbZtOgyWIGXysg3R+2jKZ19tE+G1+HzXD9uJtX7ZuMtOVqP1h7AFPrd2A8bb5la+rzJN+Lv5yGN2P917u47Wr1U1xfLIfHTabRNFhqr+uL8e9D7btC7zc9Kz3ct6YbXtsG7iU9y2Tv9fB8pmOh54qe8R4+k97P/tKM/g5q4TNbuObJ1sJ39pj3kZ/wf/X5I7YREZF/J1gURESkYFEQEZGCRUFERAoWBRERqbePdl/Wcf1yoiyRYRe+7XLHfgY5IpMGsl5SZgp04c8HsonycR8ht+cczvMMWU7JQLgyBWsqZc7QtWrauvUq+4hsIrhWZ8iROWyy3XPYDtePkBNF63Qs03ANV8FIuvJ4l3Oinrf5fm6O+X7uQzDOn7b5+NZ/yfbRcpmf8UU49hlsS89K+w52D9p7h7o8rGbajz++ymeZjrHGsMP1C+y7BSsp7QO+33q4D5d+9NcyWkYnyKTLqV//En8piIhIwaIgIiIFi4KIiBQsCiIi8h1Ddp5XVbEQqZlFjTIiNado3zQkAxsx2MjM55MiLehP4GkAxxSGinTzMJijg+EmEAnSwrWiY0zDh6hxfKKG8sty9EAiajTTQCJq4mMMSdh+Co3MFTyH9+vcIL//lqM4PvXDa/4NIjH+/DXv++ZvuQG9Wg+HIy3XuUE+JYEDGu018RIYLVEZiRI/D94HaoTXRrnExjk1lOE8qwnHSN8HNByJRJX0XZYGV105hndtLP5SEBGRgkVBREQKFgURESlYFEREpGBREBGR77CPwCjpQ5wFGTUEGjWwPmnGd+xpiMsB1k/HOhtmbOTCldkiWy+zMDyFrh9FZRD05+7pupCRtQPzbPuco0+2ZCWlmAu43jSoiKgx0mZgdt2s8hCb+01+TTbH4f6fwD765ZJNk7tP+Rrerj8O1lZgH9GzQnERHdgwNDimxtahmItJMoHAakPLiKwkOB8aSFW17258NM2V6fz8Q99jb32npmuL328QNTMGfymIiEjBoiAiIgWLgoiIFCwKIiJSsCiIiEi9fUT5NzV5JGjULLL10UCmS+IEXfgjdOFpiEvKOCLbgmyNOZzPHDJ3UiYUGiVwven+0Pnvw/oWLKPnr7dx/QXso80m7yflHB1pSBPc+g6eiS4NKoL7Q2YTbb+c5fVVsI9e4paTyTYM5Lny8z4/b3ef7gdrNzfDPCQayPMKPCsrMIfSc0j5RAhZScHeS4O43swUg/Oh3K9kX9Fgn5aMrClYRgv4LgvvbVNhYl65gDGYriHlldH32xj8pSAiIgWLgoiIFCwKIiJSsCiIiEjBoiAiIvX2UQ/GRgPd+WTPzNbZkpgus63TQtf+vJmPnkC0hwlEtRlHyUyZwfHNwQah9S7YSmR9nGGS3O4Z8obAEHr5Nlx/Asvo69e7uP5MmUh7yGM5BHsCMqumYIPMwB5ZBhtkBjlRPNkrLk/mYB8twjHO4XxeIBPpK1hJfw/T3h5+HRpJV27vs/NEzyeRppJ1ldMSMRMpmEbJpqHjeHtSWb627bQZnQfVzC9VllG3ytelDd9llJ9E36mUCZWuC026wwyqEfhLQUREChYFEREpWBRERKRgURARkfpGM0FDX1JTuaNG8/pQ1Vg6hz8DP7xAnAUO0xnfUL7ShWYRxVYsYRjKnM4/XENqFO2ecuP4+UtuEj99yU3ir5+HTctfP8O2TxB/sYWmNxz7MVzaFpq7Hayv4Hk7hSZcaj6/7hua+D3NdoHncBZOcwaNZmIDDehfQxP205ebuO0HuMfLVX4OsdkaGud0TShagqIrYkRDRaTMm1AsRsXQIIq/mEKzvoXvrPhdBsfR7/P7cwbJIp3nGZryNUPB/jX+UhARkYJFQUREChYFEREpWBRERKRgURARkXr7iDr5ZODMb4bmQ3eT7Ztmnjv/ly0MwgkDYvYvy9GDXd4yHJJldGURzKElDD2psYzIwiDL6Nunh7j+FQyUXz89xvVPvw63//VbNriewBJ5AbnjANENiekk34d8NyeTUw9/1h/uZzKSrswqhje9tZ8EOR+0h0OTj+U5nM+n5/y6fgRrbH2zqXrGk3lH5hU9yz3YV5eaiAaK1KkY6HWlDftJhtVb6y0MzCJjsiGTMgHnOblURIWc3sng+mf4S0FERAoWBRERKVgURESkYFEQEZGCRUFEROrtozQ05y3TZn63/fGMIxqcE4a7HGCYDnXnycCYL/P5LEKe0SIYVq/7BmOBjiWdz9efH6tsol9+IcsoZyJ9ehpe288nGhDT/7BldCWdPSe0gD0B2Trp3zcnsDjmkH1EQ3YO5/FZTvmpYsiD2gUr6emSX9dfvmZT7eEh3/s5PJ9tuC6Y+wT7oOFQaUAM5fP0cI/RHKLhOxUGDh13A2ZkQwOc0vbwHNLbQwbX+TAbZXX9KP5SEBGRgkVBREQKFgURESlYFEREpGBREBGRevtotoCMo9uc/9PdDi2eBiZhUcbR8RnyjELO0REyjshY6GbZnlhAPtMynOcMcp8ou2UH55NMo19+/lBlGf38a57K9XOwjK58DobHC7gw9ZbR9+eu/BNH+Mx2Mj4X5gAWRweWFXEGi2UfDnEPx32qtI/OYT8b2PfzNls8TzAxbwUT2abJyAOzh57x6RQykcI1JDuI1tt+/MS41/0EM4fMHjKYGspbAlspXq8+X6v+kO/biaZFHrrR9hFNkByDvxRERKRgURARkYJFQUREChYFEREpWBRERKTePpqvDqMzjq60FROIKOPo8AT2UdgebYguex9LyC1KltGV2SpbSYljmAx35enX+9F5Rp8/521/+XwzOsvoylfIkdkGk4UcozkYP7WWUc2/QOhYdhUmFIkjIKsglwqjaAc+0QkmrPWw70u4tslIurIFA+UZphHebrKV1IV3Be0bMITofasBs4ymdRPZLsE06uF7AtfP8NSeYPv98Cu13+Wv2dPLYvRkSbKPyNSiyXhj8JeCiIgULAoiIlKwKIiISMGiICIi39FohsYsDc5pwp/MpybMlRP8OX4aPnPluJ+PbjYtoEFMA3LmYZjOlbYbNgoP0Ch6/pKHm3yBiIqvX+6G28LglC8vOc7jGRrK1G5Kd2IJ/0agQTjT6uiG8XEWh8r1Y7j/1Jh9r385XWrOnRq2wLRi8yNsuw2Nydd1GEg1D9EvGCEBDc4ZxMekAUYYLQGfiU1s2E93Oo0edHWGyIkLfGddNlnsmBwu47/3KMYH9n0+dqOvYTfP92EM/lIQEZGCRUFERAoWBRERKVgURESkYFEQEZHvGLJzC/YRxF+kP4M/Q1f9APbRASyJNFBltsjd9iUc9wLiLKYwCOgcDILdUzaEvkGcxdPXbCU9vwzP/9tLvlbbygEx+QpOJuugg8zBZJjCR5Igc4RBJtvwP+S7M5m8QCzES5N9qk0zvG9HcIEotqJD+2p8zEcHVk4D+5hVfCYdB9pRcB8OYCXtwnAXtI9g36d5N3roSwuDamhATAeRE2TgnINplNauXILZc+UC14qiedL1wu+9b+uq77107HStaADYGPylICIiBYuCiIgULAoiIlKwKIiISMGiICIi9fZRt4YhMyET6MolDJY4gmW0g/XjfjY6h4iG4yzvNnF9BtYUZbocNsvRGUc1ltHrerAT9jDEowUTaAWWyBzK/jyYHx0E7rSwj8MRLCM49m2wxvZgCD0Fm+jKlzbft6fJcH0HphJB9tGyz8bKuh8+44tmWrWPKTxvi7C+IAsKnokLBDEdwcA5HIfvW7uvtI9C3tDrMU6H92Ia8tF+2xYGEvWUq9SPHjTTHfI+TvBdMwXLiEjX5QjDjuh77wBDdtIgMbIu5/R9PQJ/KYiISMGiICIiBYuCiIgULAoiIlKwKIiISL191K5gkg9N/ApTyfYwTWwP3XkygeYh14MyjmYwYa0B0+b4lI9lG479KUxMu/Lyks9zAybDIdggaVLVlQUcd7KJXrefw3owMzBDJlgPv22fLZY9ZNQk12SHGUfZYvncZKviczO8zzvYx7TPx7fG1yHft0WYPdfSRDI0m/L6KmyfXZXJZEGTyuBZucAxHo/pOZyNzh97/cxTvoZdhX3UwYQ1+j5A+ygYRbN5Pp9jyH260kC2UJqCdqUP7/L+uc4+OgULjI6F7KOZ9pGIiLwHFgURESlYFEREpGBREBGR+kYzNXMu8OfhKdJiB0MlTjDIghpOKbpiAXEW3RL+rH2Xj3v/nJs/m6eb4RrEVqRhJdTII5YzGDQyHd84fl2HoUGp8UdQLMIJmo3EOQy3OcLAmyM0oA+xXZ0H6pxg33QXqEk8h2bwIkRXrCHO4uaS1+/h32V3IdJiDY3jRVf3rPQQf3E6h2OEWS0pcuFKe8o7n4YmKTWaF5TNAmCjOTzjx3l+N+lYiGYHDejD8HtlH6Sb13UaIgbXdrk+jm4od2uH7IiIyDtgURARkYJFQUREChYFEREpWBRERKTePuohuuBEf8L9ZWjr7MOgmregQRHLu+34IUDACQwh+tPz52/D89lul1WWEf2Z/ixYIu0MTJN5tonmM1iH7ZMNQnEWBA3l6SB2IUU9zGBwzAyMn2WTH9nboNRQbMUcDKH7fl61/hjWHy9dlWV0CwLXTTCKyDKiKBO6Pw3c5ksYEHMCV4sMGTKB2vC8dcl2eoOmHb/v1/3PhibQYQeWEUW8nOqO8RjsowNYRrTvbg7RFYvx9lEL8Rdj8JeCiIgULAoiIlKwKIiISMGiICIiBYuCiIjU20cXygqCwTnJ4jmDldOBIbO6z3lG82AfTSHj5wh2VE3G0ZVtMKeOkNlEZkZHGTVhfQZZLGQTzWfZNpjCZyba86XqfOaUtwSfuToO93Pf52t4vFBuUdZ1HppgCOVdYJbRGo7lAdbvg8V0D8d31+WDWcE1XC7O420vuN4tGDVkCI01kl7X4Txp3014hvoehuxMp1W2zmma789hPx9tKpEZeIRstx7eifSdcAbLio5lCc/EPAwMm60OP3yPB8f13f+niIj8m8OiICIiBYuCiIgULAoiIlKwKIiISL19dIBMoJRx9Lr9ZjG6I768HdpEVxYP2T6a3oS8D8hmOobjeCvjaANWUjIZKCuIzpOMojQhagYGwgym0dH2NRYC5dzQlDbKW7pZjZ/U1hzytvM+Wx+PZ7CVSDVK+wZzZl2ZT3QbpuOtgzV0ZQV2HBlc6VlBs6fSNCHTJj3PfV+3D1pPKljNcby5DnbPKdiO+6Yuh6iBvCXaPpl6dH9W6/y9N1/tR2fBtfAOXo6jv9qH+/zu/1NERP7NYVEQEZGCRUFERAoWBRERKVgURESkMLpFTZbR9ilnH51Ow10vb3K3ffn4EtdnIePoShuyXo6bPB3r8JJtgy1YRjuYknSqmBKFWTQ0ISrYPR1YKWQC1ZopyfxI09iuXOAzF5XTndJ1We/yI/i4z9f7GAym12MMeUaU/UOT4RYw8Wo5h/MPOVRkZM3e6X4mai0eyrJK2Ve0be2UvnQvaq0pymEiE+gwCcYgvMdTyE8iaibPLckmWubcosV6mHF0pQvvW0/XBL73xuAvBRERKVgURESkYFEQEZGCRUFERAqjuytbaDQfd7nB24WhLyuIrcA4i3VuxPShsXSCOAsaprN9yevH4+yHG7O4DjEX3fQyKvrirT+7J6gRVQMN6mnaY1UUxyo01u5v65qhl/EzgyYt/JOHri01fen80/YkE7ThHr8ZFxHuG21LEsS0sjHbNNPR17s5jxcYftv3jzea6Vmm80/N8LbJX3l03wg69sVy2FSeL/L32ArifVKcxetnhmfofMjfV4enPFxsDP5SEBGRgkVBREQKFgURESlYFEREpGBREBGR74i5AFuHbINFGISz+vAct+3ucxe+AVsn/Qn34WVZddz73eKH/3y9xiZ63R7tlvEDVQg67n5SOwxlvE3VTfsq0+Y9DJSaOA/attYQauBS1Rw7RTRcYDhUimNI0TFXWjK14N7/36T2ftY8y0c6fzCh3uN5a+GZoEiUeYiiWEG8zwIsoylEovThWTnts320/Zpt0TH4S0FERAoWBRERKVgURESkYFEQEZGCRUFEROrto+Mhb0qd9XUwjeYwTAczjg450yTlHJF9tKehOcfxQ3NejzEYK2TfoJUEmUA1uStoGVXYRLWQsVF7nmn7DvZBphbZIOka0nWttYno2iajiIa4nI75/clXKptGZCqdaB0+kyye06kdf+7v8LzREKTLhWyi8Wbg6/7b8dvW5l4tQsbRlXX4PlzejB+a89tB5mM8hu+9HQw523y9nXwv/lIQEZGCRUFERAoWBRERKVgURESkYFEQEZF6+4hMDpqmtvzpabDWPVZmHMH0oMPzcH0Pk9cOkA1SMyHqSjc7jb4mbN+MN2cwgwnMDLREaPxY3aCpfCyV2UKzcA3J4pjNT6Mn+r1+ZldjH1VeQzSKhuvHfZ5ESOZQ3+dXMFlMe3iW94f8mTvY/giT17J9NKmCzK5kGmGOFU3Mo8wqmEYYjcGKd/DKkiwjmJqWTKP5KtuVLXzvUZ5RMixfIOOIrMsx+EtBREQKFgURESlYFEREpGBREBGRgkVBRETq7SPK77j5+C2uzz4Mc46aZTZH+j1ksYQJa5QBQtbHGUwLgjJ3kimRjKQ383xgPdHDpC6avnU511kVF1I83oEGbJB0LFPIMiLLaAZ5MWlaVUv3Eo4vTbZ6+xkaPnPnU53WRfs+HIYGym6f34dnMO+2u/ys7A9wnuGZo+lt7YSMH1ifjreGZvRMTPOxkFGU7KMZmIHL5WF0ltGV1Tp/Hy7C+hSmtJ0gT+64y99l229D02jztKqywMbgLwURESlYFEREpGBREBGRgkVBRETqG823H4exFVcWv8vr04dhw6WZQdPzGzSat/PRjRgaAkTRBTSshQfKpD+ZpyiGumE66TMp5qIWOv+0TlEMtfum/aRzSoNqaNu3PvNdgHsPvdYqQYDOh4bypHiWDbwPz5sci/C0hUYzHOOxItKCWu8zaB534SMX0CDu8+nguzmD9XmISsGG8m2O61nfQIwPNKC70FS+0LAjiLPYveTm8cu39ejn5+YuDzQbg78URESkYFEQEZGCRUFERAoWBRERKVgURESk3j5a//5rXJ/9lLvczfowOs7ivJlX2Ufpz8NrLSOKoqiJvyDLiKIbamIuLmcYQEKGDFBj65yb6bsYP2TanEKkwwHiSWr/TD99JtlhGHMBVs65YsjOmaIycB9gpoQ4k/0h72ML65tzPp8tPEJHiK5IzEDJmsNnrqYhJgYHXeXP7OC9WkCMxGq1H20T3YB9tLrNcRYdDIFK5t0B7LDdJg8R2zwPLaMrxxB9QkOqbh+fJ9+LvxRERKRgURARkYJFQUREChYFEREpWBRERKTePqKMozZkHL0SbIN+m7vwZxgqcYJskJpcoJqhObX7IcuoBcuIso8icHxkzuBuYPt0/qfjpep61+YzpYEyRzBNyHhKBtOVbn8eb3vVGlyUW3RqRxkitO3b17YiawoeK3raatdrIHMozceZk00UBiZdWa9ybtEtGEK3t0Mz8uYOsoxgaE4Hw57IVNvthrlFe7CMti95fQ9GXjImb+7z+dz9IduiY/CXgoiIFCwKIiJSsCiIiEjBoiAiIgWLgoiI1NtH048wyWeVM0AmYerTBe0jsIzA2EgRLWQZzRfZHqidMpYylNrpO1hGANlRF1gffSPfgI6bcntwalrFtU35QW/t+xQygejY6Rq+x/0hc4jsKDruc4XBRdk/s2D6XVleIOMJ8olSnhFFUM3hPyzhWG7mw3flbp3fzdubbALd3eVpZ3d3OednfTvcfhnykK50YDyd4dnfbxej17ebPEltD9YlPbd398PzvP/9l7jtSvtIRETeA4uCiIgULAoiIlKwKIiISH1/srnLDRoiRVqcYWjOOQzNed0HNOFSdAMNvWih8dVDr7GBMhmbP5VxCUiIL7hQQgPGX8Bgn5Qv8Lqf4+gG7BQOJsVWXLlMadBMO7opTfs+VQ78eY+IE9o+xU5QbAU1LImuG96LxSI/43fQlJ/u8nu1hGveJ4GDxAZ4r9bLfIyr5fB5u4OG8hoiJ9Y0CAe2n4fhO/SekPBwgtiSHTSa0/p+n7clbu+y1PPwu2Hz+CasXZn/PscSjcFfCiIiUrAoiIhIwaIgIiIFi4KIiBQsCiIi8h3pCLPL6DiLK5fN0DS6UJzFsS6kYTo7/ZAh8tb6uwByCw3mSGZKC/W6T4rIW5EOEI2Q/j3QNNky6vu8TtEiaOAEo4jiH45gpJHFk/aNA2wq731Lxtc72Ge0j3kY7kLbzrps/KxX8G7Cc1gVrQGxEIt5HoSzXA7XF8tsNC7Ctlfmi8Po4TNkKZ7hu+YAltF+t6iKqEjb0/N2c5NtqoefslF09/vh+uof8rbth7zvMfhLQUREChYFEREpWBRERKRgURARkYJFQURECuO1H8pLeYE8o+dhF/68B/sIhn5QTsksDM7pIfuoFjKE8rZt3fAZyPNJlsQJLImmeR9rKn1mQ9oUMJ1c6iyrYCuRHVVrk0WzqTJXqdZIS1lRdD5tuN5XppQ3NR+uzyuf8drzSdec8rC6YAC+roMJlYbYzEI20VtWGx0LCHmTQ/i+OeznP2wTXdnDd1m65mvIeHr48C2uP/4hD865+eNwvfvdc93wsxH4S0FERAoWBRERKVgURESkYFEQEZGCRUFERL7DPtrBlK2n3J1PU9ZowlqaPHalDdOn/venjjYT3ms6WjKN0D4Cm4pyV050XdJxwLWqzflJE894qhvlKkHmTAemTTiW7lyXq0T3OR07XiuykuAa4n7CejrH1+ODrCCcdhfyfOia1OZe4fbJSINt8f6gfXX54ewoyr0iUy8ZRTQFbU9W0j5bRsR6Ncxzun/IU9Aef58to1uwj+Z/HNpKzW3Og5rAOzsGfymIiEjBoiAiIgWLgoiIFCwKIiJSsCiIiEhhtPbSg2V0el7m9c14+4jsDrJbkpXUwvQlWq/OPgrHSFlGZLdMZ+ONjSPYA3R8lxMYNXE15zP1PRx3pcUyDVPD2CbL23azadWUrZhDBGZP2+Zndg/Tt8huSaDBVWkIpQyhlB/0lglE+UR8XdI1rDPSiPTcnuE9oWl875FbdIDvoMNxfJbRldUq5xndPw5Now9gGd2DZUTT1KYP4TPn8IYf8vszBn8piIhIwaIgIiIFi4KIiBQsCiIiUhjdQTt9Wef1p1Ve3y5GN2YJirnolsM/7Z7CAJIGGnk1DeXftg+xEHB8LTR9LzUN28oIABw+A9EAk+N09La0PoNDpOFI6X7SoBVa7+A+d2F7HAQDDdsuPLNvNTgpFiPu+x0iKmiAzXyRow5mcK2msJ922r/DsCNoHocmPj1X1DjebbMgsKsYhHMMz/1brMJ3zZUHiq74OGwe3//hc9z25h9yo7n78AIHE94JiNTpn/M1HIO/FEREpGBREBGRgkVBREQKFgURESlYFEREpN4+Ony+yetkH4XOPxk/U7BEcD1YFS0YJThsAv7Evq9LxchQ1AHYR2RO1dDT4BgaTBJsEBw+Q1YS2GQYWxKsJLSMFmAlgQ0yW8zGm0pdZVwE2DrHEI1Aw45qh9WkaBGyqcgymsE1RPuIBlVVPRP0DLUVsRWLH7aMXvdfMbwKLaPHbBl9+F2OongM0RW3f8jbzn56jus4OKfCMjr/mm3RMe6VvxRERKRgURARkYJFQUREChYFEREpWBREROQ77KNvuZt9CMN0rpzDYBIaeNNRJhCsV+UCgfHUkyUBA1UuITOFjB+yb94l96nP5kh/ycYC2TCnYGYc4dwPMHzmCHYH5i0FpnCeZJ7NVuNtJbJvOFcJ1l9Woy0ZuiY1RhbZSmQwoe1WMUzndfuQfTSBj+xPTd3zFgbn0LU6Vj5vlGeUrtcSnonHD9/i+k+/y/lED7B+G+yjxe+ywdSmoTlX6HtvG2y3L/nZPPxyG9fHJCL5S0FERAoWBRERKVgURESkYFEQEZGCRUFEROrtox1lHFXki5B91EA+Ea0nKFfpAkbNaZcNh9N2Pvo80zS2t0AbJFgfLU3qgn1QVhBmIgVjI+UhvZVFc9iTDZL3cwn3CDOBaMrYCrKPQnYN5SR1MKlsWjup7Xm4voPpbcm+udKTUBSuC1ptFdMC39pPEw6G8rBo3zRdMeVk0TU50j7gM6fJmro+K7PhO3H/kPOGPnzM+UT3kHF0B3lGy49D06h73MRtmzkErZHVF0yjwy93cdvd52wf5dV/ib8URESkYFEQEZGCRUFERAoWBRERKYzuEu9flnG9ZnBOSw1lirmoaDRTQ/kIjeMjnM/+JTcKj7vhfk7wmQQOVAmNTGySwkAVHuCTG9Dz9fDfAydoEO9hGAo1VWn7FF9Azw89K3T+6Xp10JTulhRzUddoTjJAC/cBG9DwDKVmMA01OlHMQ0WExpXL5TK6oUyfeTqNX8chTfBMdDQECe7P7e3L+IYyrN9+/Da6oXxl9nH4mc0KommO0MSn76BPwzbxjhrNEEs0Bn8piIhIwaIgIiIFi4KIiBQsCiIiUrAoiIjIdwzZCfbNW0bNfHUZHSNA62RPJCPifADrAewjsox2zznOYxcGrbzXQJVkvSxW+7jtYp0Hc8zX+6ohNmkADe17tZ9VGTXbbTa7NsngghgFAofvBPtoCpbRDKykliyjrnIIVAVbMG1SBATFQhD0HJJRRNEqNcOoaMASxWXUPLPzNt/71Xob1+8fh4bQbVi7cvMhx1+sf5ftoznYR806P1uJHgaUHX+5ieu7X4f20fZL3na/ye/mGPylICIiBYuCiIgULAoiIlKwKIiISMGiICIihdE6AxoLMNwlDTKhLJop5fmAhdCH3JULWA9pmMxbA2XIstqHdRo+c641aoLFstztqs6HBq2QlZTMrjnkLS1vst2xhmu1DabWlc1maCU9PcFAHriGlC00C88QWUY0kKiD86fhUDVDZuj55AyhbvS29LyRCXQ+w/nDYKOqfVOeUXg+6V4upjBIKQzNuXJ7P8wbunLz8DLaMlqBTTT/mLdv7/ajv7P6bX7Gz9/ye7IPltGVTRics3teVn2PjcFfCiIiUrAoiIhIwaIgIiIFi4KIiBQsCiIiUm8fUS4KZvTcDu2Z2U02aiijhujPzehpUk2WcjCHiHJX0vaULUPTtMjYSFCu0gUssFqSldRCrtAc7vGKrKTbTVx/CVbSZpsnRB2+ZgOD6LqK6XVgH9H5kx03vxue/+UEk8rgfpIlstv2440fyP06wjNO09HSNaT3hJ79mmccJxHC+hKeQ3rekn20Avto8VNenz7mZ7xZjp+mdnnJ9/jwJT/7mGcUpkXuIX+M7s8Y/KUgIiIFi4KIiBQsCiIiUrAoiIhIwaIgIiL19hFO5XrMuSPz+6ERMLvP+2ggW6aHTJeUwzQ9wkQuyL+5wMSr9yFbBftd/sxjyGGqmVT1ln3VTsHKCrkzaRrb6zrYYavbbGbcglGzeR5el6dgVFx5hqlU5/PdaGtssQQzDiyW6RzO/zZv36a8Jciamm/z+uzlONrAIfMsPT+v21facbNw/mQCUW4RWS/p+exoih6sr+/GW0ZXVo9Do2gJllH34eWHJ6m9sg+ZVU/5Gd9/he8JmP54CFlr9Ex0MEVwDP5SEBGRgkVBREQKFgURESlYFEREpL7RvIaG8gKaPLOHYRNyCg27CTRJ+0PFQBloHDctNGCpyQXRCKlhTfEPs6+5ebh5yo2lTYh/OOzhT+MPef3lCc4TYgrSkB1qVncU8wBN/HWQDK7cbYZNvqfQfH6r0fy8zevTX+6HxwdDWajRjPEXEH2S4lkosoWeqzk0w1MTlu7PEYbvHMOgntf1FhrNYftFGJb1ZgManrfUmKaG8gqkFoqzWD3k9WX4zuo+5G3be/hump9HN5SvXMJAneMTNI5BsjjuafBUMz4SBCJoxuAvBRERKVgURESkYFEQEZGCRUFERAoWBRERqbePUif/yuwxd/O7sN6sYDBFFhYmTdeNL2UU8wBGSbfOxsYFBpAsdsNu/vJlWxUJQtbL7MvwGF/AytmHP3V/00qC/bTBykJTqcnn00I8yRLO/+5haB89BvPqyssmn+enz3n7z9+G289nD1XDgei4Kf5iGa5hsrp+28epyniahe1rB96glTSBYT0VA5zmFAkCxtc02Ud0XWEY1zIMNbqygPiLZEC2d3nfE/huIsiMPL8Mn8MjPMtoGcF9SFEuZLUt4ZqMwV8KIiJSsCiIiEjBoiAiIgWLgoiIFCwKIiJSbx/NwT6iLJHmIXT5YTBHc2rrBnaEDBCsbmA21ZIG/sx32R6YgyVBA3/ScBsakvH0NVtWuy1YSZCh9PIc7CO4P7RO2UeUlbS+Gz5DDx/ycb/AoBHKRPq2Gd6LX2CIyfrnD3H9BrJ16L5Nwz2a3cAAH8j5oWs1mx9GD6WhTCSyWMgySu/blGwqWCf7KJlTczCv0N4DK2l2C9ZYMI2adf7MyQy+KPZwrXb5q/McsrlOZBmB6YgZZCGHqnb42Rj8pSAiIgWLgoiIFCwKIiJSsCiIiEjBoiAiIvX2UfdT7mY3H2DCz/I83gQKZk810LFvZnl9Qjk/ZCGE/U/PYJqss63SgmmSzBTOIeqrTC2ykrabPPWp5jMnk2GW0VtWUrJ4bu/zPh4/UCZSPu59yKLZgTny69fbuH776UNVVlLMnaFJf2TxQH5UspIobyhl4rzFGd63Phx6B9PbZpe6rKB0nnOaRkeT8cgCg/UmTcGjSWrEIRtCPZiH52AaXcCuJJLVdmUW7COaOjeHTLox+EtBREQKFgURESlYFEREpGBREBGR+kZzm2Ir3hpOMQ1dqwPUIGrEUJNn342KoXir8dfktITJ5ALbp8Y5NK0wFoIatmGZzud8ztfkBANVznBtd9thw3YDA28QbEBPRjdmlxBR8PjTt7i+3eRj3IY4j1+/5ib7c4jEuPLly11cv7u/Hz0MBpuE67r4ixR9soDG7CI0IK90Xb5WB0h6SLLCOUTK0LZvRjR0p1FRHq/rqUH8xqCiFrZvlqfR3weTUzP6u4biLK5cwnvYQ6wIDWSawTOxCO/K/B6iWYy5EBGR98CiICIiBYuCiIgULAoiIlKwKIiISL19VGUZXUnWAgym6LcwhAIGqqTOfw+WTYODfcAcWoDhkE6T/mSehtWssiXRhWEgc7AbVjCw4wjr+102cPb74foOtj3DMBAEzJSbEItB9s36PtsTHz5+ieu73fB6HY9gXh3yc/j8kiM0vn3NVtJNOEaK+Gin8KyQrZNiLpbZYFquYCjNPNtHRzLVLmF4FfyzkSwjMu/S0CgaMNR2sE5Dhug9TMcYzvHtOIsur9M1PAYzEt4HiidJw3SuLG6HcSszGOjV3uVnZQz+UhARkYJFQUREChYFEREpWBRERKRgURARke+wj2j4DHTWJ8n8gByRC9hHZ7KPgmmSMkfeooXhJpSj0i660aZSA/uma5UMKRooEge7XM0EGEyyWu9GD9nZbiAraJ8tlhPkMF3I8Ais77JlRGbK3eNTXN+H7KPDMT9Xv35Zx/UTGGwvzzDw59vNYG19u6kySrqQcXRlGgbq0D1ewxAgyok6wuCcZCVNwZqa0tAgMu/CfvAdBKOxBVunoTyj9L5Rzhp8N/X0nQXfN3149injaDqH7CN690P20fQmPxMNmI5j8JeCiIgULAoiIlKwKIiISMGiICIiBYuCiIh8h31EgJSUuvw95YvA+iXkiFw574ZWyRnybGonRLXBbCIbZEr2EUzfovVJmLJGRgVO9gKLhfJy0hSv9jl/5mGTr+0e8pZo2lsNZCWRgfMQrKRDMJLemia2gewnspjSpLpdsLquLMASofuZ1slKWYF9dLPNJtTpOP5+TsEQ6iCHqEUrKdhHNBUR9kFT05Lx87oeDMgGJhr2W7CMdvAMwbOfJibSeZJ91YFhmMxIylNDW3QE/lIQEZGCRUFERAoWBRERKVgURESkYFEQEZHvsI+ofIDJgROO3oFkFF1gOhhmlJCVBOZD281HGUm/rZ/rJkcFO4GMCjIW6FjmYDKkaV1LMJWen7NRs4HpcAewWy6XYKRRdhbYYWTarO6Gps0j2WvwrLRfJ1Uku4nso/V+U5VllSbSzcG8Wt5mE+Z2nw2uMxg43XY5+jmczY51VlLILaKpiGQZ4XdKRZ4R7Bnz1y6UfUSfGZ5bfmfzteogf22a1sGAnEBO1Bj8pSAiIgWLgoiIFCwKIiJSsCiIiEh9o7mnARdNM/rPrBtowOI6DuEI+4bGZGpuXjnTUJ6KBnQLf+qemoSv22OkwWn84BA4TxpKQ9EIKS6CBvKsljBkBobyPMFwpEO45rUxJMQyHPsNRGVQo5mOZQdRB+nZ2lNUxjavL252o8UBusepyX6lBwmEzrML7xs2peHdnMGzn2IuMM6CYitg/QIRN/FdgXO/UGTLHuJz4HslvbdpwNBbcRaxoQyRFvTdacyFiIi8CxYFEREpWBRERKRgURARkYJFQUREviPmYkEDLmBQxiRYCGBDtGEYxpUpDd8JpkALlgBZLGQPUFxGH3ZD4hUOzwB75BJMEzKVcIgJ7JuiEVa3w7iIA1g2OzBnnsOQmSsvYQjSla/Pw/XL5b5uCBINLAnXhQYP3T48V5lq06ebvH0wc07w/NC1PYE5M181o+8xxkUAZLZ14Tk8gpVDzz4NdUpDg/DdJEOIomzg3U+mUa3B1J9rY3J+POYiDdN53XeKtFjmffdL7SMREXkHLAoiIlKwKIiISMGiICIiBYuCiIjU20fnm7osmnZxHm2ONDRQBuyjaTAiyB5o95CrhOZDXJ6cw8AWNBDgWMie6IKV1V2ygUBDNchwmN/sR9tXJxhKczxmA2UbhrJceYHhOy+74fn/8gS5Qv1DpZU0tC0efspTc8hKunt8qvrMfTCKaNsTZG2dwO5JJlQHlhEOtoHtaT1lcB0rcp9e90E5P8mwm9Z9p/SQw3SB55YMw7gPMh3PkHEE9znltZFlVJNx9LrvdchKusnb9mvtIxEReQcsCiIiUrAoiIhIwaIgIiIFi4KIiNTbR6f7uvrR7ofd7+4CNsQRuvCQaTLdDbvwZzBeyLTAqU9AMo1wehtAxkaCc5XguMn6gMlryZ4gm4osjuNhVjWpbBvu5y+bfI9/BiupbR7j+jRclykYWfcfsmU0h0lYt5OcldTNlqMNLrq2dA3PyWDLEUyTKRhpHdgtU7Cv0pS+A0zRO8Nx02TAZDbRRDICc4vgPWwga60m42hCAxDh+6MJRhVaRskmemN9shpewwtYRufb7//C95eCiIgULAoiIlKwKIiISMGiICIiBYuCiIh8h30E3eyGJJ52WG8uwUh63cec1mHS1DzkKlH+C+bCQHYJCAvJHiGbCKe6kX0VTIZka7zu45T33S3B+giZM7ReO8HrAnYH5fzsQ87PZp8frM8wje/PX/MUuLb9MFjrwG6hfJ7bx2wZLdc7+Mzh9Trus61D0LOSJrJRdhbl8JD1QuvJVOvWYB/BdD3MGwrHiPlBlc8hZSKlyWu1ZtOk0gJM3zdTsNpwwhpkH/U3wT4CI+10k69Jfnv+1XGN2EZERP6dYFEQEZGCRUFERAoWBRERqW80X2bQFIHGUpOajVSCaJ36RKHB11DjB9bxz9Sp+VURC3GGZnADXexTO7wN3Tzfmg4iCqhRlv7s/kob9tOGBv6bA4kodgCeicNh2LTcQsNy++sqrj9DD/JPn4cttK77qWooTQexGDcP0IC+GTagp7O8D4pEoWubhjrRQJ45NXdpyA4cY4pXmELkAg21omE1sQGNsSrjG8RvkfbTwKAvoqWYHJIYQuRIS4OxoKE8WY8fnHNewXdQfn1G4S8FEREpWBRERKRgURARkYJFQUREChYFERGpt4+QPteVNjTQG2i2N0ewDWhIRj/eKmhqh+yADTL2OGqH6VxpT/1og4liBPraz0xWFlgSFNxwQzECsH4Kg1n2EAuxgQFL26ds4HwJpsn0U1YwZt3HvA6GXQdRIau77WBtsdrHbc8dWDlk4FQMdTrTMKoVGE8UrxDufwP2UQ8xJBcaMhSOvadnHOI8KOIFn/2KmAv8nmj6OqsxmF0pluet9cki77sPj34/g+en0rL65/hLQUREChYFEREpWBRERKRgURARkYJFQURE6u2jKWTUTLNsMem+DTvo7QvYAFswFsCqSEM1MPuHsozIVqro2qM5UmkCJdPocgYDA4wsGjTSk8FVMZBoAoM85viZef0xGCiHYCRd2W7zOJDNfjhM58pfDsPP/Bnkjtnf8wktF9lKmkPeVBdMk+XtJu9jTUOTpqMtOBzIA5lIHb0/y+loG6aBZyKZSq/rx9Noo6innCQwmBrYHo2n8F7RO1s78KepWG8gU2tC62RAptsPEmVLRucI/KUgIiIFi4KIiBQsCiIiUrAoiIhIwaIgIiL19tHsS25zT1/y9u3zsN4037Il0X/L+Tf9FrZPFgJJQzVZRpVTn3ro/JPhcAErJ+UwUc4LWUmYiUTbJysJjrsFSyJNb7syux1OJLtycxhOMHsEy+iPm2Vcf9mAlfS328Ha3+H+/BVyexZ/uc/r85z/M18M1zvIT1rCNZmuDj/8HJLBdAJjkCaBJUumJ/uI7JslbH8ebt/DPmh90uTzIS7p6w3eq3ej/fHsNFpvguk53Vzq7KOH//Nh+UtBREQKFgURESlYFEREpGBREBGR72g0/w2apC/wZ/ovw6ZQ/5ybhJfNrOrP1ycp5qJioMabYHRF88MN5Qs0D1OTmAb1UIQExV/QscSoENiWwAEkIf7hymw97JStH7Kp8OHj17j+D8/ruP4SpITtl/y8fYFsgD9B3MryrzlaY7k8jI/EgPUFDPBpKsZf4XMI7895Ox9/P+keTw51g2Ni/ENlo/UMw2qgedyE4VU9iScV7/2b3zfpvQIRgGI+mk1eb9M1PFZEYlz5R1gf8b+KiMi/QywKIiJSsCiIiEjBoiAiIgWLgoiIFEY7Ds2f82CSHoyNy2Y+2npIwzCq/5S8Ihbg9TNhezKEksVzpkE4lcZC2jcO8Kkc7ENDdpIRcTlUKC9vWRU02CeYH908xyKsYFjN40/ZSvrjy2qw9gQxKbt9Pr5vZCV9zRbT+q/DoTyLZZ46NQ+m0lvnPw+mFtleBD0TZxi+E02jSlunvZBNBVbSe1Dz6tcOxmry+V/y7cz3iCJBOojtoIE/4XuymcL9qfw+/Of4S0FERAoWBRERKVgURESkYFEQEZGCRUFERApN3/d1SoOIiPybxV8KIiJSsCiIiEjBoiAiIgWLgoiIFCwKIiJSsCiIiEjBoiAiIgWLgoiIFCwKIiIy+Sf+F1KtwTd/RZntAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -852,7 +852,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ diff --git a/demo/cfd/vorticity.gif b/demo/cfd/vorticity.gif index 759b57a..07df6e1 100644 Binary files a/demo/cfd/vorticity.gif and b/demo/cfd/vorticity.gif differ