diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..29a8006 --- /dev/null +++ b/.gitignore @@ -0,0 +1,572 @@ +# Created by https://www.gitignore.io/api/data,linux,macos,python,windows,pycharm,database,jupyternotebook +# Edit at https://www.gitignore.io/?templates=data,linux,macos,python,windows,pycharm,database,jupyternotebook + + +### Local Datasets ### +/experiments +/setups/experiments + +### Data ### +*.csv +*.dat +*.efx +*.gbr +*.key +*.pps +*.ppt +*.pptx +*.sdf +*.tax2010 +*.vcf +*.xml + +### Database ### +*.accdb +*.db +*.dbf +*.mdb +*.pdb +*.sqlite3 + +### JupyterNotebook ### +.ipynb_checkpoints +*/.ipynb_checkpoints/* + +# Remove previous ipynb_checkpoints +# git rm -r .ipynb_checkpoints/ +# + +### Linux ### +*~ + +# temporary files which can be created if a process still has a handle open of a deleted file +.fuse_hidden* + +# KDE directory preferences +.directory + +# Linux trash folder which might appear on any partition or disk +.Trash-* + +# .nfs files are created when an open file is removed but is still being accessed +.nfs* + +### macOS ### +# General +.DS_Store +.AppleDouble +.LSOverride + +# Icon must end with two \r +Icon + +# Thumbnails +._* + +# Files that might appear in the root of a volume +.DocumentRevisions-V100 +.fseventsd +.Spotlight-V100 +.TemporaryItems +.Trashes +.VolumeIcon.icns +.com.apple.timemachine.donotpresent + +# Directories potentially created on remote AFP share +.AppleDB +.AppleDesktop +Network Trash Folder +Temporary Items +.apdisk + +### PyCharm ### +# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and WebStorm +# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839 + +# User-specific stuff +.idea/**/workspace.xml +.idea/**/tasks.xml +.idea/**/usage.statistics.xml +.idea/**/dictionaries +.idea/**/shelf + +# Generated files +.idea/**/contentModel.xml + +# Sensitive or high-churn files +.idea/**/dataSources/ +.idea/**/dataSources.ids +.idea/**/dataSources.local.xml +.idea/**/sqlDataSources.xml +.idea/**/dynamic.xml +.idea/**/uiDesigner.xml +.idea/**/dbnavigator.xml + +# Gradle +.idea/**/gradle.xml +.idea/**/libraries + +# Gradle and Maven with auto-import +# When using Gradle or Maven with auto-import, you should exclude module files, +# since they will be recreated, and may cause churn. Uncomment if using +# auto-import. +# .idea/modules.xml +# .idea/*.iml +# .idea/modules + +# CMake +cmake-build-*/ + +# Mongo Explorer plugin +.idea/**/mongoSettings.xml + +# File-based project format +*.iws + +# IntelliJ +out/ + +# mpeltonen/sbt-idea plugin +.idea_modules/ + +# JIRA plugin +atlassian-ide-plugin.xml + +# Cursive Clojure plugin +.idea/replstate.xml + +# Crashlytics plugin (for Android Studio and IntelliJ) +com_crashlytics_export_strings.xml +crashlytics.properties +crashlytics-build.properties +fabric.properties + +# Editor-based Rest Client +.idea/httpRequests + +# Android studio 3.1+ serialized cache file +.idea/caches/build_file_checksums.ser + +### PyCharm Patch ### +# Comment Reason: https://github.com/joeblau/gitignore.io/issues/186#issuecomment-215987721 + +# *.iml +# modules.xml +# .idea/misc.xml +# *.ipr + +# Sonarlint plugin +.idea/sonarlint + +### Python ### +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +.hypothesis/ +.pytest_cache/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +target/ + +# Jupyter Notebook + +# IPython +profile_default/ +ipython_config.py + +# pyenv +.python-version + +# celery beat schedule file +celerybeat-schedule + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +### Python Patch ### +.venv/ + +### Windows ### +# Windows thumbnail cache files +Thumbs.db +ehthumbs.db +ehthumbs_vista.db + +# Dump file +*.stackdump + +# Folder config file +[Dd]esktop.ini + +# Recycle Bin used on file shares +$RECYCLE.BIN/ + +# Windows Installer files +*.cab +*.msi +*.msix +*.msm +*.msp + +# Windows shortcuts +*.lnk + +# pycharm +.idea/ + +####################################### +#### Tex related +## Core latex/pdflatex auxiliary files: +*.aux +*.lof +*.log +*.lot +*.fls +*.out +*.toc +*.fmt +*.fot +*.cb +*.cb2 +.*.lb + +## Intermediate documents: +*.dvi +*.xdv +*-converted-to.* +# these rules might exclude image files for figures etc. +# *.ps +# *.eps +# *.pdf + +## Generated if empty string is given at "Please type another file name for output:" +.pdf + +## Bibliography auxiliary files (bibtex/biblatex/biber): +*.bbl +*.bcf +*.blg +*-blx.aux +*-blx.bib +*.run.xml + +## Build tool auxiliary files: +*.fdb_latexmk +*.synctex +*.synctex(busy) +*.synctex.gz +*.synctex.gz(busy) +*.pdfsync + +## Build tool directories for auxiliary files +# latexrun +latex.out/ + +## Auxiliary and intermediate files from other packages: +# algorithms +*.alg +*.loa + +# achemso +acs-*.bib + +# amsthm +*.thm + +# beamer +*.nav +*.pre +*.snm +*.vrb + +# changes +*.soc + +# comment +*.cut + +# cprotect +*.cpt + +# elsarticle (documentclass of Elsevier journals) +*.spl + +# endnotes +*.ent + +# fixme +*.lox + +# feynmf/feynmp +*.mf +*.mp +*.t[1-9] +*.t[1-9][0-9] +*.tfm + +#(r)(e)ledmac/(r)(e)ledpar +*.end +*.?end +*.[1-9] +*.[1-9][0-9] +*.[1-9][0-9][0-9] +*.[1-9]R +*.[1-9][0-9]R +*.[1-9][0-9][0-9]R +*.eledsec[1-9] +*.eledsec[1-9]R +*.eledsec[1-9][0-9] +*.eledsec[1-9][0-9]R +*.eledsec[1-9][0-9][0-9] +*.eledsec[1-9][0-9][0-9]R + +# glossaries +*.acn +*.acr +*.glg +*.glo +*.gls +*.glsdefs + +# gnuplottex +*-gnuplottex-* + +# gregoriotex +*.gaux +*.gtex + +# htlatex +*.4ct +*.4tc +*.idv +*.lg +*.trc +*.xref + +# hyperref +*.brf + +# knitr +*-concordance.tex +# TODO Comment the next line if you want to keep your tikz graphics files +*.tikz +*-tikzDictionary + +# listings +*.lol + +# makeidx +*.idx +*.ilg +*.ind +*.ist + +# minitoc +*.maf +*.mlf +*.mlt +*.mtc[0-9]* +*.slf[0-9]* +*.slt[0-9]* +*.stc[0-9]* + +# minted +_minted* +*.pyg + +# morewrites +*.mw + +# nomencl +*.nlg +*.nlo +*.nls + +# pax +*.pax + +# pdfpcnotes +*.pdfpc + +# sagetex +*.sagetex.sage +*.sagetex.py +*.sagetex.scmd + +# scrwfile +*.wrt + +# sympy +*.sout +*.sympy +sympy-plots-for-*.tex/ + +# pdfcomment +*.upa +*.upb + +# pythontex +*.pytxcode +pythontex-files-*/ + +# tcolorbox +*.listing + +# thmtools +*.loe + +# TikZ & PGF +*.dpth +*.md5 +*.auxlock + +# todonotes +*.tdo + +# vhistory +*.hst +*.ver + +# easy-todo +*.lod + +# xcolor +*.xcp + +# xmpincl +*.xmpi + +# xindy +*.xdy + +# xypic precompiled matrices +*.xyc + +# endfloat +*.ttt +*.fff + +# Latexian +TSWLatexianTemp* + +## Editors: +# WinEdt +*.bak +*.sav + +# Texpad +.texpadtmp + +# LyX +*.lyx~ + +# Kile +*.backup + +# KBibTeX +*~[0-9]* + +# auto folder when using emacs and auctex +./auto/* +*.el + +# expex forward references with \gathertags +*-tags.tex + +# standalone packages +*.sta + + +# End of https://www.gitignore.io/api/data,linux,macos,python,windows,pycharm,database,jupyternotebook + diff --git a/README.md b/README.md index d8ca4a8..086618e 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,2 @@ -# cristian_lenta - BA code - +# bannana-networks + diff --git a/code/bar_plot.py b/code/bar_plot.py new file mode 100644 index 0000000..404d35c --- /dev/null +++ b/code/bar_plot.py @@ -0,0 +1,96 @@ +import os + +from experiment import Experiment +# noinspection PyUnresolvedReferences +from soup import Soup +from typing import List + +from collections import defaultdict + +from argparse import ArgumentParser +import numpy as np + +import plotly as pl +import plotly.graph_objs as go + +import colorlover as cl + +import dill + + +def build_args(): + arg_parser = ArgumentParser() + arg_parser.add_argument('-i', '--in_file', nargs=1, type=str) + arg_parser.add_argument('-o', '--out_file', nargs='?', default='out', type=str) + return arg_parser.parse_args() + + +def plot_bars(names_bars_tuple, filename='histogram_plot'): + # catagorical + ryb = cl.scales['10']['div']['RdYlBu'] + names, bars = names_bars_tuple + situations = list(bars[0].keys()) + names = ['Weightwise', 'Aggregating', 'Recurrent'] # [name.split(' ')[0] for name in names] + data_dict = {} + for idx, name in enumerate(names): + data_dict[name] = bars[idx] + + data = [] + + for idx, situation in enumerate(situations): + bar = go.Bar( + y=[data_dict[name][situation] for name in names], + # x=[key for key in data_dict[name].keys()], + x=names, + name=situation, + showlegend=True, + ) + data.append(bar) + + layout = dict(xaxis=dict(title="Networks", titlefont=dict(size=20)), + barmode='stack', + # height=400, width=400, + # margin=dict(l=20, r=20, t=20, b=20) + legend=dict(orientation="h", x=0.05) + ) + + fig = go.Figure(data=data, layout=layout) + pl.offline.plot(fig, auto_open=True, filename=filename) + pass + + +def search_and_apply(absolut_file_or_folder, plotting_function, files_to_look_for=[]): + if os.path.isdir(absolut_file_or_folder): + for sub_file_or_folder in os.scandir(absolut_file_or_folder): + search_and_apply(sub_file_or_folder.path, plotting_function, files_to_look_for=files_to_look_for) + elif absolut_file_or_folder.endswith('.dill'): + file_or_folder = os.path.split(absolut_file_or_folder)[-1] + if file_or_folder in files_to_look_for and not os.path.exists('{}.html'.format(file_or_folder[:-5])): + print('Apply Plotting function "{func}" on file "{file}"'.format(func=plotting_function.__name__, + file=absolut_file_or_folder) + ) + + with open(absolut_file_or_folder, 'rb') as in_f: + bars = dill.load(in_f) + + names_dill_location = os.path.join(*os.path.split(absolut_file_or_folder)[:-1], 'all_names.dill') + with open(names_dill_location, 'rb') as in_f: + names = dill.load(in_f) + + plotting_function((names, bars), filename='{}.html'.format(absolut_file_or_folder[:-5])) + + else: + pass + # This was not a file i should look for. + else: + # This was either another FilyType or Plot.html alerady exists. + pass + + +if __name__ == '__main__': + args = build_args() + in_file = args.in_file[0] + out_file = args.out_file + + search_and_apply(in_file, plot_bars, files_to_look_for=['all_counters.dill']) + # , 'all_names.dill', 'all_notable_nets.dill']) diff --git a/code/box_plots.py b/code/box_plots.py new file mode 100644 index 0000000..574bdd6 --- /dev/null +++ b/code/box_plots.py @@ -0,0 +1,129 @@ +import os + +from experiment import Experiment +# noinspection PyUnresolvedReferences +from soup import Soup +from typing import List + +from collections import defaultdict + +from argparse import ArgumentParser +import numpy as np + +import plotly as pl +import plotly.graph_objs as go + +import colorlover as cl + +import dill + + +def build_args(): + arg_parser = ArgumentParser() + arg_parser.add_argument('-i', '--in_file', nargs=1, type=str) + arg_parser.add_argument('-o', '--out_file', nargs='?', default='out', type=str) + return arg_parser.parse_args() + + +def plot_box(exp: Experiment, filename='histogram_plot'): + # catagorical + ryb = cl.scales['10']['div']['RdYlBu'] + + data = [] + + for d in range(exp.depth): + names = ['D 10e-{}'.format(d)] * exp.trials + data.extend(names) + + trace_list = [] + + vergence_box = go.Box( + y=exp.ys, + x=data, + name='Time to Vergence', + boxpoints=False, + showlegend=True, + marker=dict( + color=ryb[3] + ), + ) + fixpoint_box = go.Box( + y=exp.zs, + x=data, + name='Time as Fixpoint', + boxpoints=False, + showlegend=True, + marker=dict( + color=ryb[-1] + ), + ) + + trace_list.extend([vergence_box, fixpoint_box]) + + layout = dict(title='{}'.format('Known Fixpoint Variation'), + titlefont=dict(size=30), + legend=dict( + orientation="h", + x=.1, y=-0.1, + font=dict( + size=20, + color='black' + ), + ), + boxmode='group', + boxgap=0, + # barmode='group', + bargap=0, + xaxis=dict(showgrid=False, + zeroline=True, + tickangle=0, + showticklabels=True), + yaxis=dict( + title='Steps', + zeroline=False, + titlefont=dict( + size=30 + ) + ), + # height=400, width=400, + margin=dict(t=50) + ) + + fig = go.Figure(data=trace_list, layout=layout) + pl.offline.plot(fig, auto_open=True, filename=filename) + pass + + +def search_and_apply(absolut_file_or_folder, plotting_function, files_to_look_for=[]): + if os.path.isdir(absolut_file_or_folder): + for sub_file_or_folder in os.scandir(absolut_file_or_folder): + search_and_apply(sub_file_or_folder.path, plotting_function, files_to_look_for=files_to_look_for) + elif absolut_file_or_folder.endswith('.dill'): + file_or_folder = os.path.split(absolut_file_or_folder)[-1] + if file_or_folder in files_to_look_for and not os.path.exists('{}.html'.format(file_or_folder[:-5])): + print('Apply Plotting function "{func}" on file "{file}"'.format(func=plotting_function.__name__, + file=absolut_file_or_folder) + ) + + with open(absolut_file_or_folder, 'rb') as in_f: + exp = dill.load(in_f) + try: + plotting_function(exp, filename='{}.html'.format(absolut_file_or_folder[:-5])) + except AttributeError: + pass + + else: + pass + # This was not a file i should look for. + else: + # This was either another FilyType or Plot.html alerady exists. + pass + + +if __name__ == '__main__': + args = build_args() + in_file = args.in_file[0] + out_file = args.out_file + + search_and_apply(in_file, plot_box, files_to_look_for=['experiment.dill']) + # , 'all_names.dill', 'all_notable_nets.dill']) diff --git a/code/experiment.py b/code/experiment.py new file mode 100644 index 0000000..d75be60 --- /dev/null +++ b/code/experiment.py @@ -0,0 +1,120 @@ +import os +import time +import dill +from tqdm import tqdm +import copy + + +class Experiment: + + @staticmethod + def from_dill(path): + with open(path, "rb") as dill_file: + return dill.load(dill_file) + + def __init__(self, name=None, ident=None): + self.experiment_id = '{}_{}'.format(ident or '', time.time()) + self.experiment_name = name or 'unnamed_experiment' + self.next_iteration = 0 + self.log_messages = [] + self.historical_particles = {} + + def __enter__(self): + self.dir = os.path.join('experiments', 'exp-{name}-{id}-{it}'.format( + name=self.experiment_name, id=self.experiment_id, it=self.next_iteration) + ) + os.makedirs(self.dir) + print("** created {dir} **".format(dir=self.dir)) + return self + + def __exit__(self, exc_type, exc_value, traceback): + self.save(experiment=self.without_particles()) + self.save_log() + self.next_iteration += 1 + + def log(self, message, **kwargs): + self.log_messages.append(message) + print(message, **kwargs) + + def save_log(self, log_name="log"): + with open(os.path.join(self.dir, "{name}.txt".format(name=log_name)), "w") as log_file: + for log_message in self.log_messages: + print(str(log_message), file=log_file) + + def __copy__(self): + copy_ = Experiment(name=self.experiment_name,) + copy_.__dict__ = {attr: self.__dict__[attr] for attr in self.__dict__ if + attr not in ['particles', 'historical_particles']} + return copy_ + + def without_particles(self): + self_copy = copy.copy(self) + # self_copy.particles = [particle.states for particle in self.particles] + self_copy.historical_particles = {key: val.states for key, val in self.historical_particles.items()} + return self_copy + + def save(self, **kwargs): + for name, value in kwargs.items(): + with open(os.path.join(self.dir, "{name}.dill".format(name=name)), "wb") as dill_file: + dill.dump(value, dill_file) + + +class FixpointExperiment(Experiment): + + def __init__(self, **kwargs): + kwargs['name'] = self.__class__.__name__ if 'name' not in kwargs else kwargs['name'] + super().__init__(**kwargs) + self.counters = dict(divergent=0, fix_zero=0, fix_other=0, fix_sec=0, other=0) + self.interesting_fixpoints = [] + + def run_net(self, net, step_limit=100, run_id=0): + i = 0 + while i < step_limit and not net.is_diverged() and not net.is_fixpoint(): + net.self_attack() + i += 1 + if run_id: + net.save_state(time=i) + self.count(net) + + def count(self, net): + if net.is_diverged(): + self.counters['divergent'] += 1 + elif net.is_fixpoint(): + if net.is_zero(): + self.counters['fix_zero'] += 1 + else: + self.counters['fix_other'] += 1 + self.interesting_fixpoints.append(net.get_weights()) + elif net.is_fixpoint(2): + self.counters['fix_sec'] += 1 + else: + self.counters['other'] += 1 + + +class MixedFixpointExperiment(FixpointExperiment): + + def run_net(self, net, trains_per_application=100, step_limit=100, run_id=0): + + i = 0 + while i < step_limit and not net.is_diverged() and not net.is_fixpoint(): + net.self_attack() + with tqdm(postfix=["Loss", dict(value=0)]) as bar: + for _ in range(trains_per_application): + loss = net.compiled().train() + bar.postfix[1]["value"] = loss + bar.update() + i += 1 + if run_id: + net.save_state() + self.count(net) + + +class SoupExperiment(Experiment): + pass + + +class IdentLearningExperiment(Experiment): + + def __init__(self): + super(IdentLearningExperiment, self).__init__(name=self.__class__.__name__) + pass diff --git a/code/fixpoint-2.ipynb b/code/fixpoint-2.ipynb new file mode 100644 index 0000000..81aa9fd --- /dev/null +++ b/code/fixpoint-2.ipynb @@ -0,0 +1,832 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "Cygv_wPHYa5R" + }, + "source": [ + "# Learning Fixpoints\n", + "\n", + "We want to learn a function $f$ such that $f(x) = x$ for an initial $x$." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "DTY3MwI4TrMG" + }, + "source": [ + "## Related Work\n", + "\n", + "- Random NNs: https://arxiv.org/pdf/1710.06570.pdf\n", + "- Attractors: https://en.wikipedia.org/wiki/Attractor" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "autoexec": { + "startup": false, + "wait_interval": 0 + }, + "base_uri": "https://localhost:8080/", + "height": 103, + "output_extras": [ + { + "item_id": 1 + } + ] + }, + "colab_type": "code", + "executionInfo": { + "elapsed": 3128, + "status": "ok", + "timestamp": 1522832183139, + "user": { + "displayName": "Lenz Belzner", + "photoUrl": "https://lh3.googleusercontent.com/a/default-user=s128", + "userId": "102800868167498000139" + }, + "user_tz": -120 + }, + "id": "dXGZLAQARYjV", + "outputId": "e96a4de3-9eae-4f6b-ab96-eeaae849846c" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: keras in c:\\miniconda\\envs\\keras\\lib\\site-packages (2.2.4)\n", + "Requirement already satisfied: numpy>=1.9.1 in c:\\miniconda\\envs\\keras\\lib\\site-packages (from keras) (1.15.4)\n", + "Requirement already satisfied: scipy>=0.14 in c:\\miniconda\\envs\\keras\\lib\\site-packages (from keras) (1.1.0)\n", + "Requirement already satisfied: six>=1.9.0 in c:\\miniconda\\envs\\keras\\lib\\site-packages (from keras) (1.11.0)\n", + "Requirement already satisfied: pyyaml in c:\\miniconda\\envs\\keras\\lib\\site-packages (from keras) (3.13)\n", + "Requirement already satisfied: h5py in c:\\miniconda\\envs\\keras\\lib\\site-packages (from keras) (2.8.0)\n", + "Requirement already satisfied: keras_applications>=1.0.6 in c:\\miniconda\\envs\\keras\\lib\\site-packages (from keras) (1.0.6)\n", + "Requirement already satisfied: keras_preprocessing>=1.0.5 in c:\\miniconda\\envs\\keras\\lib\\site-packages (from keras) (1.0.5)\n" + ] + } + ], + "source": [ + "!pip install keras" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "autoexec": { + "startup": false, + "wait_interval": 0 + }, + "base_uri": "https://localhost:8080/", + "height": 34, + "output_extras": [ + { + "item_id": 1 + } + ] + }, + "colab_type": "code", + "executionInfo": { + "elapsed": 7843, + "status": "ok", + "timestamp": 1522832191020, + "user": { + "displayName": "Lenz Belzner", + "photoUrl": "https://lh3.googleusercontent.com/a/default-user=s128", + "userId": "102800868167498000139" + }, + "user_tz": -120 + }, + "id": "0yvVUGjTSYW3", + "outputId": "b087262b-51af-4e63-fe91-a45bce9e54e8" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Using TensorFlow backend.\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pylab as plt\n", + "from keras.models import Model\n", + "from keras.layers import Input, Dense" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "autoexec": { + "startup": false, + "wait_interval": 0 + } + }, + "colab_type": "code", + "id": "JUVIsqO9TjOX" + }, + "outputs": [], + "source": [ + "DIM = 2" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "RunnmxYmhhnm" + }, + "source": [ + "Setup the model." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": { + "autoexec": { + "startup": false, + "wait_interval": 0 + } + }, + "colab_type": "code", + "id": "06pEyryrSdHG" + }, + "outputs": [], + "source": [ + "def make_model():\n", + " a = Input(shape=(DIM,))\n", + " b = Dense(DIM)(a)\n", + " model = Model(inputs=a, outputs=b)\n", + " model.compile('sgd', 'mse')\n", + " return model" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "autoexec": { + "startup": false, + "wait_interval": 0 + } + }, + "colab_type": "code", + "id": "MOhqMK8iUCAj" + }, + "outputs": [], + "source": [ + "model = make_model()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "edL4F3vXhj5L" + }, + "source": [ + "We use a random initial point $x$, and train the network by minimizing $(f(x) - x)^2$." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "colab": { + "autoexec": { + "startup": false, + "wait_interval": 0 + } + }, + "colab_type": "code", + "id": "arfIdBXbTZw_" + }, + "outputs": [], + "source": [ + "x = []\n", + "x.append(np.random.uniform(size=(1, DIM)))\n", + "for _ in range(100):\n", + " new_x = model.predict(x[-1])\n", + " x.append(new_x)\n", + " model.fit(x[-1], new_x, verbose=0)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "FJrlXoLMh52E" + }, + "source": [ + "This is the resulting trajectory of $x$, plotted by dimension." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "colab": { + "autoexec": { + "startup": false, + "wait_interval": 0 + }, + "base_uri": "https://localhost:8080/", + "height": 366, + "output_extras": [ + { + "item_id": 1 + }, + { + "item_id": 2 + } + ] + }, + "colab_type": "code", + "executionInfo": { + "elapsed": 641, + "status": "ok", + "timestamp": 1522832197171, + "user": { + "displayName": "Lenz Belzner", + "photoUrl": "https://lh3.googleusercontent.com/a/default-user=s128", + "userId": "102800868167498000139" + }, + "user_tz": -120 + }, + "id": "AnoQzZmNUfLf", + "outputId": "4d68c369-a25e-468d-e673-ca3ba623a60a" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot([e[0][0] for e in x])\n", + "plt.plot([e[0][1] for e in x])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "4MElxuYKh-wz" + }, + "source": [ + "Same data, in 2D." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": { + "autoexec": { + "startup": false, + "wait_interval": 0 + }, + "base_uri": "https://localhost:8080/", + "height": 364, + "output_extras": [ + { + "item_id": 1 + }, + { + "item_id": 2 + } + ] + }, + "colab_type": "code", + "executionInfo": { + "elapsed": 470, + "status": "ok", + "timestamp": 1522832197784, + "user": { + "displayName": "Lenz Belzner", + "photoUrl": "https://lh3.googleusercontent.com/a/default-user=s128", + "userId": "102800868167498000139" + }, + "user_tz": -120 + }, + "id": "bw5I9K4bUgL6", + "outputId": "907a2322-b3db-49aa-a8f3-269e1242edfe" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter([e[0][0] for e in x], [e[0][1] for e in x], alpha=.5)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "k930dBsyiB7h" + }, + "source": [ + "This is what happens if we initialize the recurrent function application for new points $x$." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "colab": { + "autoexec": { + "startup": false, + "wait_interval": 0 + }, + "base_uri": "https://localhost:8080/", + "height": 348, + "output_extras": [ + { + "item_id": 1 + } + ] + }, + "colab_type": "code", + "executionInfo": { + "elapsed": 1170, + "status": "ok", + "timestamp": 1522832199086, + "user": { + "displayName": "Lenz Belzner", + "photoUrl": "https://lh3.googleusercontent.com/a/default-user=s128", + "userId": "102800868167498000139" + }, + "user_tz": -120 + }, + "id": "UoZHRg0PVEy6", + "outputId": "0207091e-9895-4892-b572-e5f7176a0e68" + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX8AAAD8CAYAAACfF6SlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4xLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvDW2N/gAAGD5JREFUeJzt3XFslPed5/H3x8bGboaxQyCAARe6SxwStGq30+i2VdNWBOT2VNI/ck162z2SVEW6KN0/eleJU1fVKf1ju12t9k5tTreomyxbqZem1W1D97IEyqab1bZUONtuDsLNhpJNAAOhIXgy6Rgb+3t/zMRrOwM2nseeGT+fl2TN8zzz8/y+Pwwf//jNM8+jiMDMzNKlpd4FmJnZwnP4m5mlkMPfzCyFHP5mZink8DczSyGHv5lZCjn8zcxSyOFvZpZCDn8zsxRaUu8CrmbFihWxYcOGepdhZtZUnn/++V9FxMqZ2jVs+G/YsIGBgYF6l2Fm1lQkvTKbdl72MTNLIYe/mVkKOfzNzFLI4W9mlkIOfzOzFHL4m5mlkMPfzCyFGvY8fzOrrpTPUzxwkNHBQdp6eshs30ZnX1+9y7Im45m/WRMp5fNcfOxxxgoFlqxezVihwMXHHqeUz9e7NGsyiYS/pH5JeUknJO2u8nyvpGcl/VzSC5I+kUS/ZmlTPHCQ1myW1mwWtbRMbBcPHKx3adZkag5/Sa3Ao8DHgduAz0i6bVqzPwCejIj3AfcB/6PWfs3SaHRwkJZMZsqxlkyG0cHBOlVkzSqJmf8dwImIOBkRI8ATwN3T2gSQrWx3Af6bajYHbT09jBeLU46NF4u09fTUqSJrVkmE/1rg1KT905Vjk/1X4LOSTgNPA19IoF+z1Mls38ZYocBYoUCMj09sZ7Zvq3dp1mSSCH9VORbT9j8D/EVErAM+AXxb0jv6lrRL0oCkgQsXLiRQmtni0tnXx/IHH6A1m+XKuXO0ZrMsf/ABn+1j1y2JUz1PA+sn7a/jncs6nwP6ASLip5I6gBXAa5MbRcQeYA9ALpeb/gvEzCj/AnDYW62SmPkfATZJ2iipnfIbuvumtXkV2AogaTPQAXhqb2ZWJzWHf0RcAR4GngGOUz6r55ikRyTtqDT7T8DnJf0T8L+A+yPCM3szszpJ5BO+EfE05TdyJx/7yqTtF4EPJdGXmZnVzp/wNTNLIYe/mVkKOfzNzFLI4W9mlkIOfzOzFHL4m5mlkMPfzCyFHP5mZink8DczSyGHv5lZCjn8zcxSyOFvZpZCDn8zsxRy+JuZpZDD38wshRz+ZmYp5PA3M0shh7+ZWQo5/M3MUsjhb2aWQg5/M7MUSiT8JfVLyks6IWn3Vdp8WtKLko5J+k4S/ZqZ2dwsqfUFJLUCjwLbgNPAEUn7IuLFSW02Af8F+FBEvCHp5lr7NTOzuUti5n8HcCIiTkbECPAEcPe0Np8HHo2INwAi4rUE+jUzszlKIvzXAqcm7Z+uHJvsFuAWSf8g6bCk/gT6NTOzOap52QdQlWNRpZ9NwEeBdcDfS9oSEZemvJC0C9gF0Nvbm0BpZmZWTRIz/9PA+kn764DBKm2eiojRiHgZyFP+ZTBFROyJiFxE5FauXJlAaWZmVk0S4X8E2CRpo6R24D5g37Q2PwA+BiBpBeVloJMJ9G1mZnNQc/hHxBXgYeAZ4DjwZEQck/SIpB2VZs8Ar0t6EXgW+FJEvF5r32ZmNjeKmL483xhyuVwMDAzUuwwzs6Yi6fmIyM3Uzp/wNTNLIYe/mVkKOfzNzFLI4W9mlkIOfzOzFHL4m5mlkMPfzCyFHP5mZink8DczSyGHv5lZCjn8zcxSyOFvZpZCDn8zsxRy+JuZpZDD38wshRz+ZmYp5PA3M0shh7+ZWQo5/M3MUsjhb2aWQomEv6R+SXlJJyTtvka7eySFpBlvLmxmZvOn5vCX1Ao8CnwcuA34jKTbqrRbBvw+8LNa+zQzs9okMfO/AzgREScjYgR4Ari7SruvAl8HhhPo08zMapBE+K8FTk3aP105NkHS+4D1EfHXCfRnZmY1WpLAa6jKsZh4UmoB/hS4f8YXknYBuwB6e3sTKM1s/h0/O8T+o+c5c6nE2u5O+resYvOarnqXZXZNScz8TwPrJ+2vAwYn7S8DtgA/lvQvwL8B9lV70zci9kRELiJyK1euTKA0s/l1/OwQe557maHSKGu6OhgqjbLnuZc5fnZodi9w7ig8+4fwg4fKj+eOzm/BZhVJhP8RYJOkjZLagfuAfW8/GRFDEbEiIjZExAbgMLAjIgYS6NusrvYfPU9XZxtdnW20SBPb+4+en/mbzx2Fn3wDSpcgu7b8+JNv+BeALYiawz8irgAPA88Ax4EnI+KYpEck7aj19c0a2ZlLJZZ1TF09XdaxhDOXSjN/8/EfQkc3dHaDWsqPHd3l42bzLIk1fyLiaeDpace+cpW2H02iT7NGsLa7k6HSKF2dbRPH3hy+wtruzpm/eehUecY/WUe2fNxsniUS/mZp1b9lFXueexkoz/jfHL7CUGmUez+wbuZv7lpfXurp7P7XY8OF8nFLjXqdMODLO5jVYPOaLnbduZGuzjbODg3T1dnGrjs3zu4f7+ZPwvCl8i+AGC8/Dl8qH7dUqPmEgRp45m9Wo81ruuY2U1u9BT74hfIa/9Cp8oz/t3+vfNxSYfIJA8DE4/6j5+d99u/wN6un1Vsc9il25lKJNV0dU47N+oSBGnnZx8ysTtZ2d/Lm8JUpx2Z9wkCNHP5mZnXSv2UVQ6VRhkqjjEdMbPdvWTXvfTv8zczqpKYTBmrkNX8zszqa8wkDNfLM38wshRz+ZmYp5GUfM0tM/mKeQ68eYrA4SE+mh629W+lb3lfvsqwKz/zNLBH5i3n2HttL4XKB1TespnC5wN5je8lfzNe7NKvC4W9miTj06iGy7VmyS7O0qIXs0izZ9iyHXj1U79KsCoe/mSVisDhIpj0z5VimPcNgcfAq32H15PA3s0T0ZHoojhSnHCuOFOnJ9NSpIrsWh7+ZJWJr71YKIwUKlwuMxziFywUKIwW29m6td2lWhcPfzBLRt7yPnbfvJLs0y7m3zpFdmmXn7Tt9tk+D8qmeZpaYvuV9Dvsm4Zm/mVkKOfzNzFLI4W9mlkKJhL+kfkl5SSck7a7y/BclvSjpBUmHJL07iX7NzGxuag5/Sa3Ao8DHgduAz0i6bVqznwO5iPgt4PvA12vt18zM5i6Jmf8dwImIOBkRI8ATwN2TG0TEsxHx68ruYWBdAv2amdkcJRH+a4FTk/ZPV45dzeeAv0mgXzMzm6MkzvNXlWNRtaH0WSAHfOQqz+8CdgH09vYmUJqZmVWTxMz/NLB+0v464B1XcpJ0F/BlYEdEXK72QhGxJyJyEZFbuXJlAqWZmVk1SYT/EWCTpI2S2oH7gH2TG0h6H/BnlIP/tQT6NDOzGtS87BMRVyQ9DDwDtAKPRcQxSY8AAxGxD/hjIAN8TxLAqxGxo9a+zXznKLO5UUTV5fm6y+VyMTAwUO8yrIG9feeobHuWTHuG4kiRwkjBFxOzVJP0fETkZmrnT/ha0/Kdo8zmzuFvTct3jjKbO4e/NS3fOcps7hz+1rR85yizuXP4W9PynaPM5s538rKm5jtHmc2NZ/5mZink8DczSyGHv5lZCnnN31KplM9TPHCQ0cFB2np6yGzfRmef3zuw9PDM31KnlM9z8bHHGSsUWLJ6NWOFAhcfe5xSPl/v0swWjMPfUqd44CCt2Syt2SxqaZnYLh44WO/SzBaMw99SZ3RwkJbM1MtCtGQyjA76shCWHg5/S522nh7Gi1MvCzFeLNLW48tCWHo4/C11Mtu3MVYoMFYoEOPjE9uZ7dvqXZrZgnH4W+p09vWx/MEHaM1muXLuHK3ZLMsffMBn+1iq+FRPS6XOvj6HvaWaw98ahs+9N1s4Dn9rCG+fe9+azU459/7t5ZjjZ4fYf/Q8Zy6VWNvdSf+WVWxe01Xvss2alsPfGsK//O8fcu7C63Se/b8s49eMLHsXF2jljW/t5v/t+DCnTv0m6zK/wZquDoZKo+x57mV23bnRvwDM5iiRN3wl9UvKSzohaXeV55dK+m7l+Z9J2pBEv7Y47M8/zy/+8WleGRvgldbXOdkyzj++dZ7C8CArXh/m2LnznNV+rrSeoUWiq7ONrs429h89X+/SzZpWzTN/Sa3Ao8A24DRwRNK+iHhxUrPPAW9ExG9Kug/4I+DeWvu25vfCrbeyHrG+sj9GidduFB3rO2ldsoTLN5YYGVnKu9rhleHD3NS+AYBlHUs4c6lUt7rNml0SM/87gBMRcTIiRoAngLuntbkb2FvZ/j6wVZIS6Nua2Au33korQjDx1Yq4+Q14z0slll0scmHjFZZ1tMFYB2+N/Wrie98cvsLa7s56lW7W9JII/7XAqUn7pyvHqraJiCvAEHBTAn1bkzp59PBE8E9W/gUA7Vdg9AZ4q6vErctKFEeLtMZyxiMYKo0yVBqlf8uqOlRutjgk8YZvtRl8zKENknYBuwB6e3trr8waztuncxb+7inartFurAVAjHfeROubed6zaiM3jn6Qs0PDrO3u5N4PrPObvWY1SCL8T8PEki3AOmD6FbLebnNa0hKgC7g4/YUiYg+wByCXy73jl4M1t8mnc9I+cu3GrePEyuWcW9pBz+gwv5/7vO/Va5agJML/CLBJ0kbgDHAf8O+ntdkH7AR+CtwD/G1EONxTZvKllKOjizHOv2PpJ4AxgqVdHXzsQx/kEze0QGc3OPjNElXzmn9lDf9h4BngOPBkRByT9IikHZVmfw7cJOkE8EXgHaeD2uI3+VLKN6y9jUu55YwRBEx8jRG89Rtt3PLAXXTe1ALDl2DzJ+tZttmilMiHvCLiaeDpace+Mml7GPh3SfRlzautp4exQoHWbJYbb14H3Mn58SOcaSvw7EeW07vu/dyz4UP81pkXYOgUdK6H3/49WL2l3qWbLTr+hK8tmMz2bVx87HGgfPOUbEeWG9Z/gNyDD3Df5Gv43PJv61ShWXr4ks62YHwpZbPG4Zm/LShfStmsMXjmb2aWQg5/M7MUcvibmaWQ1/ztuuUv5jn06iEGi4P0ZHrY2rvVn741azKe+dt1yV/Ms/fYXgqXC6y+YTWFywX2HttL/mK+3qWZ2XVw+Nt1OfTqIbLtWbJLs7SohezSLNn2LIdePVTv0szsOjj87boMFgfJtGemHMu0ZxgsTr+Wn5k1Mq/5G5w7Csd/WL6kQtf68rV0rnJJhZ5MD4XLBbJLsxPHiiNFejI9C1WtmSXAM/+0O3cUfvINKF2C7Nry40++UT5exdberRRGChQuFxiPcQqXCxRGCmzt3brAhZtZLRz+aXf8h9DRXb5ssiqXT+7oLh+vom95Hztv30l2aZZzb50juzTLztt3+mwfsybjZZ+0GzpVnvFP1pEtH7+KvuV9DnuzJueZf9p1rYfhwtRjw4XycTNbtBz+abf5k+UbppQuQYyXH30DFbNFz+Gfdqu3wAe/UF7rL5wpP37wC76Bitki5zV/Kwe9w94sVTzzNzNLIc/8F7HjZ4fYf/Q8Zy6VWNvdSf+WVWxe01XvssysAXjmv0gdPzvEnudeZqg0ypquDoZKo+x57mWOnx2qd2lm1gBqCn9JyyUdlPRS5fHGKm3eK+mnko5JekHSvbX0abOz/+h5ujrb6Opso0Wa2N5/9Hy9SzOzBlDrzH83cCgiNgGHKvvT/Rr4DxFxO9AP/DdJ3TX2azM4c6nEso6pq3rLOpZw5lKpThWZWSOpNfzvBvZWtvcCn5reICL+OSJeqmwPAq8BK2vs12awtruTN4evTDn25vAV1nZ31qkiM2sktYb/qog4C1B5vPlajSXdAbQDv6yxX5tB/5ZVDJVGGSqNMh4xsd2/ZVW9SzOzBjDj2T6SfgSsrvLUl6+nI0lrgG8DOyNi/CptdgG7AHp7e6/n5W2azWu62HXnxiln+9z7gXU+28fMAFBEzP2bpTzw0Yg4Wwn3H0fEO674JSkL/Bj4w4j43mxeO5fLxcDAwJxrMzNLI0nPR0Rupna1LvvsA3ZWtncCT1UppB34K+AvZxv8ZmY2v2oN/68B2yS9BGyr7CMpJ+lblTafBu4E7pf0i8rXe2vs18zMalDTss988rKPmdn1W6hlHzMza0IOfzOzFHL4m5mlkMPfzCyFHP5mZink8DczSyGHv5lZCjn8zcxSyOFvZpZCDn8zsxRy+JuZpZDD38wshRz+ZmYp5PA3M0shh7+ZWQo5/M3MUsjhb2aWQg5/M7MUcvibmaWQw9/MLIUc/mZmKVRT+EtaLumgpJcqjzdeo21W0hlJ36ylTzMzq12tM//dwKGI2AQcquxfzVeBv6uxPzMzS0Ct4X83sLeyvRf4VLVGkt4PrAIO1NifmZkloNbwXxURZwEqjzdPbyCpBfgT4EszvZikXZIGJA1cuHChxtLMzOxqlszUQNKPgNVVnvryLPt4CHg6Ik5JumbDiNgD7AHI5XIxy9c3M7PrNGP4R8RdV3tO0nlJayLirKQ1wGtVmv0O8GFJDwEZoF1SMSKu9f6AmZnNoxnDfwb7gJ3A1yqPT01vEBG/+/a2pPuBnIPfzKy+al3z/xqwTdJLwLbKPpJykr5Va3FmZjY/FNGYS+u5XC4GBgbqXYaZWVOR9HxE5GZq50/4mpmlkMPfzCyFHP5mZink8DczSyGHv5lZCjn8zcxSqNYPeTWsUj5P8cBBRgcHaevpIbN9G519ffUuy8ysISzKmX8pn+fiY48zViiwZPVqxgoFLj72OKV8vt6lmZk1hEUZ/sUDB2nNZmnNZlFLy8R28cDBepdmZtYQFmX4jw4O0pLJTDnWkskwOjhYp4rMzBrLogz/tp4exovFKcfGi0XaenrqVJGZWWNZlOGf2b6NsUKBsUKBGB+f2M5s31bv0szMGsKiDP/Ovj6WP/gArdksV86dozWbZfmDD/hsHzOzikV7qmdnX5/D3szsKhblzN/MzK7N4W9mlkIOfzOzFHL4m5mlkMPfzCyFHP5mZinUsDdwl3QBeKWyuwL4VR3LqQePOR085nRYyDG/OyJWztSoYcN/MkkDs7kb/WLiMaeDx5wOjThmL/uYmaWQw9/MLIWaJfz31LuAOvCY08FjToeGG3NTrPmbmVmymmXmb2ZmCWrI8Je0XNJBSS9VHm+8RtuspDOSvrmQNSZtNmOW9F5JP5V0TNILku6tR621ktQvKS/phKTdVZ5fKum7led/JmnDwleZrFmM+YuSXqz8XA9Jenc96kzSTGOe1O4eSSGpoc6GmYvZjFnSpys/62OSvrPQNU6IiIb7Ar4O7K5s7wb+6Bpt/zvwHeCb9a57vscM3AJsqmz3AGeB7nrXfp3jbAV+CbwHaAf+CbhtWpuHgP9Z2b4P+G69616AMX8MeFdl+z+mYcyVdsuA54DDQK7edS/Az3kT8HPgxsr+zfWqtyFn/sDdwN7K9l7gU9UaSXo/sAo4sEB1zacZxxwR/xwRL1W2B4HXgBk/zNFg7gBORMTJiBgBnqA89skm/1l8H9gqSQtYY9JmHHNEPBsRv67sHgbWLXCNSZvNzxngq5QnPsMLWdw8mc2YPw88GhFvAETEawtc44RGDf9VEXEWoPJ48/QGklqAPwG+tMC1zZcZxzyZpDsozy5+uQC1JWktcGrS/unKsaptIuIKMATctCDVzY/ZjHmyzwF/M68Vzb8ZxyzpfcD6iPjrhSxsHs3m53wLcIukf5B0WFL/glU3Td3u5CXpR8DqKk99eZYv8RDwdEScapZJYQJjfvt11gDfBnZGxHgStS2gaj+s6aeczaZNM5n1eCR9FsgBH5nXiubfNcdcmbz9KXD/QhW0AGbzc15Ceenno5T/d/f3krZExKV5ru0d6hb+EXHX1Z6TdF7Smog4Wwm6av81+h3gw5IeAjJAu6RiRFz1jaV6S2DMSMoC/wf4g4g4PE+lzqfTwPpJ++uAwau0OS1pCdAFXFyY8ubFbMaMpLsoTwQ+EhGXF6i2+TLTmJcBW4AfVyZvq4F9knZExMCCVZms2f7dPhwRo8DLkvKUfxkcWZgS/1WjLvvsA3ZWtncCT01vEBG/GxG9EbEB+M/AXzZy8M/CjGOW1A78FeWxfm8Ba0vSEWCTpI2V8dxHeeyTTf6zuAf426i8O9akZhxzZQnkz4Ad9VwHTtA1xxwRQxGxIiI2VP4NH6Y89mYNfpjd3+0fUH5zH0krKC8DnVzQKisaNfy/BmyT9BKwrbKPpJykb9W1svkzmzF/GrgTuF/SLypf761PuXNTWcN/GHgGOA48GRHHJD0iaUel2Z8DN0k6AXyR8tlPTWuWY/5jyv+D/V7l5zo9NJrKLMe8qMxyzM8Ar0t6EXgW+FJEvF6Pev0JXzOzFGrUmb+Zmc0jh7+ZWQo5/M3MUsjhb2aWQg5/M7MUcvibmaWQw9/MLIUc/mZmKfT/AVsXbIPCLEjkAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "for _ in range(4):\n", + " x = []\n", + " x.append(np.random.uniform(size=(1, DIM)))\n", + " for _ in range(100):\n", + " new_x = model.predict(x[-1])\n", + " x.append(new_x)\n", + "\n", + " plt.scatter([e[0][0] for e in x], [e[0][1] for e in x], alpha=.5)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "WgSISiDwhYH3" + }, + "source": [ + "## Untrained Network with Random Weights\n", + "\n", + "It's tempting to credit the learning process for this effect, but not training at all yields similar results." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "colab": { + "autoexec": { + "startup": false, + "wait_interval": 0 + }, + "base_uri": "https://localhost:8080/", + "height": 347, + "output_extras": [ + { + "item_id": 1 + } + ] + }, + "colab_type": "code", + "executionInfo": { + "elapsed": 1382, + "status": "ok", + "timestamp": 1522832200496, + "user": { + "displayName": "Lenz Belzner", + "photoUrl": "https://lh3.googleusercontent.com/a/default-user=s128", + "userId": "102800868167498000139" + }, + "user_tz": -120 + }, + "id": "m8qfSihbgE6f", + "outputId": "50b40d91-0780-4ce3-90f3-5b7ade328cf9" + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYYAAAD8CAYAAABzTgP2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4xLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvDW2N/gAAIABJREFUeJzt3Xtw3Odd7/H3d3Vde/WTLFu2tLYVO4mzce0Up1XT0kJLq9r4HE6TZhpIymmPmhQ80FOYAwNDe2DgTLkFGE5hoD1gSoLoAL1BW5fS1I6aNECbNErrNHZcJamd+LKS7ViWfl57tbrsc/7YlbI/RbfV3nT5vGZ29rfPPr/dr2R5v/tcfs9jzjlEREQmhSodgIiILC1KDCIiEqDEICIiAUoMIiISoMQgIiIBSgwiIhKgxCAiIgFKDCIiEqDEICIiAdWVDmAxNmzY4LZt21bpMERElpWnnnrqZedcy3z1lmVi2LZtG729vZUOQ0RkWTGzlxZST11JIiISoMQgIiIBSgwiIhKgxCAiIgFKDCIiEqDEICIiAUoMIiISsCyvYxCRla1vsI+e0z3EE3GikSid7Z3EmmOVDmvVUItBRJaUvsE+uo9346d8Wte24qd8uo930zfYV+nQVg0lBhFZUnpO9+DVenh1HiEL4dV5eLUePad7Kh3aqqHEICJLSjwRJ1IbCZRFaiPEE/EKRbT6KDGIyJISjURJjCYCZYnRBNFItEIRrT5KDCKypHS2d+KP+vgpn7RL46d8/FGfzvbOSoe2aigxiMiSEmuO0bWrC6/OY+DqAF6dR9euLs1KKqOiTFc1s/3AnwNVwKecc/dPe/7jwNuzD9cAG51zTdnnJoBnss+dds7dXoyYRGT5ijXHlAgqqODEYGZVwCeAvcBZ4EkzO+Sce3ayjnPuV3Lq/xJwa85LJJ1zewqNQ0REiqMYXUm3AS84504650aBzwB3zFH/vcA/FeF9RUSkBIqRGDYDZ3Ien82WvYqZXQdsB76RU1xvZr1m9riZvbsI8YiISAGKMcZgM5S5WereA3zBOTeRU9bunIub2fXAN8zsGefcD1/1JmYHgAMA7e3thcYsIiKzKEaL4SywNefxFmC2K1HuYVo3knMunr0/CTxKcPwht95B51yHc66jpWXevaxFRGSRipEYngR2mNl2M6sl8+F/aHolM4sB64Bv55StM7O67PEG4C3As9PPFRGR8im4K8k5N25mHwa+Tma66gPOueNm9jGg1zk3mSTeC3zGOZfbzbQT+GszS5NJUvfnzmYSEZHys+Dn9PLQ0dHhent7Kx2GiMiyYmZPOec65qunK59FRCRAiUFERAKUGEREJECJQUREApQYREQkQIlBREQClBhERCRAiUFERAKUGEREJECJQUREApQYREQkQIlBREQClBhERCRAiUFERAKUGEREJECJQUREAgrewU1EZD7Jvj4Sh48wFo9TE40S2beXcCxW6bBkFkoMIivcif5hHjp2nnNDSTY3hdm/exM72xrL9v7Jvj4GH3iQKs+jurWVCd9n8IEHab7vXiWHJUpdSSIr2In+YQ4+dorh5BhtjfUMJ8c4+NgpTvQPly2GxOEjVHkeVZ6HhUJTx4nDR8oWg+RHiUFkBXvo2HkawzU0hmsImU0dP3TsfNliGIvHCUUigbJQJMJYPF62GCQ/6koSWcHODSVpa6wPlDXUV3NuKFm2GGqiUSZ8nyrPmypLJxLURKNli2E56xvso+d0D/FEnGgkSmd7J7Hm0nbBFaXFYGb7zazPzF4ws4/M8PwHzOyimR3N3n4u57kuM3s+e+sqRjwikrG5KcyVkfFA2ZWRcTY3hcsWQ2TfXiZ8nwnfx6XTU8eRfXvLFsNy1TfYR/fxbvyUT+vaVvyUT/fxbvoG+0r6vgUnBjOrAj4B/BfgNcB7zew1M1T9rHNuT/b2qey5zcDvAG8EbgN+x8zWFRqTiGTs372J4eQYw8kx0s5NHe/fvalsMYRjMZrvu5cqz2N8YIAqz9PA8wL1nO7Bq/Xw6jxCFsKr8/BqPXpO95T0fYvRlXQb8IJz7iSAmX0GuAN4dgHn/iRwxDk3mD33CLAf+KcixCWy6u1sa+TAW7cHZiXd/YYtZZ2VBJnkoESQv3giTuva1kBZpDZCPFHa8ZliJIbNwJmcx2fJtACme4+ZvRV4DvgV59yZWc7dPNObmNkB4ABAe3t7EcIWWR12tjWWPRFIcUQjUfyUj1f3yvhMYjRBNFLa8ZlijDHYDGVu2uOvANucc68FHga68zg3U+jcQedch3Ouo6WlZdHBiogsF53tnfijPn7KJ+3S+Ckff9Sns72zpO9bjMRwFtia83gLEGjnOOcuOedS2Yd/A7x+oeeKiKxWseYYXbu68Oo8Bq4O4NV5dO3qKvmspGJ0JT0J7DCz7cA54B7gZ3MrmFmbc64/+/B24ET2+OvAH+QMOO8DPlqEmEREVoRYc6zkiWC6ghODc27czD5M5kO+CnjAOXfczD4G9DrnDgG/bGa3A+PAIPCB7LmDZva7ZJILwMcmB6JFRKQyzLkZu/SXtI6ODtfb21vpMERkGav0GlKVYGZPOec65qunJTFEZNVZCmtILWVKDCKy6iyFNaSWMiUGEVl1zg0laagPDrGWew2ppUyJQURWnaWwhtRSpsQgIqvOUlhDailTYhCRVWdyDanGcA39wyM0hms48NbtK35W0kJpPwYRWZW0htTs1GIQEZEAJQYREQlQYhARkQAlBhERCVBiEBGRAM1KEpFF6xvso+d0D/FEnGgkSmd7Z9mXiJbiU4tBRBalb7CP7uPd+Cmf1rWt+Cmf7uPd9A32VTo0KZASg4gsSs/pHrxaD6/OI2QhvDoPr9aj53RPpUOTAikxiMiixBNxIrWRQFmkNkI8od15lzslBhFZlGgkSmI0EShLjCaIRqIVikiKRYlBRBals70Tf9THT/mkXRo/5eOP+nS2d1Y6NCmQEoOILEqsOUbXri68Oo+BqwN4dR5du7o0K2kF0HRVEVm0WHNMiWAFUmIQkWUv2ddH4vARxuJxaqJRIvv2Eo4pYS1WUbqSzGy/mfWZ2Qtm9pEZnv9VM3vWzL5vZj1mdl3OcxNmdjR7O1SMeERk9Uj29TH4wINM+D7Vra1M+D6DDzxIsk/XUyxWwS0GM6sCPgHsBc4CT5rZIefcsznVvgd0OOeumdkvAn8M3J19Lumc21NoHCLltpyu+j3RP8xDx85zbijJ5qYw+3dvWjF7ESQOH6HK86jyPICp+8ThI2o1LFIxWgy3AS84504650aBzwB35FZwzj3inLuWffg4sKUI7ytSMcvpqt8T/cMcfOwUw8kx2hrrGU6OcfCxU5zoHy5PAAPH4JE/hC99KHM/cKyoLz8WjxOKBK+nCEUijMV1PcViFSMxbAbO5Dw+my2bzQeBr+U8rjezXjN73MzePdtJZnYgW6/34sWLhUUsUqDldNXvQ8fO0xiuoTFcQ8hs6vihY+dL/+YDx+BbfwHJIfA2Z+6/9RdFTQ410SjpRPB6inQiQU1U11MsVjESg81Q5masaPY+oAP4k5zidudcB/CzwJ+Z2Q0zneucO+ic63DOdbS0tBQas0hBltNVv+eGkjTUB3uNG+qrOTeULP2bn/gK1DdBuAkslLmvb8qUF0lk314mfJ8J38el01PHkX17i/Yeq00xEsNZYGvO4y3Aq/53mNk7gd8EbnfOpSbLnXPx7P1J4FHg1iLEJFJSy+mq381NYa6MjAfKroyMs7kpXPo3Hz4D9V6wrN7LlBdJOBaj+b57qfI8xgcGqPI8mu+7V+MLBSjGdNUngR1mth04B9xD5tv/FDO7FfhrYL9z7kJO+TrgmnMuZWYbgLeQGZgWWdI62zvpPt4NZFoKidEE/qjPnTvurHBkr7Z/9yYOPnYKyLQUroyMM5wc4+43lGGor3Frpvso3PRK2YifKS+icCymRFBEBbcYnHPjwIeBrwMngM85546b2cfM7PZstT8BIsDnp01L3Qn0mtnTwCPA/dNmM4ksScvpqt+dbY0ceOt2GsM19A+P0Biu4cDmcTZ84dPEP/q/ufgXf1m6qZ073wUjQ5nk4NKZ+5GhTLksWebcjMMBS1pHR4fr7e2tdBgiC7aULsCanPdf5XmEIhHSiQQTvl+67peBY5kxheEzmZbCzndB6+7iv4/My8yeyo7pzklXPouUWO4Hce4FWJXqBy/7vP/W3UoEy4wSg5TcUvq2XAlL7QKssXic6tbWQJnm/Usura4qJaXlCpbeBVia9y/zUWKQksr9tmyh0NRx4vCRSodWNiX9IF7EVcWa9y/zUWKQklpq35YrIZ8P4r7BPj559JP81n/8Fp88+sm5l9hY5FXFmvcv89EYg5RUTTTKhO9P9avD6uu2mPwgzh1nabzrPa/6IJ5cf8mr9QLrL806DTb3qmJ45f7EV+Yd7NW8f5mLEoOUVGTfXgYfeBAgMDWy8a73VDiy2ZViJdKFfBDnrr8ETN33nO6ZOTEMn8m0FHIV+apiWZ3UlSQltdy6LSq5Emne6y81bs1cRZyrBFcVy+qjFoOU3HLqtshdiRSYun/o2PnZWw1FuoArGonip/yplgLMs/7SzndlxhQg01IY8TNXFb/u/Xm/t0gutRhEcuS9EmkRl5XubO/EH/XxUz5pl8ZP+fijPp3tnTOf0Lob3vxLmbEF/1zm/s2/pIvJpGBqMYjk2NwUZjg5NtVSgHlWIs1zAHim8Ytt/gCJw0doiMd5/7pavhNL8fz6TEvhzh13zr3+kq4qlhJQYhDJkfdKpHkMAE+OXzSGa6bGLz7/uUf56R9+k3WbNlDd2sq6RIJ3fsvnZxYwDrOcthaV5UWJQSTH5Eqkud/q737DltnHF/JYVnqm8Ystzz/Fi2NVbJhluYzZZkjlPbWVlb3vsxSXEoPINDvbGhf+gZnHAPC5oSS3VJ3hptOP0pDq50pdG2OD5znjtQfqTV4AOFML4+Bjpzjw1u08cj6/qa1zvZaSg0ynxCBSiMkB4NxZSa97/4z9/q+tPstrz3yadF0jV2o3UTfuM1F1Ert2gW+cXktDbQPbG7ezbqyWmmh0zhlSl8JxWtcGF8Kba2rromZbyaqlxCBSqAUOAO+v/g4n3FqcW0stxgnSfP9meNvTl6kaa+JaaIQTLz3Jzpp2tt31vzj3/SRtjfWB15icIXV9S35TW88Nzf5akzRmIZM0XVWkiOZa62jjxEXaNrZwMZGi7/wVvjXRD1vXcfG2WibGzuO9dBJzPs9cN0Li8BF+8l//hvZD/0Dk3Kmp15icIZXv1Nb59n2eHLPwU35gzGLOtZpkxVKLQaRIcgeEb3i5mqZ/fYznLnyZ9M0/yrY73suVqhYuPPsDtp2+Sk0iRbrRZ3BbiKFNI1z9iW1Q3Ur4zBAb//1pJnY0s+Wmdi4/18/mw1/k7N47ia/fMjVDKtbcSNeursA3/Lmmts432yrv5ThkRVNiEFmAhWw2NPnh2jaQYutXn2Z8bR2X1tXR+/yjnPy9b3Ju4yhv/MEgkbpakmvX05x0tH53mOffsA42Zrp5mn5wlZo1dVSlzrKhbTu33LyZF188z9rv/DvX7/tR9q/5DhufuAiNW4ntfBexPR9aUPzzzbaKJ/Ibs5CVTYlBVq2F9qkvZGvOE/3DPPzcDwgnJ7jusae5NpLiqu8ID44STjkiVcaaF9Mc31JPLJSmZbSfjfUbOe1SND4/ztWdjoQbY+vlFFtbNk2tgbQhUs/612xl/NQJou4QVDXB2pwrrPO40nmu2VZ5L8chJVXpXQ81xiCrUj596vNtNjQ1FTQF0dQxai5f5cJIkqZzVwlfHSOcHKfm8hjrL00wkUjxzVrjcO0ajpHkWl0djVfGGEgn8UK13LixjXXXJjJTX7PSiQQ1VYOvXGFtocx9fVNmNlQR5L0ch5TMUtj1sCgtBjPbD/w5UAV8yjl3/7Tn64C/B14PXALuds69mH3uo8AHgQngl51zXy9GTCJzyadPfWqP5MQFeLkPRnxCdQ2MXVwPwD989wnO8i2uO/sELc9d4aZnHVU5509kbwbcctLxXVJc2lBD80SakZEGEk0J3l8TJdawheQtZxjsOQEbdxJKp19ZpvzG2kCySJ4dJPG9lxg7f5GaYw0Ff6OMNcfyGrOQ0lkKe4QXnBjMrAr4BLAXOAs8aWaHnHPP5lT7IHDZOXejmd0D/BFwt5m9BrgH2AVEgYfN7Cbn3EShcYnMJZ8+9ZpolIn+U1QNHYPqeqhrIO0nqKn16Xvuq/zHy19m69l+3vTvPje9mPl2ZDnnV5MpGwlBdRp2nYFjdeNM1BiNLszRXVtJpIeI+Ub4huto3vkuEt89FdzUJ/4vU1dYJ88OMvjws1TVOKo3tczYtbUYseaYEsESMPVFJEe5dz0sRovhNuAF59xJADP7DHAHkJsY7gD+T/b4C8Bfmpllyz/jnEsBp8zshezrfbsIcYnMKrdP/eKVEV64cJXB5BDN4UZO9A8H+uIj+/Yy+Ae/CjVVTIymGT0bZyKRYs2O9Tzytf8HdfW87egLbO5/dVLIVQ0kwlCThu0Djsd31HJ8xw28vL6J+pYQ/NjvARAGwm+ZdnLjK1dYJ773ElU1jqraCWi5mapI+b9RSukshV0PizHGsBnIXTHsbLZsxjrOuXFgGFi/wHMBMLMDZtZrZr0XL14sQtiymk32qb84eJHeFy9zZdSnpjbFeut41cY84ViM5jc1k6aK5A8GcED4hkZCo4Ns/9oPua/nOLf+ABpSsycFgJCDa2G4sB7ObqriSz++lVPNDQyPXKHGNc8dcM4S22PnLxLyIrD1jRDZmHntVbaP9kqWzx7hpVKMxDDT/wW3wDoLOTdT6NxB51yHc66jpaUlzxBFgib71PsvG676Mg21DexeezvXNdxIY7iGh46dD9QP3/waataEiNyyhdQNa3g6dJ4nxq4SHoL1F8Fm/KsNGquCOhyX18IFzwhNbCJt14iERxnzFzCzqHU3vP2j1LzpPaTX75lKCrD69tFeyZbCrofF6Eo6C+QuJbkFmP7VZbLOWTOrBhqBwQWeK1ISseYYm9J3sGd9PSF75TvKWOgs37zwn1z6jzTRSJTrw2/kwtBr+ZEXv4K/rpYzVYOEgZZLjrFaCKVhIjR3awHgStgx1Gw0GRy7bg3VoTSbIs3c3PBmRq5tWnDcy3EfbclPpXc9LEaL4Ulgh5ltN7NaMoPJh6bVOQR0ZY/vAr7hnHPZ8nvMrM7MtgM7gO8UISaRBZm+VMSl0Rc5euXL1NamaF3byouDF/nT7/wN33XGhS0dnB8doXpsjGqqCI2GqHOQqoVUdWbm0UwNBwckcWww4zVV9YRu3U54c4SNDXWsqa3i6ujE7BsBzWApfKOUla3gFoNzbtzMPgx8nczY2wPOueNm9jGg1zl3CPhb4NPZweVBMsmDbL3PkRmoHgf+p2YkSTlNXyqiL/Et0uNhdm3ZRMhC9F8Osba6gUuulxdv+ynWfO0ZascdqdA4zlJUj0KiFRoSMDIOtaOZ/1S5rYf+dWlqbtzElsh6+kOj/Ev0KvUWJhxaz5XRKwyMH2L/rp/PK+5Kf6OUla0o1zE45/4N+LdpZb+dczwC/PQs5/4+8PvFiEMkX9OXipiwQd54XTstDZklKq6MjLG2LsLViZcBSNeuZcPpK9RPXOOqB6F0iOpQGn8tVDugCi7XQ3gEUuEQ19bW0dYSYV3EI1RfzeBAP+11a4nXxriamqCh3uOmTRFOJp8gc5mPSOVpSQxZ9XKXivjk0ZvxU/7Ucw31NVwZ9bn+UhXbn/gyft1mvnvjKFuujNKQSnPqugkiQ9WE642x1ASn2+Byawux55LUpSa41NrKDdt2s+baKSYuX+LlpirWX/9jtDS8MqaQdmmtSSRLihKDSI7O9k66j3cDmQve2talGTh3hT3P1jEaXsNVq2PsSpqxNQmGq1N4fh0Xb7mekbpqXrr6PD/yIuxy6xiJNWIvD/P6bTfTtCHKRMJjotpn5M1hErV1eDnvuRTXJNI2oKubEoNUXKUXDANg4Bic+Aqx4TN01UfosRHiYwm2NUd5x+b/RtXDD3IhHOHKyDjRyEZaa8JEJ57Ghsaod6dpuDbMpXX19Lz+jTyzxiMaifL20RvY8MTzgSuY39RCIPEkRhP4oz537rizvD/vHLQNqFhmctDy0tHR4Xp7eysdhhRB7sqluVMvyzrLZuBY5qri+qbAvs19u2+n59pLxBNx3vy1M2wPtfDdl+tpqKvGzFj/8gmio8eJvC7EEB43Xn8TVFXPu+LpUt8p7eNHnmM4OTa1/Scw9fhX9t5UwcikUGb2lHOuY756ajFIReW9YFj2m/3U/so737WgZafnbJWc+MorK5cChJvoG/Ppfvqv8NrfQuvaVk7tGSX91aOEq7eTCm0kMj7Cmqsvc/l1t/Bi4ybqaqq4ccP6zHpGJ74yZ0yLXpNokT97vhayDaisbFp2WypqLB4nFIkEymZd3mHym31yCLycPQkGjs35HvMuYzx8JrByKUBP+jLe+ChenUfIQtiObbz0U3uYWJeg+tJFEjVhql7bwPD6FkbG09y4cW3mxHov83rFtsiffTHm2wZUVj4lBqmommiUdCIRKJt1eYfcb/Z57Ekw334KNG6d2hhnUjw1TKRuXaDM3djO03ds5+aP/xFn73gf8ZZ2vFCS11/XREsk8w370uBFvn1pDb/2+af5+JHnAmsuFWSRP/ti7N+9ieHkGMPJMdLOTR3v373wq7NleVNikIrKa8GwGb7ZL+Qb+rytkp3vgpGhzLdwl4bkEFEHiXVbA+dMzh7a2dbIr+y9iZ98z8/zuhajpWoEXJpLl87zw9Pn+N7aHw8M2hYlOSzyZ1+MyWs7GsM19A+P0Biu0cDzKqMxBqmoyeUdcvv/G+96z8zjC41bp/YkmDLiZ8rnMO8yxpMrl+b033fe+GG6z/8npPzZZw9NO++54TV8L/o+Uut3EoKpwduHjp0v/EN1kT/7Ys21DaisfEoMUnELXt5h5yt7EuTOHuJ175/ztJdvfRPn/voBLlfVUd/kceMa8CZSwUXnWncHBnJjQNeGG+k53cO1E8/y2mNX2J6M0Hz0CMl9vBJvznn//PmnaWusDzTDizZou8ifXWQx1JUky0fOngT45zL380wNPdE/zMFz1Tzzlp+itqmR0MsX6R2cwH/XXfMmo1hzjHvDnbz3aITXrYmx/rrYnPvvlnTQdhE/u8hiqcUgy8u0b/bzeejY+UyXTvMOTt6wA8jMyX85WcPOBZyfz3Ta6QvyXRkZZzg5xt1v2LLgeOeU588uslhqMciKdm4oSUN98PtPPt07+Uyn1aCtrBRqMciysZgrhjc3hV91FW8+3Tv57r+rQVtZCdRikGWhb7CP7uPd+Cmf1rWt+Cmf7uPd9A2+uq8/V6Fz8pfC/rsi5abEIMtCz+kevFpv6kpkr87Dq/XoOd0z53mFdu9otzRZjdSVJEVTyqWa44k4rWtbA2WR2siC9jEotHsnHItxuoVXurGSPXQOsqQWvhMpJiWGVarYK3yWeqnmaCSKn/Lx6l7p6y/XPgaT3VherRfoxura1VX05LAkliCXVU9dSavQYvvr5zI5LbQxXEPIbOr4oWPnixJzZ3sn/qiPn/JJuzR+yscf9els7yzK689lsd1Y+Zp3sT+RMlGLYRXK/aADpu57Tvcs+htwqZdqjjXH6NrVFWjl3LnjzrJ05xTSjZWPvJcgL7Klvk+ElI8SwypUig+6QqeFLsSi9zEoULm6scbicapbg/8usy5BXmTl7C6Tpa+griQzazazI2b2fPZ+3Qx19pjZt83suJl938zuznnu78zslJkdzd72FBKPLEw0EiUxGlzqutAPuoov1TxwDB75Q/jShzL3RdynoFzdWHktQV5k5eouk+Wh0DGGjwA9zrkdQE/28XTXgP/hnNsF7Af+zMxylojk151ze7K3owXGIwtQig+6il71W+JNbCa7sbw6j4GrA3h1Xkm+SVfymol4Ik6kNniFdym6y2R5KLQr6Q7gJ7LH3cCjwG/kVnDOPZdzHDezC0ALMFTge8silaq/vmJX/c6wNedUeZHWFipHN1ZeS5AXWSVnfcnSU2hi2OSc6wdwzvWb2ca5KpvZbUAt8MOc4t83s98m2+JwzqVmOfcAcACgvb29wLClUv31JTF8JtNSyFWqLTZLbMFLkBdZZ3sn3ce7AWbff0JWjXm7kszsYTM7NsPtjnzeyMzagE8D9zrn0tnijwI3A28AmpnW2sjlnDvonOtwznW0tLTk89ay0s2wNWcpN7FZicrVXSbLw7wtBufcO2d7zszOm1lbtrXQBlyYpZ4HfBX4Lefc4zmv3Z89TJnZg8Cv5RW9CGgTmyJZUa1IKUihg8+HgK7scRfw5ekVzKwW+CLw9865z097ri17b8C7geJNJZHVQ5vYiBRVoWMM9wOfM7MPAqeBnwYwsw7gF5xzPwf8DPBWYL2ZfSB73geyM5D+wcxaAAOOAr9QYDyyWmkTG5GiMedcpWPIW0dHh+vt7a10GCIiy4qZPeWc65ivntZKEhGRACUGEREJUGIQEZEALaInZaX9BkSWPrUYpGy034DI8qDEIGWTu9+AhUJTx4nDRyodmojkUGKQshmLxwlFgit4lmu/ARFZOI0xSNnURKNM+P7UzmSw8P0GTvQP89Cx85wbSrK5Kcz+3Zsqs5KryCqgFoOUzWL3GzjRP8zBx04xnByjrbGe4eQYBx87xYn+4TJFLrK6KDFI2UzuN1DleYwPDFDleTTfd++8s5IeOnaexnANjeEaQmZTxw8dO1+myEVWF3UlSVktZr+Bc0NJ2hrrA2UN9dWcG0oWMzQRyVKLQZa8zU1hroyMB8qujIyzuSlcoYhEVjYlBlny9u/exHByjOHkGGnnpo73795U6dBEViQlBlnydrY1cuCt22kM19A/PEJjuIYDb92uWUkiJaIxBlkWdrY1KhGIlIlaDCIiEqDEICIiAUoMIiISoMQgIiIBSgwiIhKgxCAiIgEFJQYzazazI2b2fPZ+3Sz1JszsaPZ2KKd8u5k9kT3/s2ZWW0g8IiJSuEJbDB8BepxzO4Ce7OOZJJ1ze7K323PK/wjCWgF6AAAJ/ElEQVT4ePb8y8AHC4xHREQKVGhiuAPozh53A+9e6IlmZsA7gC8s5nwRESmNQhPDJudcP0D2fuMs9erNrNfMHjezyQ//9cCQc25ydbSzwObZ3sjMDmRfo/fixYsFhi0iIrOZd0kMM3sYaJ3hqd/M433anXNxM7se+IaZPQP4M9Rzs72Ac+4gcBCgo6Nj1noiIlKYeRODc+6dsz1nZufNrM05129mbcCFWV4jnr0/aWaPArcC/ww0mVl1ttWwBdDmv0tQ32AfPad7iCfiRCNROts7iTXnt6eCiCwfhXYlHQK6ssddwJenVzCzdWZWlz3eALwFeNY554BHgLvmOl8qq2+wj+7j3fgpn9a1rfgpn+7j3fQN9lU6NBEpkUITw/3AXjN7HtibfYyZdZjZp7J1dgK9ZvY0mURwv3Pu2exzvwH8qpm9QGbM4W8LjEeKrOd0D16th1fnEbIQXp2HV+vRc7qn0qGJSIkUtOy2c+4S0DlDeS/wc9njbwG3zHL+SeC2QmKQ0oon4rSuDQ4xRWojxBPq9RNZqXTls8wpGomSGE0EyhKjCaKRaIUiEpFSU2KQOXW2d+KP+vgpn7RL46d8/FGfzvZXNRRFZIVYdTu4Jfv6SBw+wlg8Tk00SmTfXsIxzbCZTaw5RteursCspDt33KlZSSIr2KpKDMm+PgYfeJAqz6O6tZUJ32fwgQdpvu9eJYc5xJpjSgQiq8iq6kpKHD5CledR5XlYKDR1nDh8pNKhiYgsGasqMYzF44QikUBZKBJhLK4ZNiIik1ZVYqiJRkkngjNs0okENVHNsBERmbSqEkNk314mfJ8J38el01PHkX17Kx2aiMiSsaoSQzgWo/m+e6nyPMYHBqjyPA08i4hMs6pmJUEmOSgRiIjMblW1GEREZH5KDCIiEqDEICIiAUoMIiISoMQgIiIBSgwiIhKgxCAiIgFKDCIiEqDEICIiAUoMIiISoMQgIiIBBSUGM2s2syNm9nz2ft0Mdd5uZkdzbiNm9u7sc39nZqdynttTSDwiIlK4QlsMHwF6nHM7gJ7s4wDn3CPOuT3OuT3AO4BrwOGcKr8++bxz7miB8YiISIEKTQx3AN3Z427g3fPUvwv4mnPuWoHvKyIiJVJoYtjknOsHyN5vnKf+PcA/TSv7fTP7vpl93MzqZjvRzA6YWa+Z9V68eLGwqEVEZFbzJgYze9jMjs1wuyOfNzKzNuAW4Os5xR8FbgbeADQDvzHb+c65g865DudcR0tLSz5vLSIieZh3ox7n3Dtne87MzptZm3OuP/vBf2GOl/oZ4IvOubGc1+7PHqbM7EHg1xYYt4iIlEihO7gdArqA+7P3X56j7nvJtBCm5CQVIzM+cazAeKTCkn19JA4fYSwepyYaJbJvr3bME1lmCh1juB/Ya2bPA3uzjzGzDjP71GQlM9sGbAW+Oe38fzCzZ4BngA3A7xUYj1RQsq+PwQceZML3qW5tZcL3GXzgQZJ9fZUOTUTyUFCLwTl3CeicobwX+Lmcxy8Cm2eo945C3l+WlsThI1R5HlWeBzB1nzh8RK0GkWVEVz5L0YzF44QikUBZKBJhLB6vUEQishhKDFI0NdEo6UQiUJZOJKiJRisUkYgshhKDFE1k314mfJ8J38el01PHkX17Kx2aiORBiUGKJhyL0XzfvVR5HuMDA1R5Hs333avxBZFlptDpqiIB4VhMiUBkmVOLQUREApQYREQkQIlBREQClBhERCRAiUFERAKUGEREJECJQUREApQYREQkwJxzlY4hb2Z2EXip0nHMYwPwcqWDWCDFWhqKtfiWS5ywNGO9zjk37xaYyzIxLAdm1uuc66h0HAuhWEtDsRbfcokTlles06krSUREApQYREQkQImhdA5WOoA8KNbSUKzFt1zihOUVa4DGGEREJEAtBhERCVBiKBIzazazI2b2fPZ+3Sz12s3ssJmdMLNnzWxbeSNdeKzZup6ZnTOzvyxnjDnvP2+sZrbHzL5tZsfN7PtmdneZY9xvZn1m9oKZfWSG5+vM7LPZ55+oxL95No754vzV7N/k982sx8yuq0Sc2VjmjDWn3l1m5sysYrN/FhKrmf1M9nd73Mz+sdwx5s05p1sRbsAfAx/JHn8E+KNZ6j0K7M0eR4A1SzXW7PN/Dvwj8JdL9fcK3ATsyB5HgX6gqUzxVQE/BK4HaoGngddMq/Mh4K+yx/cAn63A73Ehcb598u8R+MVKxLnQWLP1GoDHgMeBjqUaK7AD+B6wLvt4YyVizeemFkPx3AF0Z4+7gXdPr2BmrwGqnXNHAJxzCefctfKFOGXeWAHM7PXAJuBwmeKaybyxOueec849nz2OAxeAeS/iKZLbgBeccyedc6PAZ8jEnCv3Z/gC0GlmVqb4Js0bp3PukZy/x8eBLWWOcdJCfqcAv0vmi8NIOYObZiGx/jzwCefcZQDn3IUyx5g3JYbi2eSc6wfI3m+coc5NwJCZ/YuZfc/M/sTMqsoaZca8sZpZCPhT4NfLHNt0C/m9TjGz28h8c/thGWID2AycyXl8Nls2Yx3n3DgwDKwvS3QzxJA1U5y5Pgh8raQRzW7eWM3sVmCrc+5fyxnYDBbye70JuMnM/tPMHjez/WWLbpG053MezOxhoHWGp35zgS9RDfw4cCtwGvgs8AHgb4sRX64ixPoh4N+cc2dK/eW2CLFOvk4b8GmgyzmXLkZsC3nbGcqmT/VbSJ1SW3AMZvY+oAN4W0kjmt2csWa/tHyczP+dSlvI77WaTHfST5Bphf27me12zg2VOLZFU2LIg3PunbM9Z2bnzazNOdef/YCaqbl4Fviec+5k9pwvAW+iBImhCLH+KPDjZvYhMmMhtWaWcM7NOhBYwVgxMw/4KvBbzrnHix3jHM4CW3MebwHis9Q5a2bVQCMwWJ7wXhXDpJnixMzeSSYhv805lypTbNPNF2sDsBt4NPulpRU4ZGa3O+d6yxZlxkL//R93zo0Bp8ysj0yieLI8IeZPXUnFcwjoyh53AV+eoc6TwDozm+z/fgfwbBlim27eWJ1z/9051+6c2wb8GvD3pUgKCzBvrGZWC3yRTIyfL2NskPk33WFm27Nx3EMm5ly5P8NdwDdcdhSyjOaNM9s989fA7RXuB58zVufcsHNug3NuW/bv83EyMZc7Kcwba9aXyAzsY2YbyHQtnSxrlPmq9Oj3SrmR6TPuAZ7P3jdnyzuAT+XU2wt8H3gG+DugdqnGmlP/A1RuVtK8sQLvA8aAozm3PWWM8b8Cz5EZ1/jNbNnHyHxYAdQDnwdeAL4DXF+h3+V8cT4MnM/5HR6qRJwLiXVa3Uep0KykBf5eDfi/ZL4EPgPcU6lYF3rTlc8iIhKgriQREQlQYhARkQAlBhERCVBiEBGRACUGEREJUGIQEZEAJQYREQlQYhARkYD/DyIec+/gPSUxAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "model = make_model()\n", + "\n", + "for _ in range(4):\n", + " x = []\n", + " x.append(np.random.uniform(size=(1, DIM)))\n", + " for _ in range(100):\n", + " new_x = model.predict(x[-1])\n", + " x.append(new_x)\n", + "\n", + " plt.scatter([e[0][0] for e in x], [e[0][1] for e in x], alpha=.5)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "UM7ttSvmij8u" + }, + "source": [ + "More layers, more parameters, same effect." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "colab": { + "autoexec": { + "startup": false, + "wait_interval": 0 + }, + "base_uri": "https://localhost:8080/", + "height": 371, + "output_extras": [ + { + "item_id": 1 + } + ] + }, + "colab_type": "code", + "executionInfo": { + "elapsed": 1289, + "status": "ok", + "timestamp": 1522832201928, + "user": { + "displayName": "Lenz Belzner", + "photoUrl": "https://lh3.googleusercontent.com/a/default-user=s128", + "userId": "102800868167498000139" + }, + "user_tz": -120 + }, + "id": "SIOil5pugtHJ", + "outputId": "2769b8a6-3ec4-4d43-ea2d-e4f69e0ee210" + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD8CAYAAACMwORRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4xLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvDW2N/gAAGa5JREFUeJzt3X9w3PV95/HnWz/sXSPvKsLCsmQbO4nRyFG4kNORHpmSdIwZkzmba8ulcCnnEBrPXAr9gzZzdNqhHTJ3vSZzk+kR0tSTQtzOJITQu9bkCOC4dLjDcYq4EEa22GDsC5ZlGYHQrhfvWr/e98d37ZFkSfuVtT+0X78eM5rv9/vZj/f7/ozwi48/3+/u19wdERGJlrpqFyAiIqWncBcRiSCFu4hIBCncRUQiSOEuIhJBCncRkQhSuIuIRJDCXUQkghTuIiIR1FCtE69Zs8Y3bdpUrdOLiNSkV1555R13by3Wr2rhvmnTJnp7e6t1ehGRmmRmvwzTT8syIiIRpHAXEYkghbuISAQp3EVEIkjhLiISQQp3EZEIUriLiERQ1e5zX7KhPuh/GtInIbkBunZCW3e1qxIRWRZqc+Y+1AeHHoHcKCQ6gu2hR4J2ERGp0XDvfxpizRBvBqsLtrHmoF1ERGo03NMnIZaY2RZLBO0iIlKj4Z7cAPnMzLZ8JmgXEZEaDfeunZAfDdbafSrY5keDdhERqdFwb+uGm+4P1tozp4LtTffrbhkRkYLavRWyrVthLiIyj9qcuYuIyIKKhruZPWZmb5vZnDeRm9nnzOy1ws8hM/sXpS9TREQWI8zM/TvAjgVePwF8yt2vB74C7C1BXSIisgRF19zd/UUz27TA64emHR4G1i+9LBERWYpSr7nfC/xovhfNbI+Z9ZpZ7/DwcIlPLSIiF5Qs3M3s1wjC/T/N18fd97p7j7v3tLYWfXi3iIhcppLcCmlm1wPfBm5z93dL8Z4iInL5ljxzN7ONwP8A7nb3Xyy9JBERWaqiM3cz+x7waWCNmQ0AfwI0Arj7t4CHgKuBb5oZwIS795SrYBERKS7M3TJ3FXn9d4DfKVlFIiKyZPqEqohIBCncRUQiSOEuIhJBCncRkQhSuIuIRJDCXUQkghTuIiIRpHAXEYkghbuISAQp3EVEIkjhLiISQQp3EZEIUriLiESQwl1EJIIU7iIiEaRwFxGJIIW7iEgEKdxFRCJI4S4iEkEKdxGRCFK4i4hEUNFwN7PHzOxtM+ub53Uzs/9uZsfM7DUz+3jpyxQRkcUIM3P/DrBjgddvA7YUfvYAf7n0skREZCmKhru7vwiMLNDlduBvPHAYaDazdaUqUEREFq8Ua+4dwMlpxwOFNhERqZJShLvN0eZzdjTbY2a9ZtY7PDxcglOLiMhcShHuA8CGacfrgcG5Orr7Xnfvcfee1tbWEpxaRETmUopw3w/8h8JdM78CpN39dAneV0RELlNDsQ5m9j3g08AaMxsA/gRoBHD3bwHPAJ8BjgHngHvKVayIiIRTNNzd/a4irzvwuyWrSERElkyfUBURiSCFu4hIBCncRUQiSOEuIhJBCncRkQhSuIuIRJDCXUQkghTuIiIRpHAXEYkghbuISAQp3EVEIkjhLiISQQp3EZEIUriLiESQwl1EJIIU7iIiEaRwFxGJIIW7iEgEKdxFRCJI4S4iEkEKdxGRCFK4i4hEUKhwN7MdZpYys2Nm9uAcr280sxfM7Gdm9pqZfab0pYqISFhFw93M6oFHgduArcBdZrZ1Vrc/Bp509xuAO4FvlrpQEREJL8zM/UbgmLsfd/cx4Ang9ll9HEgU9pPAYOlKFBGRxWoI0acDODnteAD4xKw+fwo8b2b3A1cBt8z1Rma2B9gDsHHjxsXWKiJSfUN90P80pE9CcgN07YS27mpXdYkwM3ebo81nHd8FfMfd1wOfAf7WzC55b3ff6+497t7T2tq6+GpFRKppqA8OPQK5UUh0BNtDjwTty0yYcB8ANkw7Xs+lyy73Ak8CuPtPgBiwphQFiogsG/1PQ6wZ4s1gdcE21hy0LzNhwv1lYIuZbTazFQQXTPfP6vMWsA3AzLoIwn24lIWKiFRd+iTEEjPbYomgfZkpGu7uPgHcBzwH9BPcFXPEzB42s12Fbr8PfNHMfg58D/i8u89euhERqW3JDZDPzGzLZ4L2ZSbMBVXc/RngmVltD03bPwp8srSlLS/9p9M823eGU6M5Oprj7OheS9e6ZLXLEpFK6toZrLFDMGPPZyA/Ch+/u7p1zUGfUA2h/3SavS+eIJ0bZ10yRjo3zt4XT9B/Ol3t0kSkktq64ab7g7X2zKlge9P9y/JumVAz9yvds31nSMYbScYbAS5un+07o9n7MpBLpcg+f4DxwUEa29tpunU78c7OapclUdXWvSzDfDbN3EM4NZpjdWzm/wdXxxo4NZqrUkVyQS6VYuSxx5nMZGhoa2Myk2HkscfJpVLVLk2kqhTuIXQ0xzmbn5jRdjY/QUdzvEoVyQXZ5w9Qn0hQn0hgdXUX97PPH6h2aSJVpXAPYUf3WtK5cdK5cabcL+7v6F5b7dKueOODg9Q1Nc1oq2tqYnxQ34AhVzaFewhd65LsuXkzyXgjp9N5kvFG9ty8Wevty0BjeztT2eyMtqlslsb29ipVJLI86IJqSF3rkgrzZajp1u2MPPY4EMzYp7JZJjMZknf8ZpUrE6kuzdylpsU7O2n5wj3UJxJMDA1Rn0jQ8oV7dLeMXPE0c5eaF+/sVJiLzKKZu4hIBCncRUQiSOEuIhJBCncRkQhSuIuIRJDCXUQkghTuIiIRpHAXEYkghbuISAQp3EVEIkjhLiISQfpumYjSo+dErmyhZu5mtsPMUmZ2zMwenKfPZ83sqJkdMbPvlrZMWQw9ek5Eis7czaweeBTYDgwAL5vZfnc/Oq3PFuAPgU+6+3tmdk25Cpbipj96Dri4zT5/QLN3kStEmJn7jcAxdz/u7mPAE8Dts/p8EXjU3d8DcPe3S1umLIYePSciYcK9Azg57Xig0DbddcB1ZvaSmR02sx2lKlAWT4+eE5Ew4W5ztPms4wZgC/Bp4C7g22bWfMkbme0xs14z6x0eHl5srRJS063bmcxkmMxk8Kmpi/tNt26vdmkiUiFhwn0A2DDteD0w+9/3A8A/uPu4u58AUgRhP4O773X3HnfvaW1tvdyapQg9ek5EwtwK+TKwxcw2A6eAO4F/P6vP3xPM2L9jZmsIlmmOl7JQWRw9ek7kylZ05u7uE8B9wHNAP/Ckux8xs4fNbFeh23PAu2Z2FHgB+LK7v1uuokVEZGHmPnv5vDJ6enq8t7e3KucWEalVZvaKu/cU66evHxARiSCFu4hIBCncRUQiSOEuIhJBCncRkQhSuIuIRJDCXUQkghTuIiIRpHAXEYkghbuISATpGapSGUN90P80pE9CcgN07YS27mpXJRJZmrlL+Q31waFHIDcKiY5ge+iRoF1EykLhLuXX/zTEmiHeDFYXbGPNQbuIlIXCXcovfRJiiZltsUTQLiJloXCX8ktugHxmZls+E7SLSFko3KX8unZCfjRYa/epYJsfDdpFpCwU7lJ+bd1w0/3BWnvmVLC96X7dLSNSRroVUiqjrVthLlJBmrmLiESQwl1EJIIU7iIiEaRwFxGJoFDhbmY7zCxlZsfM7MEF+t1hZm5mPaUrUUREFqtouJtZPfAocBuwFbjLzLbO0W818HvAT0tdpIiILE6YmfuNwDF3P+7uY8ATwO1z9PsK8FUgX8L6RETkMoQJ9w5g+peADBTaLjKzG4AN7v7DEtYmIiKXKUy42xxtfvFFszrg68DvF30jsz1m1mtmvcPDw+GrFBGRRQkT7gPA9G94Wg8MTjteDXQD/2Rm/w/4FWD/XBdV3X2vu/e4e09ra+vlVy0iIgsKE+4vA1vMbLOZrQDuBPZfeNHd0+6+xt03ufsm4DCwy917y1KxiIgUVTTc3X0CuA94DugHnnT3I2b2sJntKneBIiKyeKG+OMzdnwGemdX20Dx9P730skREZCn0CVURkQjSV/5KeEN9wXNP0yeDpyh17dTX+IosU5q5SzhDfXDokeApSomOYHvokaBdRJYdhbuE0/80xJqDpyhZXbCNNQftIrLsKNwlnPRJiCVmtsUSQbuILDsKdwknuQHymZlt+UzQLiLLjsJdwunaCfnRYK3dp4JtfjRoF5FlR+Eu4bR1w033B2vtmVPB9qb7dbeMyDKlWyElvLbu0GGeS6XIPn+A8cFBGtvbabp1O/HOzjIXKCIXaOYuJZdLpRh57HEmMxka2tqYzGQYeexxcqlUtUsTuWIo3KXkss8foD6RoD6RwOrqLu5nnz9Q7dJErhgKdym58cFB6pqaZrTVNTUxPjg4z58QkVJTuEvJNba3M5XNzmibymZpbG+vUkUiVx6Fu5Rc063bmcxkmMxk8Kmpi/tNt26vdmkiVwyFu5RcvLOTli/cQ30iwcTQEPWJBC1fuEd3y4hUkG6FlLKId3YqzEWqSDN3EZEIUriLiESQwl1EJIIU7iIiEaQLqjKv1EiKg28dZDA7SHtTO9s2bqOzpbwXSftPp3m27wynRnN0NMfZ0b2WrnXJsp5TJIo0c5c5pUZS7Duyj8z5DG1XtZE5n2HfkX2kRsr3/TD9p9PsffEE6dw465Ix0rlx9r54gv7T6bKdUySqQoW7me0ws5SZHTOzB+d4/QEzO2pmr5nZQTO7tvSlSiUdfOsgiRUJEisT1FkdiZUJEisSHHzrYNnO+WzfGZLxRpLxRurMLu4/23embOcUiaqi4W5m9cCjwG3AVuAuM9s6q9vPgB53vx54CvhqqQuVyhrMDtK0Yub3wzStaGIwW77vhzk1mmN1bOZK4epYA6dGc2U7p0hUhZm53wgcc/fj7j4GPAHcPr2Du7/g7ucKh4eB9aUtUyqtvamd7NjM74fJjmVpbyrf98N0NMc5m5+Y0XY2P0FHc7xs5xSJqjAXVDuA6U9BHgA+sUD/e4EfzfWCme0B9gBs3LgxZIlSDds2bmPfkX1AMGPPjmXJjGX49S2/Pu+fuXAx9Nzrr/PR4z9ji59lzYc2hX5Qx47utex98QQQzNjP5idI58b5rX+luYLIYoWZudscbT5nR7PfBnqAr831urvvdfced+9pbW0NX6VUXGdLJ7s/spvEygRD7w+RWJlg90d2z3u3zIWLobz5Bjf+84+YymR4JbeSkRMpRv7LA+T+8m544c9gqG/ec3atS7Ln5s0k442cTudJxhvZc/Nm3S0jchnCzNwHgOmPuF8PXLLwama3AH8EfMrdz5emPKmmzpbO0Lc+XrgY+qHDvUysaqJ+VRMt54aZfKeP+hWryL5xnvi1o3DokQWfvdq1LqkwFymBMDP3l4EtZrbZzFYAdwL7p3cwsxuAvwJ2ufvbpS9TlrsLF0PjI8NMxFcB0Db2S3JTjdQlmhh/71zwUO1YM/Q/XeVqRaKvaLi7+wRwH/Ac0A886e5HzOxhM9tV6PY1oAn4gZm9amb753k7iagLF0NzLa005IJr643jZ6lrjDGVG6ex5aqgYywB6ZMLvJOIlEKoT6i6+zPAM7PaHpq2f0uJ65Iac+Fi6JudPXS/9EPOT0yRZRVtPsbkuSmSN3046JjPQHLDwm8mIkumT6hKSVy4GMqHtvDPN95GXSJBy+oOmlYZLb+6gXhHM+RGIT8KXTurXa5I5Om7ZaRkLl4M3X4dUFixG+oL1tjTJ4MZ+8fvnvdiqoiUjsJdyqutW2EuUgValhERiSCFu4hIBCncRUQiSGvuUhmzL6x27dRavEgZKdyl/Ib6yP3dn5FNZRnPTNCYOEXT0T7iv/mHCniRMtGyjJRd7sA+Rn7yNpPjdTS0XMXkeB0jP3mb3IF91S5NJLIU7lJ22cN91DddRf2qFZwbn+T0+UkGxuD4gV49Qk+kTBTuUnbj5+qpa5zi/bEJTo/mmZicIh4z8tl6PSNVpEwU7lJ2jdd9nKns+2TOZmmog5U2TsP5HO+t26pnpIqUicJdyq7pNz7H5OoPk8s5q6beZ2qsjnfrruXVj93AsfG/49kzf8E3X/0mqZFUtUsViQyFu5RdvLOTlt99gDPtn+SddAt1b2eIpVN84PC3WHOin9bYNWTOZ9h3ZJ8CXqREFO5SEfHOTpKfbCFTd5xXrz7HS63jNGTPs+3/9POJs2dIrEyQWJHg4FsHq12qSCQo3KUiUiMpTh74LtmVdUyuXMl43RTDq5zMSmPDT4PnqjataGIwe8kTHEXkMuhDTFIRB986SMc7ed5fHSNeX0+cRsaZ5L1V0DycBSA7lqW9qb3KlYaTGklx8K2DDGYHaW9qZ9vGbaGfNytSCZq5S0UMZgfJJGLEzk8Sy5yj60SOj/7iPB86nicPZM5nyIxl2LZxW7VLLSo1kmLfkX1kzmdou6pN1wtkWVK4S0W0N7Xz849+kNXvnWPdyRz1486EwYoxmDqXZ/LnR9n9kd01Mfs9+NZBEisSJFYmqLM6XS+QZUnLMlIR2zZu40j3cd556QgN5yZhDFZNwmQDJM45G3/8KtxR7SrDGcwO0nZV24w2XS+Q+fSfTvNs3xlOjeboaI6zo3tt8MSyMtPMXSqis6WT3+v5IldN1ZFaC+7QOAVX5SGZhQ++Oc5TT/3napcZSntTO9mx7Iy2WrpeIJXTfzrN3hdPkM6Nsy4ZI50br9inskOFu5ntMLOUmR0zswfneH2lmX2/8PpPzWxTqQuV2tfZ0sn6D6znw6cgmXVW5SCeh1XnIJZ3rvnx/612iaFs27iNzFiGzPkMUz5VU9cLpLKe7TtDMt5IMt5IndnF/Up8KrtouJtZPfAocBuwFbjLzLbO6nYv8J67fxj4OvDnpS5UomH1b9xNy6izctJomII6h3qHxkmj8/hktcsLpbOlk90f2U1iZYKh94dIrEzUzPUCqaxTozlWx2aufq+ONXBqNFf2c4dZc78ROObuxwHM7AngduDotD63A39a2H8K+IaZmbt7CWuVCNjyb/4dr/3BQxhg09rrgebsPH9oGeps6VSYS1EdzXHSuXGS8caLbWfzE3Q0x8t+7jDLMh3AyWnHA4W2Ofu4+wSQBq4uRYESPfXMDHYKx/VVqEWknHZ0ryWdGyedG2fK/eL+ju61ZT93mHCf/fcQYPaMPEwfzGyPmfWaWe/w8HCY+kREalbXuiR7bt5MMt7I6XSeZLyRPTdvrsjdMmGWZQaADdOO1wOz7/m60GfAzBqAJDAy+43cfS+wF6Cnp0dLNiISeV3rkhUJ89nCzNxfBraY2WYzWwHcCeyf1Wc/sLuwfwfwj1pvl/lM4pf8s84L7SJSGkXDvbCGfh/wHNAPPOnuR8zsYTPbVej218DVZnYMeAC45HZJkQuuf/31iwF/4WcS5/rXX69yZSLRYdWaYPf09Hhvb29Vzi0iUqvM7BV37ynWT59QFRGJIIW7iEgEKdxFRCJI4S4iEkEKdxGRCFK4i4hEkMJdRCSCFO4iIhFUtQ8xmdkw8MvL/ONrgHdKWM5ydSWM80oYI2icUVLtMV7r7q3FOlUt3JfCzHrDfEKr1l0J47wSxggaZ5TUyhi1LCMiEkEKdxGRCKrVcN9b7QIq5EoY55UwRtA4o6QmxliTa+4iIrKwWp25i4jIAmoi3M2sxcwOmNkbhe0HFuibMLNTZvaNStZYCmHGaWYfM7OfmNkRM3vNzH6rGrUulpntMLOUmR0zs0se5mJmK83s+4XXf2pmmypf5dKFGOcDZna08Ls7aGbXVqPOpSo2zmn97jAzN7Nlf3fJbGHGaGafLfw+j5jZdytd44Lcfdn/AF8FHizsPwj8+QJ9/wL4LvCNatddjnEC1wFbCvvtwGmgudq1FxlXPfAm8EFgBfBzYOusPl8CvlXYvxP4frXrLtM4fw1YVdj/j1EdZ6HfauBF4DDQU+26y/C73AL8DPhA4fiaatc9/acmZu7A7cC+wv4+4N/O1cnM/iWwFni+QnWVWtFxuvsv3P2Nwv4g8DZQ9AMNVXYjcMzdj7v7GPAEwVinmz72p4BtZmYVrLEUio7T3V9w93OFw8MED5yvNWF+nwBfIZiw5CtZXImEGeMXgUfd/T0Ad3+7wjUuqFbCfa27nwYobK+Z3cHM6oD/Bny5wrWVUtFxTmdmNxLMKt6sQG1L0QGcnHY8UGibs48Hz+1NA1dXpLrSCTPO6e4FflTWisqj6DjN7AZgg7v/sJKFlVCY3+V1wHVm9pKZHTazHRWrLoSGahdwgZn9GGib46U/CvkWXwKecfeTy3nCV4JxXnifdcDfArvdfaoUtZXRXL+Q2bdphemz3IUeg5n9NtADfKqsFZXHguMsTLS+Dny+UgWVQZjfZQPB0synCf4F9r/NrNvdR8tcWyjLJtzd/Zb5XjOzM2a2zt1PF0Jtrn/+/GvgV83sS0ATsMLMsu4+78WeaijBODGzBPC/gD9298NlKrWUBoAN047XA4Pz9BkwswYgCYxUprySCTNOzOwWgv+Zf8rdz1eotlIqNs7VQDfwT4WJVhuw38x2uXtvxapcmrD/zR5293HghJmlCML+5cqUuLBaWZbZD+wu7O8G/mF2B3f/nLtvdPdNwB8Af7Pcgj2EouM0sxXA/yQY3w8qWNtSvAxsMbPNhfrvJBjrdNPHfgfwj164SlVDio6zsFzxV8Cu5bZGuwgLjtPd0+6+xt03Ff4+HiYYb60EO4T7b/bvCS6QY2ZrCJZpjle0ygXUSrj/V2C7mb0BbC8cY2Y9ZvbtqlZWWmHG+VngZuDzZvZq4edj1Sk3nMIa+n3Ac0A/8KS7HzGzh81sV6HbXwNXm9kx4AGCu4VqSshxfo3gX5Y/KPzuZgfGshdynDUt5BifA941s6PAC8CX3f3d6lR8KX1CVUQkgmpl5i4iIougcBcRiSCFu4hIBCncRUQiSOEuIhJBCncRkQhSuIuIRJDCXUQkgv4/FSfPWUsAm2YAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "a = Input(shape=(DIM,))\n", + "h = Dense(4)(a)\n", + "b = Dense(DIM)(h)\n", + "model = Model(inputs=a, outputs=b)\n", + "model.compile('sgd', 'mse')\n", + "\n", + "for _ in range(4):\n", + " x = []\n", + " x.append(np.random.uniform(size=(1, DIM)))\n", + " for _ in range(100):\n", + " new_x = model.predict(x[-1])\n", + " x.append(new_x)\n", + " \n", + " plt.scatter([e[0][0] for e in x], [e[0][1] for e in x], alpha=.5)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "v5Z3yxTnUTT-" + }, + "source": [ + "## Multiple Untrained Networks\n", + "\n", + "We can build a chain of networks and use the prediction of a network as the input of the next network. We can do this in a circular manner." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "colab": { + "autoexec": { + "startup": false, + "wait_interval": 0 + }, + "base_uri": "https://localhost:8080/", + "height": 677, + "output_extras": [ + { + "item_id": 1 + }, + { + "item_id": 2 + } + ] + }, + "colab_type": "code", + "executionInfo": { + "elapsed": 1566, + "status": "ok", + "timestamp": 1522832203577, + "user": { + "displayName": "Lenz Belzner", + "photoUrl": "https://lh3.googleusercontent.com/a/default-user=s128", + "userId": "102800868167498000139" + }, + "user_tz": -120 + }, + "id": "RBq9UbI3UhaV", + "outputId": "5c88e9ba-804a-4eb5-ed44-964bc67d8542" + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "n_models = 4\n", + "models = [make_model() for _ in range(n_models)]\n", + "\n", + "for _ in range(2):\n", + " x = []\n", + " x.append(np.random.uniform(size=(1, DIM)))\n", + " for i in range(100):\n", + " new_x = models[i % n_models].predict(x[-1])\n", + " x.append(new_x)\n", + "\n", + " plt.figure()\n", + " plt.plot([e[0][0] for e in x])\n", + " plt.plot([e[0][1] for e in x])\n", + " \n", + " # plt.scatter([e[0][0] for e in x], [e[0][1] for e in x], alpha=.5)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "TFS3YznBWZRl" + }, + "source": [ + "## Adding Offset\n", + "\n", + "We can add an offset to each prediction." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "colab": { + "autoexec": { + "startup": false, + "wait_interval": 0 + }, + "base_uri": "https://localhost:8080/", + "height": 677, + "output_extras": [ + { + "item_id": 1 + }, + { + "item_id": 2 + } + ] + }, + "colab_type": "code", + "executionInfo": { + "elapsed": 1474, + "status": "ok", + "timestamp": 1522832205162, + "user": { + "displayName": "Lenz Belzner", + "photoUrl": "https://lh3.googleusercontent.com/a/default-user=s128", + "userId": "102800868167498000139" + }, + "user_tz": -120 + }, + "id": "2H6bn029WmRf", + "outputId": "cbc65f97-7f13-4869-b1c8-b6aa4f8606a3" + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX8AAAD8CAYAAACfF6SlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4xLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvDW2N/gAAIABJREFUeJzsvXm0JMdZJ/qLzNqrblXdtfdNUmtpbZbdkm3ZGGwLIRks29jwbOCAgTdieBgwvGEwi80cM37ngOe9mfMeghlgWMdgg8EH4RHjBWzAkqzu1mLtSy+39+57b9VdqrKWrMqM90dEZEZkRua9cldL9q34naOjrrpfZcYX+cUXv++LLyIJpRQGBgYGBuMF69VugIGBgYHBKw/j/A0MDAzGEMb5GxgYGIwhjPM3MDAwGEMY529gYGAwhjDO38DAwGAMYZy/gYGBwRjCOH8DAwODMYRx/gYGBgZjiMyr3YAkzMzM0L17977azTAwMDD4tsKjjz66RCmdXU/uW9b57927F0eOHHm1m2FgYGDwbQVCyMmNyJm0j4GBgcEYwjh/AwMDgzGEcf4GBgYGYwjj/A0MDAzGEMb5GxgYGIwhjPM3MDAwGEMY529gYGAwhhgr5//FZy7gwmrv1W6GgYGBwauOkTh/QshdhJAXCCFHCSEf0fz9g4SQRULIE/y//30U93058H2Kn/7UY/jUIxva/2BgYGCwqXHJO3wJITaA+wB8N4AzAA4TQu6nlD4bEf0MpfRDl3q/bxau58PzKda6g1erCQYGBgbfMhgF878NwFFK6XFKqQvg0wDeNYLrjhQDzwcAtPrDV7klBgYGBq8+RuH8dwA4LX0+w7+L4r2EkCcJIZ8lhOwawX1fFgYeBQC0esb5GxgYGIzC+RPNdzTy+e8B7KWU3gTgywD+VHshQu4lhBwhhBxZXFwcQdNCCObfNs7fwMDAYCTO/wwAmcnvBHBOFqCUNiilff7xDwC8TnchSunvU0oPUkoPzs6ueyLpy4I75M7fpH0MDAwMRuL8DwPYTwjZRwjJAXg/gPtlAULINunjPQCeG8F9XxZckfPvmQVfAwMDg0uu9qGUDgkhHwLwBQA2gD+ilD5DCPk4gCOU0vsB/Bwh5B4AQwBNAB+81Pu+XARpH8P8DQwMDEbzMhdK6QMAHoh89zHp378C4FdGca9vFoOhWfA1MDAwEBibHb6u5wEA+kM/yP8bGBgYjCvGx/kPwwIkk/oxMDAYd4yN8xc5f8CUexoYGBiMpfNv9U3Fj4GBwXhj8zv/xjFg0FOdv2H+BgYGY47N7fxdB/i924EnPoX+0KR9DAwMDARGUur5LYvWBWDYA7pNDCyz4GtgYGAgsLmZv8PPB/K9SM7fOH8DA4PxxuZ2/u2L7P/eIJLzNwu+BgYG441N7vwX2P/9gbKxy+T8DQwMxh1j4vy94GC3YtY2OX8DA4OxxyZ3/lLah+/wnSrnTKmngYHB2GNzO/9gwZfl/C0C1IpZ4/wNDAzGHpu71FNi/q7lI5exUClk0DY7fA0MDMYcm5v5t8NST3foI2tbmMhnTM7fwMBg7LF5nT+lIfPnaZ+czZi/SfsYGBiMOzZv2qe/Bnj8tcHeAAPKmX8hY0o9DQwMxh6b1/mLMk8A8IdwfZ7zz2fNDl8DA4Oxx+ZN+0Sc/8CjyNoEE4UM3KGP/tB79dpmYGBg8CpjEzt/nu/Plli1jxemfQCzy9fAwGC8sYmdP2f+1e2c+Yu0D3f+JvVjYGAwxti8zt9ZAIgNlOdYzn/Iq3248zcVPwYGBuOMkTh/QshdhJAXCCFHCSEfSZF7HyGEEkIOjuK+qWhfBMqzQCYXnOqZ5aWegHH+BgYG441Ldv6EEBvAfQDuBnAAwAcIIQc0chMAfg7AI5d6zw2hvQhU5gAry5i/R5HNWKgWsuzPJu1jYGAwxhgF878NwFFK6XFKqQvg0wDepZH7TQC/DaA3gnuuj/ZF7vwzbJPX0EfOJlLO3xzxYGBgML4YhfPfAeC09PkM/y4AIeQWALsopZ9PuxAh5F5CyBFCyJHFxcVLa5WzCFS2AHYG8IZwvfBsH8BU+xgYGIw3RuH8iea74IW5hBALwH8G8H+udyFK6e9TSg9SSg/Ozs5+8y2ilFX7lGeDtM8gUuq5Zpy/gYHBGGMUzv8MgF3S550AzkmfJwDcAOCrhJB5AG8AcP9lXfTtLgP+gDF/Ke2TtS3kMzZytmVy/gYGBmONUTj/wwD2E0L2EUJyAN4P4H7xR0rpKqV0hlK6l1K6F8DXAdxDKT0ygnvrIWr8K3OAneVpH4qszdStmPN9DAwMxhyX7PwppUMAHwLwBQDPAfgrSukzhJCPE0LuudTrf1MQu3uDBd8h3KGHfIY7/3zGvMTdwMBgrDGSg90opQ8AeCDy3ccSZL9rFPdMhXiDl5z24Wf7AGAne5q0j4GBwRhjc+7wFcy/PBukfcSCLyCYv3H+BgYG44tN6vwXWJVPcRKwMqD+EEM/zPkb5m9gYDDu2LzOvzIHEBKkfQAglxHO37zE3cDAYLyxOZ2/w50/wNM+3PlLaR/D/A0MDMYZm9P5ty+y0zwBwMqCgILADxZ8TamngYHBuGOTOv/FkPlbNgAgCw9ZqdTT9Xz0BuZtXgYGBuOJzef8fY+f6yOlfQBk4AVpn2rBvNDFwMBgvLH5nH+nCVCP1fgDrOoH3Plnwh2+gDnczcDAYHwxkk1e31LIV4Af+mtg9mr22WIqZuBJdf7mTH8DA4PxxuZz/tkicPWd4Wc77vzDkz3NEQ8GBgbjic2X9olCl/bJm7SPgYHBeGMMnD9n/sRTzvYBTNrHwMBgfLH5nT+v9sliqGzyAsxL3A0MDMYXm9/56xZ8DfM3MDAYc4yR8/eDnH8+YyOXscyCr4GBwdhi8zv/YJPXMGD+AFDIWOgP/FerVQYGBgavKja/85fSPjnJ+ecyNlzPOH8DA4PxxBg5fx/ZDAm+ztkEg6Fx/gYGBuOJze/8RdqHDCPM3zLM38DAYGyx+Z2/JUo9w1M9Ae78DfM3MDAYU2x+58+Pd7BjOX/j/A0MDMYXI3H+hJC7CCEvEEKOEkI+ovn7vyWEPEUIeYIQ8jVCyIFR3HdD0NT5A0DWNmkfAwOD8cUlO39CiA3gPgB3AzgA4AMa5/4XlNIbKaWvAfDbAP6fS73vhsHTPnnLh23JC76G+RsYGIwvRsH8bwNwlFJ6nFLqAvg0gHfJApTSNeljGQAdwX03Br7gm7NUR28WfA0MDMYZozjSeQeA09LnMwBeHxUihPwMgF8EkAPwthHcd2Pgr3EsRJx/PmOh6Rjnb2BgMJ4YBfMnmu9izJ5Seh+l9EoAvwzg17UXIuReQsgRQsiRxcXFETQNQdqnQNT39WZtCwPD/A0MDMYUo3D+ZwDskj7vBHAuRf7TAN6t+wOl9PcppQcppQdnZ2dH0DSEaR9bnY9MtY+BgcE4YxTO/zCA/YSQfYSQHID3A7hfFiCE7Jc+fi+Al0Zw342BV/vkSSTnbxZ8DQwMxhiXnPOnlA4JIR8C8AUANoA/opQ+Qwj5OIAjlNL7AXyIEHIHgAGAZQA/dqn33TCE87fUtI9Z8DUwMBhnjOQdvpTSBwA8EPnuY9K/f34U9/mmEFT7qGmfrGH+BgYGY4zNv8OXM/9cZME3b5i/gYHBGGNsnb9Z8DUwMBhnbH7nTwiGsJGNLPhmbQs+BYaG/RsYGIwhNr/zB+DBRi5a7cNP+Bx4r9xmYwMDA4NvFYyR84+kffghbyb1Y2BgMI7YdM6/N/DwtZeWcHalG3w3JBlkNTl/AOh76vcGBgYG44BN5/zb/SF+5L8/gi8/ezH4bkituPM3zN/AwGCMsemc/0SBVfesdQfBd0PYyELP/E3O38DAYByx6Zx/PmOjkLWw1gud/wAZZBIWfA3zNzAwGEdsOucPANVCFmvdYfB5CCvO/E3ax8DAYIyxOZ1/Masyf2ojg6EiI17m7poFXwMDgzHEpnT+Na3zj5/qCQDu0OT8DQwMxg+b0vlXC5kg7eP7FENYsBMWfM35PgYGBuOIzen8JeY/8H0MkYmlffJmwdfAwGCMsTmdfyEblHq6Qx8D2MjQ+Gscxd8NDAwMxg2b0/kXM1jrDUEpxcCj8KidmPYx7/E1MDAYR2xO51/IwvMpOq6HgceYvx1J+5g6fwMDg3HGSN7k9a2GapG9vWutN8DQoxjChkVdRUZU+/QN8zcwMBhDbE7nX2DOf7U7QNa24MGGTc0mLwMDAwOBzZn2KYrzfYZB2seKOn+T8zcwMBhjbE7nz5n/WneAwVCkfUzO38DAwEBgUzr/mpTzdz2fO3+V+dsWgW0R4/wNDAzGEiNx/oSQuwghLxBCjhJCPqL5+y8SQp4lhDxJCPlHQsieUdw3CcGCb3cAd+hjSG1YdBCTy9rE7PA1MDAYS1yy8yeE2ADuA3A3gAMAPkAIORARexzAQUrpTQA+C+C3L/W+aQjO9O+xnL8u7QOwRV/D/A0MDMYRo2D+twE4Sik9Til1AXwawLtkAUrpVyilHf7x6wB2juC+icjaFko5m+X8ufMnfvz0zlzGNszfwMBgLDEK578DwGnp8xn+XRJ+EsA/6P5ACLmXEHKEEHJkcXHxkhpVLbDzfQLnr2H++Yxh/gYGBuOJUTh/ovlOe04yIeRHABwE8End3ymlv08pPUgpPTg7O3tJjaoW2cmefX62D/ETcv7G+RsYGIwhRrHJ6wyAXdLnnQDORYUIIXcA+DUA30kp7Y/gvqkImT+Fl5j2sUZa5y+uJQ6NMzAwMPhWxSi81GEA+wkh+wghOQDvB3C/LEAIuQXAfwNwD6V0YQT3XBfiWGexyYv4A4CqAUluxGmfT/zP53DbJ76Mr7zwiqhoYGBg8E3jkp0/pXQI4EMAvgDgOQB/RSl9hhDycULIPVzskwAqAP6aEPIEIeT+hMuNDOKFLgOPlXoCAPz4EQ+jXPB95EQTy50BfvyPD+O3/tfzGJrFZAMDg29RjORsH0rpAwAeiHz3Menfd4ziPi8Hgvm7Qx8ehPMfAnaocta20B8R8/d8imOLbfzoG/dg4Pn4va8ew6lGB/f98GtHcn0DAwODUWJTHuwGhC90EQu+AAB/AKAQyOQyFtr9eBXQN4OTDQfu0McNO2r4wYO70B/6+PKzF0dybQMDA4NRY9M6/1oxC58CKx0XQ+H8PbXiJ5+x0HRGw/xfvNgGAFy9ZQIAsL1WRLvPXihDiK4gSgWlFJQClpUs23GH+KOvnUDDcdHuDUEI8NHvO4AJfpaRDi9dbOHYYhsX1/pY6QzwgdfvwtxEIVH+6EILz5xbw2Krj6W2i3fevA3Xb68lyl9c6+Gxk8tYaPWx2Orjtn1TeMvVyZVaa70Bvn6sEcjvmirhfa9L3vbhDn08dGwJF1Z7WGz1kc1Y+Km3XJHYp5RSPHKiiTPLXSy0eui5Hu79zitRySeb+tNnV3F0oY2FVo/10W27sWuqlCg/v+TgqbOrvI/6+J7rt+LmXfVE+cVWH4+ebGKh1cfCWh+v2VXHHQe2JMo7/SEePtbAxRbTeUu1gA/ctjtRfuj5eOhYAxdWe1ho9QAAP/1dV8FOsaUj802cbHSw0Oqj4w7xk2/eh3oplyj//IU1vHChhcVWH03HxQ8c3IV9M+VE+dPNDp48s4oFrsPbrp3Dwb1TifJNx8WhE00scvnrtlVx943bEuW7roeHjy/h4hrr03opix+7fW+ivOdTfP14A2dXulhs9TH0KH76u64MzvjS4fFTyzix5GCh1Ue7N8SP3b4XsxP5RPmXLrbw7Pm1oI/efcuOwB/ocG6liydOr2BhrYfFdh9vunIGt181kyg/amxa5y9O9my0XUwQrmY05z/CBd+XLrYAAPvnKgCASiEDnwId10M5wfH4PsU/Pr+Af35xAf/84iI6fQ8PfuRtKGRtrfznnzyP//TFF1HJZ5DLWGg6Lr7vpu2JzvZ0s4M7/8u/KOvclUIGP/nmfVr5gefjPfc9hJYUDTWdPn77fTcn6n3vnz+Kb5xeCT7f/FIt1fl/4vPP4TNHwm0h+YyV6vz/x9dP4uOff1b57u4btmLPtN7xPHSsgR/+w0eU767fUcP3XL9VK39xrYd7fudr8KU+KmRt/Nzb92vlfZ/iff/1YSy1w4K1k80O7vuh5PTehz/zOB482gg+XzVXSXX+/+mLL+CPH5xXvvuB1+1EJqGK7G8eO4Nf/punlO/edu0WHNhe1co/cXoF7/uvDyvfXTFbxntu0T+H1c4A7/z/voaBF3aSRyl+5e7rEnX44T98BKeaneDzs+fX8Cc/flui/C//zZP4khQpb68VUp3/fV85it/5ylHlu/e8dkdwqGMUDzx1Hj/7l48r391+1TRuTZiQXrzYwnt+9yHlu621An7kDfqTaXoDD/f8zoPoDkIf0+oN8ZvvviFRh5/4k8N4/kIr+Hz4xPIr6vw3bU2iMILFdh/UktM+IbIjXPB9caGNHfVi4OjFEROtXnJa6Y8ePIF/82dH8LePnUU+Y6PhuIpTieLIfBP1UhZP/sad+Mt/84Z1r//w8QYoBf7wRw/i0K++HQCCdxvr8PTZVbT6Q/zHd9+Ab/zGnbh6SwVr3eTrt3oDPHVmBR+8fS+O/Pod+N6btmEtpT0A8NDxJbzl6lk88qtvx4fv2I/+0Ed/GC/DDeSPNbB7qoSv/fJbAweb1qaHji3Btgi+/ItvwRd/4S3r6vzIiSZ83kdP/oc7UczaqfJHF9tYavfxK3dfi8c/+t24eVc9Vb4/9HB4fhnvv3UXDv/aHfjBgztT5QHg4WMN3LZ3Cg//ytvwq++4FkD6c37oWAOzE3n8679/K/74g7cynXvJ93jo2BIA4PM/+2b8679/K5NP6dMjJ5sYeBT/7wduwTd+407MVPKp8meWOzjV7ODn374fj330u3H7ldOpOgtWfs/N23Ho196OD96+d307OraEG3fU8NBH3oZPvOcGrkOazg1M5DP4l196Kz5z7xvWlX/4GJusP/tv34gjv86WLNP69PFTK+gOPPzWe2/ENz52J/ZMl1Llm46L5y+08FNvuQKP/voduOO6uVT5y4HN6/z54W6NtgtqcTYQSfvkbAuDETL/q7dUgs8izdDuJz/QLz17Eddtq+KJj92Jf3fnNQDWG4TLOLhnEpZFpPOLkq9/+EQTk6Us3nbtHOaqBVTymXT5+SYA4Huu34paMYuJQhatlPY/enIZPgXuuG4LZip51IpZtFKuf2G1h9PNLt6yfwZbqgVM8jRDkmPzfYojJ5t4/b4p7JwsYboi5NN0XsYN26u4am4CczxET3Och080Uc7Z+K5rZlEtZDFRyKTKHzoR9tFkOYfqOvJPnVmFO/Tx1mvnMDsh+ihZfrUzwAsXW3jz/hlsqxXX7SOhw217p7BrqoSZysZ0vmqught21LClWuDyyX16aL6JrE1w54EtqBWzXOf17ejO67dgqpxDtZCu8wsXWmj1hnjrtbOYmyigVsyi3R/C87V7RdEbeHjq7Cpuv2oa2+tFTG2kj+abeN3eSeyeLmFmA3ZxaL6J7bUCDu6dwnQ5h6xN1r0+IcBd129DrbS+HYk+uuPAFkxX8qiuYxeXA5vX+XPm33D6IJZI+8TP9B8F8x96Po4vOkp+L3inQMID7boeHj+1grfsn0EuY6G6jjNvtPs4vugEeVMxua03CA/unQrWEdZ3bMvYN1MO8pqiXDYJR+aXYVsEt+yuBzqnyR/iBn/bPqGDeOmOXoeji22sdAa4VcgXwqO6degPPTxxZiUI5cUEvN6E99o9k0FKRVSJpcnPTuSxZ7q0IXmhs2hTtZBFd+Albi48crIJSiX5YrrOZ5Y7OLfaw617J7l8ep96PsWRk8vB9XMZC4Wslcq0D59o4sYdtSAdOVHMpsofOrGMiXwG126tBm3aCOmI6txOuMfjp1Yw8Chui/ZRgs5Nx8XRhbbyDIDkPqWU4vCJZmB3hJCggCRNh2u2TKBWygb3SJU/0UQuY+GmnbUNyV8ObF7nL+X8A+avcf6jKPWcb3Tgej72S85fMPMkAz4834Tr+UGOL3TmevkjJ5cBAAf3sEFeztmwSHKksLDWw3yjEwwQIN3ABMsWToTpkM7kD803ccP2qpLqcj0fvYE+jSNY9oFtzClM5NN1Fixb6CCf1qrDk5xli0GbsS2Uc3bi9QXLlvO+6zI2zrLFgvN6zF+w7KlyTtEhUWfOssWEul6EFzjOfaKP0kmBYNm37dvYcxYsW1wfwIaY/+v2TgYLzhPrMH/BsndOlrj8+joTAhzco9pF0j0OR0jHevKnmmwhfKN2MfR8PCZNqOvJiza9Zmcd+QybUKuFDNruEH5CtHM5sHmdPx8EQ58Cgvlr0j6jWPAVi71K2mcdA3vw2BKyNgkZWyGdvRyZZ0zhRs4UCCGpg/ZQxCkA6QYZsGx5sihmEh1tf+jhidMrEfl0RqVj2evJR1k2kNxHYrKItimxTyMsGwiPBdEhyrID+Q2y7I3oEGXZoV0kTZAqy15vgoyybHaP5AgvyrJFmzbKsoV8x9VHO1GWLeSZDsl2EWXZqfIRll3I2shlrHXt6LZ9ETtKuP6z59fguF5MhyR5pz/E0+fWcKs0AVeLWVAKpdjicmPTOn8xCACA2Mlpn1Gc7fPixTYIYVUc4f3TGdhDRxu4ZfckSjl1gTjJYI6cXMbNO2sBUxC/SWQ7J5ooZm1cL1V8pBmwzuDF5EJpnI08FWHZAILUla5NSSw7SR5gaSWZZYs0TrK8yrLFPZIZ4bLCsteTPzLPoq/ohJq0aJ3EspN00LPsdDs6EmHZWdtCMWunkgKZZYs2JdpdhGULndOeARC1o+QoWMey0+woiWUnyQPA4ZPLCssW90ibIOulLK6alcdzuh0BUCbItGjnidMr8HyaoMMrl/rZtM5fhPwAADsh7WNb8Cku+RiGFxda2DVZChw5IC/4xg1gpePi6XOreNOVYVlXmgF3XQ9Pn12N1UmnDdpD88t43Z5J5ZC5dANmLHu3VN9eLWQx8Ch6g3j/RHPZQh7Qs9pHT2lYdgoLPrvSxdmVrsKybYtgImHRWseyRZvSGKTMskWbEhnhfFNh2bIOun5NYtmAfpJ/4rSGZReTmfyy4+KlCMsWv9ExeR3LFjokOcJDEZYdyif3qcyyhTzTIf6bJJYN6O3iufOtGMueSLG7jjvEM2dXFZYNrGcXyzi4Z0rZc5MW7Rw+0cSuqSK21sL9M9ViJnHR+tCJJiwCvG6PGkEC6YvQo8amdf5AaERIqvYRL3G/ROcfrfQB5MXG+MP8Oi/BfNNV08F3YrLSGdg3zjCnIDtCIJm9rHYHeP7C2styhFGWDaSzkWguW5WPt+nQCT3LTpI/fCKethK/0cnrWHaafG/g4ckzKxu+vmiTzLLX0yGJZTN5fZ9GWXYY7WjkNSxb3ENXpaVj2UIH3fV1LBsAJvIZ9Aa+Nmo+NB9n2anPOYFlJ8kHRQNSm8SitS5l8vipFQwjLDvUOS6/0OrhxJKzYTuilOLwfFNz/eRF68PzTVy3rapszkybwC4XNrXzFy9yT0r7CFZ8KXn/gefjxJKjLPYCjKVW8hntw3/waAPlnB3bFZrE5EUo/drdUYPUs5FHRS47wYCjaRwdywaSGVsSy05LaehYdiWXASF6x6Zj2aJNaY4wzoL18jqWDbAJUrdonciyE5x5MstOJgU6lp22aK1j2axNeuavY9lCB931dSyb6aB/zmksG9Az/ySWza6vnyCjLDvUQR9ZRFm20EEnH6T2NM9ZJ398yUHDcTV2pI/wBp6Px0+taKM1wDD/kUEYkRWkfdZn/l97aQkvSLvuBH7mU4/h1z73VOz7+SUHA4/GmD/AWJvOYB48toTb9k3Fzv2vFvXs4sjJZVy9pRLbfp8kH7DsXXGD93yKjqs6tjSWDcQdlWDZ8clCb/ABy44YvMUnSJ0jPHyCLQ5HjyiYSHJs801sqxWwo16My6dEFjGnkDBokyaXkLGp9xAsW5eqY/Lq9QXLPhjpU/Eb3SR/aD6+DiTkkybIWlFl2YCYLPQTMIDYcw7sIvIbwbLjOgt5tY8Ey45ev5JgdwHL3qNeX9xDZxeH55u4dqvKskN5/WRRyFqxI00mClk4rhdLEQs7SnzOkefw9NlVdAdesh2ZnP9oIJxRkPP34gu+gMr8P/K3T+I3I8cJ9AYevvTcRTx1djV2D3Gmz/65+BkeE4VMLOd/YbWH44sO3qTZxq1j/p5P8ejJZe25KElpnMPzTdywo4ZiLuoU9OwikWUnMPn1HGHU8QiWrdtKr9NBsOwoQxX3iKY0ApYdSVsF8ppFa8Gy4xNqss45O86yk1Jj0TJVgaRF64Bl6/pIM8kHLFsjnzjhzS/j1r2TsfOjkhatD59oYudkEdtq0QlV30eHeNoqPqHq7UK3gA4kL1oLlh2VF21KYtlaO8rro53D803csmsyduZPsGjdj4+d6XIOV86qx40kLVqHpbl60mGY/4iQyvxf+F+o988DUJ3/aneAw/NNJex//NQK3KGPRtuN3ePFiy1YkUofgYomT/jgUba1/vYr485fF66/eFHPsoV8u6/WBguWrTP4pPA7iWVXExieYNk7J1WnkLT3IGRHOlYb1zlpchFtSmLZOqegW7QOctn79O0BdDov4+Zdtdi5S0mpMcGy90fsImnROroBTm1T3LEFuWydzpqURsiy9fKA6ngEy45OXkB6dHTd1mrsfJ2kVJdg2TdoDg7ULVoHEWqCDtHrJ7Hs4PqR9rd6Azx3fi2xTwGNbc83cXDvZIx0JC1aHzqxjL3TpdjhiibnP2KIB2BlNDn/z/4Erpr/CwBh2odSinafvff38VPhYWVfP87O+Wg4/RiDPLrQxq6pkvYwNl34/fyFNeQzFq7dGo8UdIP2+QtrAIAbd8RPjZwosNpgxw31OrbYxsCjuHmnTj7OUgeej5cW2rh5Z3wAJjG8Fy60cNPOWszgk/YePH+hhb3TJe2pkXqdWdotyrJFm5Lk9TrEdT6z3IXjerhJ00e6aIdSiufPr2nlk6Ip0Ue6U1p1i4fPn1/D7EQ+xrJZm+Lyz51ndpH0nGMk4gKLUDeqw2K7j4bjJj4DJh9/DjfvissnLVq/cKFfdcL8AAAgAElEQVSFA9uq2pM1dRHe8xdaqOQzMZYtdHi5dtQb+Arxe2mhDZ+m25E8YTj9IU43uy/LLp6/oLejtEXry4XN7fz5A7Bs7nREtY83BAYOcl4XADAYMofecb3gBExx+BUAPHKCOf/ewI/lyy+s9WJ5ZoGJfCb2MJvOADOVfKJTiLIXEW3ojpLV5eTT5HXsZdlJk9czvEa7n3i0rW5j2FKavFbnPiYKGe2EKq4vT8Ib0lnSoeH0E+V1uVfH9dAf+lp5sWgdZWxLbRezlaQ+iufwG06yvI75NxwXGYtgspSNyesWrdN01pXohn0aP/47PEIifG6eT7Hc0esQVrJFnrOzjl3E5F3MVHLa47x1R4s02mk6xyekVDvS2EUzbewkRNmNtpuoc9LazuXC5nb+gvlHq30GDgAg67Ozz12PDRJHctQiPdMbeHjs1EpQ0igeuMBSux8cphWFjuE1nT4my/pjZ0UtseLYHBdZmwTGqtOvpTHISR3L1rCXBpefKsd1KGZt2BZRru/5FCvdgVYeELlU1YCbjquUhKptiss3HBfTCfITBbZoLR+d2+SOTXePtAlSdw9d1UWzLfooLp+0aJ2ms84uGo4bHFyna1PMjtouJstJjlDznFN01kV4TSdZZ90EudxxQaleXvxGbxfJjjAu30+xozjzbzguyjk7MSoHojqvb0eyvBg7uj7V7fDvuh66A+9l2cXlxOZ2/vwBkyzvbOH8Xeb8M5Q9bHG+j2DpOyeL+MaZVbT7QzxxmuX7xXnw0SOXF1vpzj9a6tnsJDvOajGLYdSxtV1MlvSDXFdFkWaQusPm0gY5O9BKZWBikCc5Z12uNn2Qx6su1pssgLjOlXwmVvWiyscnyFTH1o1HCok6R5h5MMiTnLmGyac5tokEUpD8DPTO3LZIUP6syieTAt2ENJHn0Y7OjhKjHTXH7vsUy51Bqg66KDht7EQXrZuOm/wMtBGhGDvxe9Q0Ofy0ySJrWyhF9u28XDu63Njczp8btR1N+wjn73Hmz52/cNR3HtgKz6c4dKKBrx9vgBD2AhFAZf4dd4iO6yWGcZV8/ATHZcfFlCZUB5LZxXqOUGX+/cRBrsvVpg1y8RtdZJHqqGKDPN1RRRet15ssojqkTxZpjC1+D7FovVEWLNqkXj99kGsjwnb6cx766qJ1+mQRX7RuOC4mS9mEdKPGjtrJjs2yCCq5jDZlkhaxyTqvdgfwfLpOn8ZJQVqfMh3U57a+HakRXjFrx6rkkuRDnTcW+W/EjtZ7j8EosbmdPzfqTDaS9nHZ4pftMQMXbygSZVzfec0schkLDx1t4JHjTVy/vRq8sk6u+FlqsX/P6BznoItpm00yTn9jBqlnqf0Ux6w3+KRBXshasXPJ0wY5EM/hrzfIoxuGVroD+KnpAPbGM3nReiOsNpp7TW6/Xj5pkItF640yQnEPfWSRIi9dvzfw4Ljeuo5twzonpDTWmyDlaKrpuCBEnz4MdOhu3LGxtZ2Nk45oDp9SRiLSoimmgzohpdlpVD6tT3XHg4fRzsaY/Lo6r/M+jFFjJM6fEHIXIeQFQshRQshHNH9/CyHkMULIkBDyvlHccyMIc/6Rs30487f5gq9g/mKwzFRyeN3uSXz1xUU8dmoZr983HTywhsT8F9ssctAy/6/8X3jnoz+hXLc/9NDuDzGly/mffQxvOPJh2PA0g1xz/dWz2P3Zu7EFzY05haEL8mf34E35Y6rBdwbJg/xzP413eF/VM3+dAf/LJ3FP84+0A0Rr8E//Lb7nuV8FEPYRpZRFRzr5c0/gdf/4ARTQj01I2kHuLGHm0+/ATrKgOMLlpD7yPeDPvx9vzT0Tk0/U+fO/iHe6/6CNLLT3ePg+vPPCfcpO6+VOymTxwj/g7U98GACNPQetzosv4Pp/eC8m0FFz8s5A357eKir/4x3Yb51Rr99xUS9m4+8BphT4yx/Cd9uPxuSBBFLwxV/HPZ3PqX3aSemjw/8d33fqt5VF67XeEAOP6q9//Kv4jkfuhQU/dg/t9ZdP4sq/uwdTWFMnyE7CuovbQeZPvxe35k7GiFYuI50hJuOzP4m78KDejnTP+Z8+gXetfir1fRijxiU7f0KIDeA+AHcDOADgA4SQAxGxUwA+COAvLvV+Lwe1oNRTn/YRzF8s+ArmP5HP4k1XTePoQhv9oY83XDGN0tLTuCl7JqggAIDFlovryEnsbj8Zv3njKCrdswBCtrDssP9P6gzy6Jcxe/oLmMWK6tiSBvnZR5G5+CSus+IGqTX41dPAiX/BG+0XY4wwcZA//Vm8dvhEhOGlRArPfR7XtR5U0jipjPDol7H7/BcB0KCP1npDDP2EQT7/NVQuHsYOsrQxxnb+G7DPPYrX2sdjKRDtIHcWgWP/iNeT52LXTxzkz3wOr+k/qk54adHR8w/g6pV/UXZaN1IWlHHsn7Dtwj8hjwFW+XMYeD7WekO9Ezn5EIoXH8M+cj6WitJGLgvPg5w5hDfmjsdy+Nr2uG3ghf+JW+kzWp21tv3M3+HG7iFtNZH2Hi9+AVc2vgogHDupdnT8q5i+8DXU0Q7kKaXJY+f0IeQvPo5rrNMbI07N48Cph/DG7NG4HekW3b0h8PTf4KD/pD5S0I6dv8f17Ye/7Zj/bQCOUkqPU0pdAJ8G8C5ZgFI6Tyl9EsBo3pm4QYjQzs5ENnnxtI8VYf5t3vGVQiZ4yQohfJfm3/88Ppr9lJLzX2z38e8yf4XdD/1q/ObOImyvhyyGwVpCwIJ1D7/NXl5dJZ3AwNwhYzJaY3EWAABTdldjkJpB3pbkN2LwvVXAc1FFJ8I4+QSmixScRRS9NigF2q7QOWWyaC+AwEcZvcBRpQ4QrnMNjhIpNJPSAc4iAGA229vYBMn7aNLuxpi8fpAPgG4TFak9gMRqtW1aQH7I7C+qs3ZC4m2qwgmeQ2okwnWW7ShVZ96nM5lerDoozY5qVidGIqqFTOzIErYRZQFl6ijRTjgWNPdwFpAbshr9DdlFW+gcPgfH9eAO/VSdq3BiEWSa/HSmu7EIstMAQPnYUe0oqXIPzgJKfnvdd1qPEqNw/jsAnJY+n+HfveqoFjP4hTuuxnffuJN94fNO5cyfDEWpp5rzL+dt3LSjhko+gwPbquygrZVTmCFrWJKc/1KrjxmyCtu5GL85HyQTkgEIp6B1nO3Qsa1F5NMc1ZZsL8bYtKWkjnBsEYNMGuTciVQiA6Tp9FErZvWDvB13bKn5cjHhSRPMepMFwBxbdJCnTaizmd7GFojFMyCdjU2QvI+YYwurccQgn8hrBnn7IndsVNJ5/ecs65xW0SV0rkmOMCzPTZafyby8CbIamfBYNKV5xv01YNhD0W8ri9biOWtttb0I23eRhxufIDdqR2mRBZefy8btQt+n7DlP2V1l41liMQa//oQ0YYs2aSv3vAHQaaDgqWPncmMUzj++sgh8U+8iI4TcSwg5Qgg5sri4eInNYot3P3/Hflw5x3fsRdI+ZBjJ+feHyGUs5DM2MraFj37fdfiFO64G3A7QbaKGVmC0AGP+U5YD0lsBhmoJKBy2T6BKnGBSSV3wCQZ5aDCpi6ttwdhCJj/0fKwklZLKji3CCPUDkBlwyW8p55InGnx3GfAHyA1bsOAH9wjTAboJaZG3yQlSS6npABG9WKFzDq6fMqFO251IKq0fvPRbbU+yY0trT9Fr8UVrL2iTdpAP+0BvFRb1UEbItIM1gpQ2MVKgThZpOjNSwCOFtBp87tgmLZ1dJLdnQmpPIK+rYuPXL3AmL+usLc/lkQLAmXlXJQVpxEaxo1QSwdo0l+kG8qI8V6szHwt16fpC57RIoUzbsZJkvTzzFbnhGgD6im30GoXzPwNgl/R5J4Bz38yFKKW/Tyk9SCk9ODs7O4KmcRDCXuUYSfuQQTTtM1TY2v92627ccWALsMZy9xP+Ghqt0MkvtfqYBLuWcGTsgk6wkWwC3Vi4rh+0zMCmrNAg01Mggo30pMiC3Sdtsog6tsQF5cCxMf3EBLYeCwaAClSWqh3kvh+mKCSGtJG0z6zE2IKyypQUSN0Kn0HHHaI38PUpExGt0ahjS6iU4dcPo53Qsa3XR1WEE1Jaea4upZFKIvg9ZCa/kT6tS5FFanku76Oy346lcbR2xK+vi3b06cYVwHO5zrpoR2ergkR0XpYdTWU0dpSWJiLRFGgSKWDtKXltZdE62Y7Y9W1/gDwG31bM/zCA/YSQfYSQHID3A7h/BNcdLaxsrNqHeH0QhOd7tPvDYGeegtUzAIAsddHptEKDb3VQAbuWcN4A1EFOnGDzWIOXz+nOuBG/mct1JXbUhwUf2zvPx+UFG7E2aPBcviw5to0McpF7DRlYeqjLdO6sL99dDp5HlYSOMH2QS9FObIJMTgfUrE4sskjTueS31UXrpFwwv3522AaBL7UpoTxX6SNH6SNtee6gB/TZSbJ1qytFU2mslt1jOhPKb0TnKgntIrU8V5ACv60uWiemTFh7LOqhhH6waL1eWgmIRDtJNfi+r5CCjdkRJ1p2R7OgnGx3E1IKVFTupemc58Rpbb0JT9K5GomoLicu2flTSocAPgTgCwCeA/BXlNJnCCEfJ4TcAwCEkFsJIWcA/ACA/0YIeeZS7/uyYWfDI5258weAsjUINmG1e8OgnlcBd/4AUB6uBSy43w7P/xGzPYAgjAOASRIuEi07CeVzrhNEI1HGdof1KHZ99h3A0lH1N5o0TtNxMYU13PmFtwJnH1Pl+eRS8tvo8HPJ2SCn+KnH3w0c+eOIPLt+1usig6HCwD689B+Af4hU9CqDthPkRpuOiw/hL4E/vUd7fUBdhG46Lt6b+zqKv3MjMJSO0vD9oF9ZtBOy7OvISdz0ZweAlVORNonIQp0gq3Dwni99B3DsK9o2Ff1w0VrU4P/M8z8GPPy7Wp0JqBLhNR0XH179JPB3H9K2J2xTOCH9H/bfAX/w9sQ+mstG7MJ+FNO/d71iy/I9Jq2uIr+XnMfrP3MTsPiiVocKdST5Pgro44f+9Q7guc9r2ySv7Yjy3J+d/xngnz+ZorOa0vxw93eBv/5xbXsAlWk3HRf35r8E3PcGVb63EpAIedG66bh4o/UMdv3BAaDT1LapJo3NhuNiKxp42+deC5x7Qtumsh+u7TQdFzY8/PihdwLf+Eykj9j1w2hHGjvnfxn40m+so/O3D/MHpfQBSunVlNIrKaWf4N99jFJ6P//3YUrpTkppmVI6TSm9fhT3fVmwbCntEw6YCXsYnOrZ7g9R1jl/nvYBgEnSRtNxQSmF35aMSmb+0sOczYWOqtlxcXf+G8BnfgSQTweV5Kdkhue42E74PZrHQ3lKAwObgBMZ5BeQ71wAzhxWdeD3kBeVmo6LCXQx0TsHnH1UKw+IFMUgGOQ7ey/Frx+JdmRmfi09AZw5kqjzbDZk8suOi9dkT7M+b0nZw24ToIxlTtmOlDJxcTU5DWvgABeejrQpdGyBfMfFDrKEnLuSqLMc7Sx32CCfcV4Czh5J11makPYMjjGdNe2Jyi932ASGc4+prxqVHKe8ttPsuLgldxbEWQSW50N5twO4rO116frNjov95CzsgQOc/4a2TSUqO7YB5sgKCv2luM68TUG00xsE5blbOy9q+kgiBUQtZrjCS+8jRmxCx3mDfRJYfA7orUntCeWnM6od3WCfBuktAw2JOEXSjWEZtosrrPOwB23g3OORNjH5ot8OjgdvtF1Moo1y77ymj1ibRLSz1mUEs9UbYnvvpbjdOWq080qVe27qHb4KlLRPO/i6ag+UtI+2QmM1LGaqkxaW2i4c10NpKL3cRXqAslOYzvTCUs+2izeTp4Dn/p6lPQQkA56UFjMbjottuQ77w1oYfcBtAwP2fcVvS2ynj0nC30ImRSvyPfJ8UUk4/7qQlya4aJtEvnmtywZ5yVvVXF9KaURy+DW02RpIgs6zGZXJz2U6cR2U66uMcJbvpFbkvWEQKciL1s22izppp/aRHO002i5q0Fw/0qYaZ/KiPLfsraXKT1lqPnuStAHqA63zWvlpW2XyWzKaNkk2qJACRWe5MC/UWV60bjp9TCLJjlibWLTDnkPTYZU5Gb+3jl10ggmm4biY8FvM7nyptLEdjXbC5zxtcZ1lW431aWhH28XYkXWWSESUOAXrdwk6FILy04E6dlLtgt2DrfdRFIZric8AUInT5cb4OP+EtE/FHgYHuyXn/M8COXb+/iQY819qSY4WUB6gPAjlQbvccTFlaQahMBZiqbngtostgSOUDX4hkC/67eBl2oETAVSDFBUUxAoWldZ6A7bBK8mxcXmAM//uAA2njxwGyHpd1mY5LdNeDOSnM93g2OWm42LC50xNHrROqAOr3gkH4XTQR3qdJ6Dm8Lfluvz6kg681hrECqKdNp/wAscWnfA0OjcdV5pQNROkkOfPjZXnUhSHq4yF9ySCIPXRXLanRHg1aO4h9ZFcjdNou5i1dRPkYiBfUaqD+tiWFSRCun6fkwhiIS9FO6odpfQRZ+bpk8VipI+GQXluyVtljjgaNXP52WxXsYu6to9CnWtEtaO5dcZOSVq0bjguZux2vI98j9kSsZRoJ3WycCI691ifVtGBRT1g7RyLQDQ61yKLypcT4+P8E9M+G8j5r50Ftt4AAKiTNhrtPhbb/ZBNZYoR578E5KtAocYqTaQF38BgViTnLwb55D5lX0DTcTFj69gOl6/viaVxtmoHOau1Rn0PgDDcbUQdm5KWWQzlScjw6qL9oGpapn0xkBdMvt1nKbWSx51/lMnbOaCyVanGaSqOR54gQ50rVI4s+noWLBxKfU/o2LjOwSBXIgVWax3q7ITRkdC5dU59FWh7QepT5ngabRcVdGHRob5N9d0AWETY6g2D8tyyto+Ezru5U5AWSy2NDpLOJd8JFq0bjhs6/wR5OdpptiWdoyRC0rnG04GNtvTMeitsUlF0ZvLiOTfbLJUmnksseqlsATIFTEl20XD6mKBCXkOc6nvUNQU5UkjQWV60bsokYjVCIqgP1PcEaztrvWFk7GiYv2QXYZTN+8Vz1epASX4usm/ncmKMnH8k7ZNhL6moSGmflo75U8oe7hbm/CfRQkMwfzFAZq+OOP9FoDwL5GvBTkiRL69qDXgBAAGmr0SFtiFX+2gHuZgsZq4OFpUEY9uW1RiwYIQzVwOQGJs8yOW0jIgUhDyvclAMHoiz1OkrAWIF1ThNx4UFXz/I24tAeQ4oTirRjjLIdZHCzNUo+e3gZdpNxw0O0NOy5pmrgw1DItoJB7ksv6T2kXBs8mREfaB9Qb0Hl5/ki9bKII/dYxGY2A7kJoJFblGeW/R4hLAWcf6FOlCeU87qUSKFhD6Sd1o3HRezOhbsqHYxIekckIjWuTAt028xEhHYEbOLmM5rkXtw+Tm+96Dh9MNUGhCf8MqzQKHO+rQ7DMpzgwkySoTsHDC5h0U7XU0KNNoernOUFGxJSzcqY4fZ0ZSYXLpNtt4CMHLQaap9JKIpSGNHfs5SH0V3Wl9OjI/zt7PqJq8y20dQsZjz7w9ZKBrL+XeXWWg8tQ/ITWA246DRdrHU7mOStEGtLDB1hZrzDwy4hio6aPcHaPV5vtznBrASYS+laaA0jaLXDl4v13Rc1HSOUEw0M/uDRSXB2GYFC26dD1mqE8oD4aKSMsjle4haay4/k+kGzH8yaZC3F4HKViBfxaTdCwZUDW0QsecvxvDmgEItiHbCQb4al28vsAm7thMFj/VJuz9Uo6loeySdZQYWDPL+arh4GOkjUXXRlCdguU1Dl9kGl9+SZem9hiORAiDuzLnOdStsTx4usvx48dgEVtkCFGrB8QiiPHfCT5hQAWD6Kr62gyB1NSWeW7Q9MZ0HagTpD0M5R9enGscmiI2IFBQ7GqqptJgOoc5ipzUrVeX58lgfcRJRqCvRTrOdRrSYDkq04/TVtI9Iy0T7CGFEGKwpACyVAwCdJQA0kK/zqqsm9xeJOtd3sWjH7pqc/8hhZdQ6/9I0AKBkuXA9H06fsZtY2kc8pOoOoDSJLZkOmk4fiyLnX5pixhpN+1Rm+aDtBI4ZAMsFA8CqVJbYXuROoR6kcVa6Lla6A1TEIF87F6ZlRKQwdQVrGk/jLHekfLm8eBiwFzHIQ8a2TXb+YlBFHOdsthcw+brs2MSgErXWXOdJcf122mRxMXCEYtE6GOQD0UeRCa88BxTrUrTDFtKqkPpIsFSdzl2R9pFYp2hTOz5BCsepDHJhD8IRTl0BgGCan7G0vK5j484/aE8/0qd6+TJftG44LnyKsNggylKLU0B5WjkeoSEvTnaXw7RnpI+YzkOeL9cw84j8lNWR5DV21FsFvD4wsQ3IVdhOa/4MFJ2jzJzrLBztcodVpYWptAhx4nYnFq2bHVaQUfE1k0X7ImDngRrblyqv7UwRrrPncieO2IRX4zl8hUTIbYr00Vw2jAgndREhPx+KTWA1ZdH6cmN8nT9n/mXiYuD5QUVOpRDZZSkMs7YLKE5h2nbQcFwstpnBk9I0M9b+GsB3DMMRzL+KMm0HA9CGh9yAG2SU+XODF8cjnGp0QClQ9NZYymrY44uY/Po8UgDEOS7yoOL7CIJBG0n7SFUabNAK+YgBT+4FrAxbtO4LgxdOgUiDnNdac8amXyMgmrQPH7R80Xqh1UMZPdh0GJeXJhcR7Sy2+2yQe2tMnnpAi6dlnEUgW2KTNsKqi5AFR/soTJkAwHSmg1af5fAZC47Ii0hhYitQqLJzXwJWK+vM+0hs2IpEOzH5KDPnfSRIwammAws+nwCJungoRVPiOa/yCYlFCkKHs2EfgQBTVzJ5EjL5GcsJ5df0fSR2WjflqjT5uQnHGUx4SX3E5UWkUBbEqR1EkMHkBRKPgrnjFGmckw1mo8Uht4vOkjQ2+eRSrHOdnWB8sig7YSxMxyNIFmWLPooQp2k12mms20ezUrRjmP9oIdI+vs+dPzu1s2QN0B/6waakROZf2wGUpjGFNhptl72+0XI405pjMu2FMOcnHJvHFpXOrXTDPCexVfYihfcAOx5hvtFBBkPkhm1g7jq1Le1FRb7Kq1+WHZfly3lEEBrkRXbPyX0AgFmek284LqbtNluEtLKhvHBs/B4iFGWDnA+i6avijJDrXKGcQXYkFjx9Veh0RK11ZQtQrAdpnPmlTugUpq9S0zLthYjOjjTIV5m80kcXg9wxIHYRD8J8uU4ekAZtP6jembU7wRpOLFLgbapb3cBRbdf1kejTsmDyzLEpkYIsL+ssRTvzS50wlTZ9FStiENcOIoXQsZ1b6WLoU5YvD3SWHJtEIsTazrLI4cf6iN9n6koAhO89kFJp2TJj+bLdAYHzr/Ey5mW5PFfWmZ8PJfpUpHGU9TVhR3IUzJ25iHbmlzqs9NTrhjqItIxEtJjOHTQcFiFVfLmPpOecKQI1djhk3QqjlyniBJFfzI6qLNoR+3aWOyLKJiyFvBaR5zpPEFPnP3oI5j/sAqCh8ycs5y+Y/0R0wXf1DHOM5TmgNIUqWmg4/SDnj9Ike3AAM5Ruk1+fOcK8x4z8VLMTDvLZaxiLdx2V7RRDRzW/5IRlmFtvZP+XBxVnCkzewRl5kAt5McidBaZvcZLdnjO2ZZEvL88wY41GCjyXWpciiy3ZDhsM01dpHCEbhOKUS1atxNnOtpvCmm5Ra80HYXbogMDHySZzbIG8ovOC4sxrxMF8o4Mshsh6HUleclQyw0MHy8EgbwFbDrDyOpmB5SqsL6yMwtimLIel92o74o6Qt6lG2mHFlXD+W2+Q2iOx4GIdRd9Bx/Ww2JIWP7fdxNMyHcZU3VYs2jnZ7KBOJHlho0Efhc6/BtZHAEV+uKrpU5UFT0mL1oxE7GN9siqRAmKxPipU+dHX4jnLfXQ6bI9kRxM0ZNnBBLntJn2kwEkBpcDp5W64oLztJpZKcpYkEqE6c2ZH0T4SbVpU+qhKOjjVZDZa9NbifeossmfA+0gcDx7sX5nYyu6vneTrQc6/0XYxm+my69R3J441RpyM8x8thPMX+U6e9imSPnP+vBwzxvzXzgLV7YBlAcUpVLw1NB3G/Ku0xZh/hR9C5yxEnEItqA0+2XDCFMi217D/r54JyzAlVluDgxMNJwx1A2cuDcKy6tjml5hehcEqWzwq1NUcfmUOyBbCRSU+aKvgOtR2SfI8UihORlIUPNqJOsJg0G4Jop3+0MeF1R52BI7wxrCmW54sCrWghG5+yQmZv6yz77HQPRLtsAlSIy/aJMlPZ7rcEfJ0QHmWVd7Ik0tljh0CWKhh0uqqkUJxirG/6CAX6xY0TJnM2Q67b31PmJaJyAfRTqMTrinIk3wksmA6O6yPELUL2VFJ8pxElNCH7Q+AuQNQUlGRNNFstofzKz24ns9YsNBZnlDLs6xsOrJoPUnazF5qOyNppVAHkQJtOi625DpsTM5ey9MyvVikwI6QoJhfcngaSu6jM2yipB6/fhjtMDtKGTvKZMHkLfgsJTt1JSM3CtHawvf5EEzbPSx3XKx0Bpiga6HO8oSaLQP5irJoHexfCewoGmXPKdEOlcuuLxPGx/mLtI/Y3VtizL8IVucfOH8d8+chH0pTKHgt+N4Q51Y7KPur4YIvwAxFZi/5auDYTjY6YbndtpvZ/1dOqYxQGrQnG04Y6s7sZ+Vsa2d4pBAuEAOshO5kw0EBfdh+P+6o2hfD1BRP41xYZYO87PFF6+oO1bFV5tiEV6gFx/cGC7jC4EVNt5L2qaPAS/JONhw2yIkNzIrU1VlJXtaZpXFmrIgzXzsT1lpX4vIBI6zvYXsrommffBUA2zB0ssEijPxADNodiX1UtxysdAZskPstJl/doU4W+SqQLYb5aZ4amxbpwNrOsKY7onNOIgXb5AkSYCxVYc2cFER1licLcT6UHBFC2BF3hJUtjKlGdc6WWLRjd4NUWmGwGrcLEVnwPhKL4g2nz/Llch9RGiMRwrEttvosIko4oAEAACAASURBVBR2JHSI6GzRIYt2Gg6256N9dCaWbgQYcTrZkEgEL9EOos5IpDBlsT6qwmGptFiExyMFywIKVUxnOjjNI4XScE3TRxdDMigtWgfrX8VJoLoTwSbJyIQXPR78cmJ8nL+VZflEwfwLVcDOoYg+XMn5x0o9V8+GBlqcAgDU0UaFdmFTj+f8+cNuL4bOvzyrOPPTzQ52CANWnL/68AHBRqQ0UWmaRR+rZ3mtdTeYXADGak8sSZNFKcLYhMEDnI04OLEk5cvFIBQ13YLhcfmS3w7WCBgL5gYMhIPWygaDXJTQnVhyWG63OMmiEYA5Nic+4dXQwYklJ+yjOSktE4mmWB91uM68j2TH4w3YuktlSxDtTNusj6rogMDXMPnFyKDtBI6w7K2y9F5tJ0/XdSJ9VEfRc9AdeFhY67GITXFsZ2KTvCAFJ5YctoieKaj55oARxnUOKrSmrmAsU+kjybHZTD6YLAKWGiERItrh8kEqLZggZdYc6jyBDi6u9dAb+CyVVuIRpChOCCIFS4l2TjYcTBOJBQOqDpGxcGLJCUtPhTNX+kglTieWnLC0dWIr65PV08wmqK/00Wy2x+wo6CMNcZLsos6vH1SlydGO2B8jyCAnBas851+lrXBsik2S7UUWVXASIe/budwYI+efYY5NOP9cGcgUkSeukvNXDnbzPZ724S8mK3HnT9phSqY0xaKK4pTK/MszgYFNoIPza71w0M5dy9qzejqyuMqY/CR/AUyQFy1OMWe7ekYNpe0MkKsEC2/BZFGU2IhgYIHzrwe7UTMYIjsUg3BHWNPdVg246LNzyftDng4oyYP2dCxlInRe6w3ZIBTsCOCThTzhheH6Wm+IrWKTWnmWLR7KkYLUR0LnYBenaNPqab5hiyqDlqVxpD4SbRJpGRHe8z4Kj++lyA9WVUe1di7WR8KxrfWGqPotVWfBUgs1IJNXHFWgQ3GKpaHE4qFGZ9FHAQsuSixVkyaazfa5zhIpEHYhkwiuQ533UV2eUGu7mI0O+zGdWTUOGzeMRPD2BDovKNfPBccjDBmJiNqFw0lEoR7rozm7wxbc+e5fJTqS+4jb3Y5YH0XsLlcGiB0cRRKQiBIfa2tnefFGQ9FZVOOU0YNFB6FdiE2SMeLE9x5QsOMslD46q47NYl3Zt3O5MT7O386oaZ9cBcgWUaBhzp8QoCSfF96+yHKK4mHxBdNJtEKWzaMBVLYw43UWJQNmzLwKVrY5l+F5zkKdGf2KPryfybINP0E6QISiSmgssRGLTSoqw9vBjLF1gaUepHC9TJnDDBaUBWMDwglGMkhxoBXA8+VRA3YWlMkFYIMWAFsUK04x3XKV0CnY+eAIDNFHAFj5XL7KJtTqjsRIYZb3UdwRnlUnVN4m0UfKc6vtZIuHrfOsr6Q+KvlMrog+bN+NOPPTKgsu1pH1WHUWAJTlfLnSR2F7mM6s/yfFBJnJMRk5UohEOwC3I8Ly7oEzlyOFINph8kF5rpxvdqSFRt4mpT2AZtKORzsAQOCzt1BFJzzZLor1INoBEK4pKBPkohQpqH00ZfHiCkLCCE8TEU5ynQOiJU94cqRACFCsY8pi7Zm0ZLvYwcZN6zyC4g2u88RG+kg8Z6mSDeATpJhcgj5So3Kh8yuxy3d8nH807ZMrA9kCcmCbvFr8XB/l1Xsi3BWOkTP/SdJWHz7ABl17ITRgiQVXeXUGY3jcgOu7OXvhedHSFHOOxMJMhjk2Nllk2feCpYqNW0oahxnw1oxk8KLN5/i5/hHGBiCMXkTKBAgZlTS5iBI6gCIncsET2xDUXEdywUDoqCZEpEBIGE47arpB6SOxpgCEC2nyIOfRzrTNdA4WS8Wg6iyF5/pLbZrg7QkGuRy9nH8ifIZcvsidf2yyABJ1FvcI8uXFSZZPXzsb5o7lPuITZFXkywF1AitOsklQinYAYFa2o1gfqWs7AEIWLHQedoHF52M6B32EiCMEgIXn2EQp2Z1wbFV0QKhIpe2S+ihZZ5Yvn2QTVXk2jHak9sjydbHoHu0jO8dkpWgH4GMnU2TplNquxD4SpGBHju+wFuk90PD4a0nnkDhJUbawi+V5VsmmiXayGCIz7Kh9unYmNtaEzq9EuecYOf8MC+MU519CXmL+8Xw/Lw8TjlHk/ElbffgAc64i7RMx4GBQEdmAd4XMX1RQ8NyoYGxB+RwhzGCoB1x8OrwfoLARhQWLNouXukhtKgwjjq0kGeTFZ8Jaa0mHKjrhqYRFnuqa2CaF96rONe7Mg1BX9GMwyFWnMMcnvLpgwYAarmeKQH4i+I0YtHN2h0UR2VI4CM/FnfkEn/CC6iN5wjsbnyBFtKMyvO3s383jbLE72keko6bSBEsVk3y0j/hzC1JpQDhBKmmocNEa4BOYLN++yHPUJChhFikKAGG+fB2dy3w3eXBEiEwiNPIi2lFSaeUZ9jxWTkUiwpDVslTaStwuIvlyuY8mRL4c4JVpZ0KWTQibROx8UFo8LarSAGZHbhtYeonrELZJkJRgA5Y8dsS5/tJYK3kau4janeTMRbQT+IvSJPM9xUnNc5aY/ytwxMP4OH87UuqZqwCZAnP+no9WbxCv9Al294bVPgBj2FNWhPmX5/iCrzST53kahzu2CSoN2vpuxuLXzoZOAQgWlQBuYPJkAbBBSKxgYw4rM2Q6bZVD3cAgHwvbBwDFOvIeW1SaldMBhTrrkyBSiKZxHNSi0U5tBx/ki1oDBoC8yxdLRT9GGWG+CrFhCOCRgqyz1wcWnmV9JKIyqY+m7bY6Qep0ltI425VU2i69vLRhqC6vo2TyTM/AKUQYGzpqKk3oLNIssclCXnQXjnBnPMVis+hvymZ2VFNYsBS9iPUnfg/BmmdtKZWWZBe8RBcAdiokYntEPkx1AYzYKJGCeA4Lz7J0Y9T5k46aShM6xCIFdv1pbhflKIloX2C/KUtjp8gOgwOiREvSOVNQSIQgTlvkVFrMLsLnLF7NqKzHledYhK6JsoXOyoKyaFNAItQ+qr1CG73Gx/kHaR+R82fMP0v7oBRY6Qz0u3tzleChIFcB7By25jr84ZPASFGZY4s+y/OSsYTVOICU5wR49QtljkQYC8AYG2e1NZntyGykNM0iBS4vHNuM3WHVH5k8H7REw17CDUM75XSAYKlno84/ZGCxdY7aTuDCUywiKUcNmO2yDEpPhbyzCKyeCq/PS+hEiqLsa3Q++1isj8TkUidOfJCffSystebyIo0zl+2wyTNf43n2QqLOVXSwPUgHSG3SsGCmszRBymmcxlG2nyMS3s/YPZYvF2kiocOgAyy+ENN5kttFZYN9JKKdSaujptKEvNiwxeWFY9siT5DZIiuLTtC5Sjrhqaob6SNImxfl57ZyOhIpsLEjiFN+EImOqA+cfzKmsyAFjGhxnauSziLdyOVFCnRGVKXJJEKjQ87rwIankgjLYuMt0Y6k/SglaZIPItQI0cIrc8TDGDl/seDrMKPPFFjO32c5wuWOGz/XZ/UMM2RhLIQAxSnM2Q7b6VqosYgCCB9gd1llbNlywNgKQ5kF75Lk58J78p2QgJgsJCcCqOkGAKI2GADbRCKMy86yMrfuclhrzeUBZpBKqAuEtfuANlc7qxvkQl5a2APYgqxShimuD7ADvyqyzqzSBEBYPqfIr8T6qMwdSFU3QcpsirdJbBiasRw2yCwrzJlHdZCinbBqRGpTrI/CxUmlagRgzzm4Pn9uItrJ9jCBbpgvByLPWe2jmpwvL0bsqLeisuBCPSAFdUh9VOJpmd6KSiKKdWT8PvJw1VSaaFOsj8IJcmesjySdpcVS0aeTRGMXA4efD8Wvz6OdaburptJifaRGzSLaKStjJ9mORLQzKa81ibRMb4X1gSARUrSzRU6liXsk2lEnLN7YgB3J77S+nBgf529nw1LPXIXnCYvIUub8m46r5vy9AQtdheEIlKZw45SP187QcEAB6kBVBmEVdc5q8+5K+PBF3Xv0t9KiUlAdADDDyJY11w8XleqQFg6B0BmKDVtcHuDOPNNlC2Y5fl0xqOQ2SWxESQcAat8Ieb5haNruxhfFq9L1y3HHZsNDdrCWcH1VZ+HYKp40WWTyYd9E+tSiQxTRDytron0kaq3lPkInPLkxrU1Sn26P9lFV06dStFOP9ZF0/bLesbF8uWC12+PX5/Ii2mGb1KbCe4vfRJ4BAEygG5IIQXpEm4gdXkdKXW0T0VGUqMht4vLTdk8tz432UUTnSbsbT6UpfaTqUJHHTrAeN8fIn6aPRLRTkydI+R6R9jCdO2oqLaZDnPnviI0dXR/xaIefonu5MT7O38qEaR/h7DJFZPg56svRtM8XP8pycq/9UfU6xSlszXJHWJSdv8TGo6yWdFBAH5YnpUCqOxGcCBhh8syx8coaIS+HoxF5AooKeuqiGBA6Ko0B1+Dw7eaT4SAXLNIKK0zklIZSeipfX24Tr+CZyvTC46XTJgsgWLSuRQd5aTp46U482mHXLogSw6jOlbhjq6Kj5stlnXXyYpDnKqwMM6pDZJDPZqTjLLR9pN5j0upI0VFKn3L5CnVYKs3rhdfPlcL1n4i8iHZK3uoG+khm5u1IH0l2FCUR6LBSUhKWZ2p1kNZ2dhaijnBXXJ7fo0Y6alUaEHGcCWPHlXS27HDCizwDEe1UvDW9zpHrM50dtuYnEy0hn5tgz0SWJx11PS6msxTtZMv81a+G+Y8OctpHOP9sERme9vF8Gi74Pv03wCO/B7z+p4Hr361epzTJdgp2m+qAkhmIyKMCECV0k9GcXybH0jJAzCALwxbbROIPEpi8usgFMIMsJxpwwiBHZJCL62sG+Uy2Hx7/LNZA0hgbcbAjr8mXC1SijK2tblIDwnUIzfVzwzY7j8VdSdAh7sxrxFErawBpQo33US0Y5Jrr52uswgQINgzNZKRBrnPmsWjHiTuF8iybfDVtKvmt+GSh6Kz2kTgeoSCTCLlNmgmvBicszw3kNXYnHbA3bUupNCBkzWJPC8D+lq9iOtPF9mx0gky2iyqk3bpCPj8R2mCkTSWvxUtPvUgfiQlMTwqK3kbsQlrboe0N9JGIdjiJkFNpSVFwsc7P9P82Yf6EkLsIIS8QQo4SQj6i+XueEPIZ/vdHCCF7R3HflwU7yxYm+23V+Ys3KAGM+S88D/zdzwK73gDc+Zvx6xSnmOPvLKvGVZ4JXsKsDMJ8FRXqxB0boGedxToyfg+7s2vss87AdAZMOmq+HEhlL9N2l23AWs+AeQndtlyXOapCLcwTi/aLWmvpHpN2F3tLIh0wFV6Ln6mktqmOEpWOLSjJOiRHO1vRZC/4UHROYfJweL5c4zg18jOZLt+hrOtTSZ5HO3NZ/opIKxvaWOIEWUeddLGvxMhHoINlJTqeotcOX5qiZfLx5zxFWjyVlpAOjMjXSIevNdU3dP1teemwv0BeslPLUn4zk+liR5T5V7YkpmWqcHBF2eXyuucciXa8dngI3AYn+Spx1JQskNpHU1aXH4ioaY88Nnm0sy3P35shp9JqGhLB7yGOvr7cuGTnTwixAdwH4G4ABwB8gBByICL2kwCWKaVXAfjPAH7rUu/7siHYVG+VhfEAkC3C9kPnP1HIAH//8yxs+4E/DvN5MkpTbMt3p6Eal2WH4XfEOU8QB9dPeuHvBeo6A2YG+bkfUvcWAAjZi2YQ/pd7diPjRsJ7LSNk1/+l79yGLVln/QHF7/GO/SUcnIusc4iablFrLclfXfPwwzdNxHVOSEVVaBuf/L7dcZ1TnPmn3junuX7yoP2/37mXL7rr2hOX/5nbZ7Gr2FufNfPffOeeHN6y01YHea7Efl+cDFNHXH5XaYCfum0yrnMCS80N2/jd9+j6SLQpzjr//Pv5s9ygzv/xrl0sfbhee3i082O3TGL/hJswoUrt4fe4dauNu67Iqak0y2ZHW9i5MFLg8ltyffzSd8zEdU6I8Cw6xJ+8d1tcPiXa+YP37IIlp9IAvTPn8r/29u3h2UQxnSV5Hu2890AFN01FIpGJbYwsavrompqPj9x1LS43RsH8bwNwlFJ6nFLqAvg0gHdFZN4F4E/5vz8L4O1E2Ur7CkCw1d6KxPxLsPwBLLA3IVXyGWDpReC6e9SFNBnFKVaVMHDUhwmETjOS9qmSLn7rHbvC3wvU+UDW5OQLLb5LdYOh5TX5ZXYq4bp5S7FhqAeruxyZLDQLgQBQZOeMx1IshLDflKMGXEfWbbEzbkTpqdwmudaa60BcB9tsTbSjm8A4K91n8R2b6zoFJr8n3wYZdKCPjiR5Hu1M213YvUgfiZruqM7FOkpeG4XBStwuajvifVqoI+Ou8XQgiTBtoYNqRwQUO8GPZdD2kRpBAgl9lJIO3Fnsg0TtQmd3PNqpWx1k+hH5QpUxWo0dFYbtePQl7iF2xkttsvqr8QXipDbxsbAbF+PyKX10ha3ro+RU19ZcWh9FdWZp36y7osrbWaCyVWMXLNp5/RXTuNzIrC+yLnYAkF5LhTMAXp8kQykdEkJWAUwDWJKFCCH3ArgXAHbv3j2CpkmwZeYvFnxZuFWAiw4KqOQtXgI3lXARqH+T0wEAM16xJV+gUAXprYJ0m+yz7Hhe88PMYOXvBPNpHufy0v12vQGYuSY82RAI0y1CXm7f7DXAnjcDe98UfsdL6NBdYWsX8vWzReDAu4Gr3qbqVaixfusux437hu8P85gx+Wa8L695B/t7JFIAwPZIRHW+8m3AqYfVBbJA/kRc512vB3a8DtjxWkm+niw/uRfY9xZg73fodYj2kWUBN/0gsOdNenk7G9f5wLvYefU6+W5TTaUBwNV3sQ1Sih1FdJbbdMV3AbvfCExfmSwv2+r2W4AdB4Fdt8XlV88wchNlqVfdwe6j06GzDGy5Uf3bje8L30AnyzdPcLuIjJ3r3qm+xUzI99dYlC2OOfn/2zv7YLnq8o5/nvuW3RtKXiBEIAaixggiDfRKw0szDglWlAFbXyq+RRHpjDJS29LSocPYTv9opx3fRnQmA7apY9GKjqbUQTE4U/8RDeooGpQIsUZTAiS5vOUmueTpH7/zu/fs2bO7v9/unt2bc57PzM7d3fvsOc/v7Xue33PO+R3P2tfC0/vmVrbNLXO6DGs2wqpXN/rUrh+tfCWsughWXzL/XTLb4fmn3FPm0tuvLYV1b3D9NVsG349WrGv836velCv+7N/FIOiH+OdF8NknEYTYoKpbga0AU1NT/X2agU/7HD7UkPMHqHOE56mxZGTG3TxSX9ZiIzQ2eDZ6OfPCRlED15jHZ+c7drqDnboWLvtwsz24QZK1X/FyuPF7+fZ5wjmxGN77381lqC1x64ocP9YsVG/dlm///FNu0K7ITEc33ZZvP3PIHSzSES3ABe9wrzTe5sBjLvebnhWcdTG8557m7Xt7aI7Y3n9/xv7kjH2qfccWwZb/ai5DfakbsDPTzf3hjZ9utq8tcWsvjYzNP0bTs/HmfPujz7ib3rJtcN4fu1fWn1ZlOGM9XHdvZvtZ+0y67v07Gu2T2U5uvxsZhXd+ubkM9aVuPB0+2FxHV3202d73i4nJZvuLP5hvr8fdXeTpVBrAuivdK+sP5NfRinVw/beat9/KvrYErr+v0d6vReXHWrqORODa/8gpQ5s6eu0/5Nv76/8Lph/ivxdIhWWsAn7bwmaviIwBS4ADfdh3OD6ymj3ckPMHqMtRUOYfIdhO/Bsi/8ygbSWE4DpMNgWSR1P00sYXSJaQkPzopd0+8g4W7ewPPOoivNDtz8645StCtw+uDOlLT0PsobNPySV0uRFhu30c+hWg4WWemQYEVk2F2YNrh9g6Gp9sPEnYyR4i+kVkHT2336VAs5F8K/uZaTfjTs/k2tlD0i8i6yibSutoT/g+Yu0PPJo/C25lP/O0W2Z8pNiLMfux9e8Da0VkjYhMAG8DtmdstgNbkvdvBu7XQTynLE16Cp2J/N2KlcndotC+USdPyX/fCj8tPfhYWOP7DntwT+NNJK1ITirlRi+tqC2BA3vi7J970kWqMYPwwJ7wDu/tY7cPjScJ2/3G24f6NFdHgfaHD7lBvhDrKFioEvui6ujos/mznVb2EFFHPvLf05xKy2Os5k4yd1vm0APe9G+aU2nt7FE31gqmZ/FX1VngRuAbwC7gP1X1pyLy9yJydWJ2J3CKiOwG/hxouhy0cEZyxH9sPu0DzK1q2HXaJ49aSsxDhRZc5Bxi73/jp4qhg+TIdKS9Pxkb4JP3O5sXbbn9JfP2If742c6Raffb0YAJbD1V5lCfYuvohSMuVx9zkO+qjgLawM92jkw3p9La+VR0HYHrSyHbb6ijiLET2o9EGsdCqE9RdRQ71pIyzEx3tu2RfqR9UNWvA1/PfHdb6v0M8JZ+7KtrRlJFzaR9aknkv/iFEPFfijuFEZEOAJfze9H5ne19NBIqIn4f08wvWBbqE8QJTzf2MaIQun0/2wkVzkH4tNDqyO/DX5UWcnHdIOsoZux0Yx9TR8/tD0ulDcKnAYp/de7wTUeH2RO+4sR/0bEkem4n/iPJsq/+QRGdqKWuRoiJRiBe2NJ3WYbYh/o0qA4PYVFt+jcxB0iIaLdIn9JCWEQdJTcMBW8/vY9YewhPpXmK7hch9n62E+pPeh/dBBFFHPD8bOdw8Sd9qyP+eWmfVORfHx9ldG4616HjTy7vbkDFdrBBDPKY6XQ39iE++UvoIL6OYlJjof6k7UN96qlOA4TWz3ZC/UnvI7aOFgWm0gqf7UTWafo30WMtcvuhqTSL/BcAeWmfuZz/Ubeuz+GDbmGmTidZ68uLSzekfxPa4etdzhRCTiin7UP3EWufepxj4RFbrL1/wEeofeg+eukXRddRsBAOYrYTsf30PgrvRwFXpaXtQ3060XL+JwTtrvaRZDnnvGtx8zj/T1xOPoR0Dr9ooQrt8HMHi8iDS+g+GnLBERHV4QPxPgUPcl/mgCjb++PtQwZ5bB1NnOQOLNkFyDr5NE0XdRQp5rH9bqwWlkpL11HQbGfUzUK6ObcTHTgVVEfpcsak0kz8+8hIm5w/R+Yj/5BO+fs3hO9XxEUwzz8ZL86FR3iRwplelbAd/oahF47ElfkgC/AAWVAqzc92Qq//7sWnhVhHMX079OqdBp+KSgd2OTZDU2n+SjZL+/SRNlf7TEqyln9o5B9Lt7nXos8RdDNAQpdkGlROfsEcICNTaYP0aaHU0cRJ7oq00KvSBuHToNKHobMvf25nAHf5Vkf889I+Sc5/8cjRAYl/wSehijq4xJ5o9PtIP+Cj3z4VfnCJjGp9ei+m/yxYoSqoDfxsp74s/O7VhXYA63psRo4dS/v0kbyrfUZGYHQRJ3HMpX0eL0r8E/EsSniKnrqOTbh0T6i99yn00lNvH+PTQhMFL2yxdRSaSuvGp6IPeLHb978ZCZwZpfdR9AyyqAOqP7cTW0cm/n0kfat3erCN11m9WBhbtQQeXiBpn7nn0K5sbze3/YJzwX4fMXVTXxrZ4Qd04q2oqNb7FFOnvo6CU2kLrI7G6+7gFduPOq1vlfUpKpUWOxYiyxxbR3OzHRP/4eE7z/hk5kBQZ9NLfwd+71T45mxx4h+TAjnvTW51yvTj7dpxxnq3PPTZl4X7c/nfuuWbQ3nNX7vlj0O56E/dSqChnP9WV/ehwvCyzXDxjW7p3RBOO9fZv+yKMPvRcdj8EXjppjB7gI1/GTfIp65rXgK4Ha/8I0DD++iajbDhA26J6xCWnQ2X3uSW3Q5l80cal4buxKU3hQs5uGdon74+3P6cq9xJ9JMDx87qDe5xrWdd0tkWXEC28Wb3zI9QLr8VVpzT2c6zZqO7M7tgZNDrq4UyNTWlO3fu7N8Gn/gF3P5qF1XfvHv++09e4AbHptvg46+Cqz8FF76rf/sF+NFd8LOvwtu/2N/tGoZhZBCRB1W149Ky1Yn8fbTv8/2esTocO+xO9kIxkf/6a93LMAxjgVC9q33STwMCl7csWvwNwzAWGNURf3+FQTbyN/E3DKOCVEj8kwxXnvjPmvgbhlEtqiP+oy3Ef6yWifwDr8gxDMM4gamO+I+0yvlPzot/6FrvhmEYJzgVEv9WaZ9U5G8pH8MwKkJ1xH+01QlfH/kfMvE3DKMyVEf8R0bh5VfC6sydfGO1+RO+Jv6GYVSE6tzkBfD2LzR/Nz4Jx2fh2f2wYt3gfTIMwxgCPUX+IrJcRO4TkUeSv7mhs4jcKyKHROSeXvZXCP4E7zP7LPI3DKMy9Jr2uQXYoaprgR3J5zz+Gejzgjl9Yrzm/h59Nm4VSsMwjBOYXsX/GmBb8n4bkLtMpKruAJ7pcV/FkF7e2SJ/wzAqQq/iv1JV9wEkf0/r3aUBM1abf2/ibxhGReh4wldEvgW8KOdft/bbGRG5AbgBYPXq1f3efD4W+RuGUUE6ir+qbm71PxF5XEROV9V9InI6sL8XZ1R1K7AV3Hr+vWwrmHGL/A3DqB69pn22A1uS91uAr/W4vcFjkb9hGBWkV/H/R+AKEXkEuCL5jIhMicgd3khEvgN8CdgkIntF5A973G//sJy/YRgVpKebvFT1KaDpIaequhO4PvX5D3rZT6FY5G8YRgWpzvIOrfA5/9GJxgOBYRhGiTHx94JfXwYiw/XFMAxjQJj4+5y/pXwMw6gQJv4m/oZhVBAT/5ERdwAw8TcMo0KY+INb2bNmz+41DKM6VGs9/1Zsug1WnjdsLwzDMAaGiT/A1HXD9sAwDGOgWNrHMAyjgpj4G4ZhVBATf8MwjApi4m8YhlFBTPwNwzAqiIm/YRhGBTHxNwzDqCAm/oZhGBVEVAfzqNxYROQJ4Fc9bOJU4Mk+uXOiULUyV628YGWuCr2U+SxVXdHJaMGKf6+IyE5VnRq2H4OkamWuWnnBylwVBlFmS/sYhmFUEBN/wzCMClJm8d86bAeGQNXKXLXygpW5KhRe5tLm/A3DMIzWlDnyNwzDMFpQOvEXkdeJyM9FV+ya6wAAA3dJREFUZLeI3DJsf4pARF4sIt8WkV0i8lMRuSn5frmI3CcijyR/S/dsShEZFZEfisg9yec1IvJAUuYvisjEsH3sJyKyVETuFpGHk/a+uOztLCIfTvr1QyJyl4jUytbOIvJZEdkvIg+lvsttV3F8MtG0H4vIhf3woVTiLyKjwO3AlcC5wLUicu5wvSqEWeAvVPUcYAPwwaSctwA7VHUtsCP5XDZuAnalPv8T8LGkzAeB9w3Fq+L4BHCvqr4C+F1c2UvbziJyJvAhYEpVzwNGgbdRvnb+N+B1me9ateuVwNrkdQPwmX44UCrxBy4Cdqvqo6p6FPgCcM2Qfeo7qrpPVX+QvH8GJwhn4sq6LTHbBrxxOB4Wg4isAt4A3JF8FuBy4O7EpFRlFpGTgY3AnQCqelRVD1HydsY9YbAuImPAJLCPkrWzqv4PcCDzdat2vQb4d3V8F1gqIqf36kPZxP9M4Nepz3uT70qLiJwNXAA8AKxU1X3gDhDAacPzrBA+DvwVcDz5fApwSFVnk89la++XAE8A/5qkuu4QkcWUuJ1V9TfAvwD/ixP9aeBByt3OnlbtWoiulU38Jee70l7OJCInAV8G/kxVnx62P0UiIlcB+1X1wfTXOaZlau8x4ELgM6p6AfAcJUrx5JHkua8B1gBnAItxaY8sZWrnThTSz8sm/nuBF6c+rwJ+OyRfCkVExnHC/3lV/Ury9eN+Opj83T8s/wrgUuBqEdmDS+ddjpsJLE3SA1C+9t4L7FXVB5LPd+MOBmVu583AY6r6hKoeA74CXEK529nTql0L0bWyif/3gbXJlQETuBNF24fsU99Jct13ArtU9aOpf20HtiTvtwBfG7RvRaGqf6Oqq1T1bFy73q+q7wC+Dbw5MStbmf8P+LWIrEu+2gT8jBK3My7ds0FEJpN+7stc2nZO0apdtwPvTq762QBM+/RQT6hqqV7A64FfAL8Ebh22PwWV8TLctO/HwI+S1+txOfAdwCPJ3+XD9rWg8r8GuCd5/xLge8Bu4EvAomH71+eyrgd2Jm39VWBZ2dsZ+DvgYeAh4HPAorK1M3AX7pzGMVxk/75W7YpL+9yeaNpPcFdC9eyD3eFrGIZRQcqW9jEMwzACMPE3DMOoICb+hmEYFcTE3zAMo4KY+BuGYVQQE3/DMIwKYuJvGIZRQUz8DcMwKsj/A0qKjJwYsaZhAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "n_models = 4\n", + "models = [make_model() for _ in range(n_models)]\n", + "\n", + "offset = .1\n", + "\n", + "for _ in range(2):\n", + " x = []\n", + " x.append(np.random.uniform(size=(1, DIM)))\n", + " for i in range(100):\n", + " new_x = models[i % n_models].predict(x[-1])\n", + " new_x += offset\n", + " x.append(new_x)\n", + "\n", + " plt.figure()\n", + " plt.plot([e[0][0] for e in x])\n", + " plt.plot([e[0][1] for e in x])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "tXjCfO6AKyRj" + }, + "source": [ + "## Next\n", + "\n", + "- Is a trained net also an attractor?\n", + "- How do trained or random density nets behave?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "autoexec": { + "startup": false, + "wait_interval": 0 + } + }, + "colab_type": "code", + "id": "w4SRxuKdK4Gg" + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "collapsed_sections": [], + "default_view": {}, + "name": "fixpoint.ipynb", + "provenance": [], + "toc_visible": true, + "version": "0.3.2", + "views": {} + }, + "kernelspec": { + "display_name": "Python 3", + "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.6.8" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/code/line_plots.py b/code/line_plots.py new file mode 100644 index 0000000..412d1cb --- /dev/null +++ b/code/line_plots.py @@ -0,0 +1,118 @@ +import os + +from experiment import Experiment +# noinspection PyUnresolvedReferences +from soup import Soup + +from argparse import ArgumentParser +import numpy as np + +import plotly as pl +import plotly.graph_objs as go + +import colorlover as cl + +import dill + +from sklearn.manifold.t_sne import TSNE, PCA + + +def build_args(): + arg_parser = ArgumentParser() + arg_parser.add_argument('-i', '--in_file', nargs=1, type=str) + arg_parser.add_argument('-o', '--out_file', nargs='?', default='out', type=str) + return arg_parser.parse_args() + + +def line_plot(names_exp_tuple, filename='lineplot'): + + names, line_dict_list = names_exp_tuple + + names = ['Weightwise', 'Aggregating', 'Recurrent'] + + if False: + data = [] + base_scale = cl.scales['10']['div']['RdYlGn'] + scale = cl.interp(base_scale, len(line_dict_list) + 1) # Map color scale to N bins + for ld_id, line_dict in enumerate(line_dict_list): + for data_point in ['ys', 'zs']: + trace = go.Scatter( + x=line_dict['xs'], + y=line_dict[data_point], + name='{} {}zero-fixpoints'.format(names[ld_id], 'non-' if data_point == 'zs' else ''), + line=dict( + # color=scale[ld_id], + width=5, + # dash='dash' if data_point == 'ys' else '' + ), + ) + + data.append(trace) + if True: + + data = [] + base_scale = cl.scales['10']['div']['RdYlGn'] + scale = cl.interp(base_scale, len(line_dict_list) + 1) # Map color scale to N bins + for ld_id, line_dict in enumerate(line_dict_list): + trace = go.Scatter( + x=line_dict['xs'], + y=line_dict['ys'], + name=names[ld_id], + line=dict( # color=scale[ld_id], + width=5 + ), + ) + + data.append(trace) + + layout = dict(xaxis=dict(title='Trains per self-application', titlefont=dict(size=20)), + yaxis=dict(title='Average amount of fixpoints found', + titlefont=dict(size=20), + # type='log', + # range=[0, 2] + ), + legend=dict(orientation='h', x=0.3, y=-0.3), + # height=800, width=800, + margin=dict(b=0) + ) + + fig = go.Figure(data=data, layout=layout) + pl.offline.plot(fig, auto_open=True, filename=filename) + pass + + +def search_and_apply(absolut_file_or_folder, plotting_function, files_to_look_for=[]): + if os.path.isdir(absolut_file_or_folder): + for sub_file_or_folder in os.scandir(absolut_file_or_folder): + search_and_apply(sub_file_or_folder.path, plotting_function, files_to_look_for=files_to_look_for) + elif absolut_file_or_folder.endswith('.dill'): + file_or_folder = os.path.split(absolut_file_or_folder)[-1] + if file_or_folder in files_to_look_for and not os.path.exists('{}.html'.format(absolut_file_or_folder[:-5])): + print('Apply Plotting function "{func}" on file "{file}"'.format(func=plotting_function.__name__, + file=absolut_file_or_folder) + ) + with open(absolut_file_or_folder, 'rb') as in_f: + exp = dill.load(in_f) + + names_dill_location = os.path.join(*os.path.split(absolut_file_or_folder)[:-1], 'all_names.dill') + with open(names_dill_location, 'rb') as in_f: + names = dill.load(in_f) + + try: + plotting_function((names, exp), filename='{}.html'.format(absolut_file_or_folder[:-5])) + except ValueError: + pass + except AttributeError: + pass + else: + # This was either another FilyType or Plot.html alerady exists. + pass + + +if __name__ == '__main__': + args = build_args() + in_file = args.in_file[0] + out_file = args.out_file + + search_and_apply(in_file, line_plot, ["all_data.dill"]) + diff --git a/code/methods.py b/code/methods.py new file mode 100644 index 0000000..39e8dd6 --- /dev/null +++ b/code/methods.py @@ -0,0 +1,191 @@ +import tensorflow as tf +from keras.models import Sequential, Model +from keras.layers import SimpleRNN, Dense +from keras.layers import Input, TimeDistributed +from tqdm import tqdm +import time +import os +import dill + +from experiment import Experiment + +import itertools + +from typing import Union +import numpy as np + +class Network(object): + def __init__(self, features, cells, layers, bias=False, recurrent=False): + self.features = features + self.cells = cells + self.num_layer = layers + bias_params = cells if bias else 0 + + # Recurrent network + if recurrent: + # First RNN + p_layer_1 = (self.features * self.cells + self.cells ** 2 + bias_params) + # All other RNN Layers + p_layer_n = (self.cells * self.cells + self.cells ** 2 + bias_params) * (self.num_layer - 1) + else: + # First Dense + p_layer_1 = (self.features * self.cells + bias_params) + # All other Dense Layers + p_layer_n = (self.cells * self.cells + bias_params) * (self.num_layer - 1) + # Final Dense + p_layer_out = self.features * self.cells + bias_params + self.parameters = np.sum([p_layer_1, p_layer_n, p_layer_out]) + # Build network + cell = SimpleRNN if recurrent else Dense + self.inputs, x = Input(shape=(self.parameters // self.features, + self.features) if recurrent else (self.features,)), None + + for layer in range(self.num_layer): + if recurrent: + x = SimpleRNN(self.cells, activation=None, use_bias=False, + return_sequences=True)(self.inputs if layer == 0 else x) + else: + x = Dense(self.cells, activation=None, use_bias=False, + )(self.inputs if layer == 0 else x) + self.outputs = Dense(self.features if recurrent else 1, activation=None, use_bias=False)(x) + print('Network initialized, i haz {p} params @:{e}Features: {f}{e}Cells: {c}{e}Layers: {l}'.format( + p=self.parameters, l=self.num_layer, c=self.cells, f=self.features, e='\n{}'.format(' ' * 5)) + ) + pass + + def get_inputs(self): + return self.inputs + + def get_outputs(self): + return self.outputs + + +class _BaseNetwork(Model): + + def __init__(self, **kwargs): + super(_BaseNetwork, self).__init__(**kwargs) + # This is dirty + self.features = None + + def get_weights_flat(self): + weights = super().get_weights() + flat = np.asarray(np.concatenate([x.flatten() for x in weights])) + return flat + + def step(self, x): + pass + + def step_other(self, other: Union[Sequential, Model]) -> bool: + pass + + def get_parameter_count(self): + return np.sum([np.prod(x.shape) for x in self.get_weights()]) + + def train_on_batch(self, *args, **kwargs): + raise NotImplementedError + + def compile(self, *args, **kwargs): + raise NotImplementedError + + @staticmethod + def mean_abs_error(labels, predictions): + return np.mean(np.abs(predictions - labels), axis=-1) + + @staticmethod + def mean_sqrd_error(labels, predictions): + return np.mean(np.square(predictions - labels), axis=-1) + + +class RecurrentNetwork(_BaseNetwork): + def __init__(self, network: Network, *args, **kwargs): + super().__init__(inputs=network.inputs, outputs=network.outputs) + self.features = network.features + self.parameters = network.parameters + assert self.parameters == self.get_parameter_count() + + def step(self, x): + shaped = np.reshape(x, (1, -1, self.features)) + return self.predict(shaped).flatten() + + def fit(self, epochs=500, **kwargs): + losses = [] + with tqdm(total=epochs, ascii=True, + desc='Type: {t}'. format(t=self.__class__.__name__), + postfix=["Loss", dict(value=0)]) as bar: + for _ in range(epochs): + x = self.get_weights_flat() + y = self.step(x) + weights = self.get_weights() + global_idx = 0 + for idx, weight_matrix in enumerate(weights): + flattened = weight_matrix.flatten() + new_weights = y[global_idx:global_idx + flattened.shape[0]] + weights[idx] = np.reshape(new_weights, weight_matrix.shape) + global_idx += flattened.shape[0] + losses.append(self.mean_sqrd_error(y.flatten(), self.get_weights_flat())) + self.set_weights(weights) + bar.postfix[1]["value"] = losses[-1] + bar.update() + return losses + + +class FeedForwardNetwork(_BaseNetwork): + def __init__(self, network:Network, **kwargs): + super().__init__(inputs=network.inputs, outputs=network.outputs, **kwargs) + self.features = network.features + self.parameters = network.parameters + self.num_layer = network.num_layer + self.num_cells = network.cells + # assert self.parameters == self.get_parameter_count() + + def step(self, x): + return self.predict(x) + + def step_other(self, x): + return self.predict(x) + + def fit(self, epochs=500, **kwargs): + losses = [] + with tqdm(total=epochs, ascii=True, + desc='Type: {t} @ Epoch:'. format(t=self.__class__.__name__), + postfix=["Loss", dict(value=0)]) as bar: + for _ in range(epochs): + all_weights = self.get_weights_flat() + cell_idx = np.apply_along_axis(lambda x: x/self.num_cells, 0, np.arange(int(self.get_parameter_count()))) + xc = np.concatenate((all_weights[..., None], cell_idx[..., None]), axis=1) + + y = self.step(xc) + + weights = self.get_weights() + global_idx = 0 + + for idx, weight_matrix in enumerate(weights): + + # UPDATE THE WEIGHTS + flattened = weight_matrix.flatten() + new_weights = y[global_idx:global_idx + flattened.shape[0], 0] + weights[idx] = np.reshape(new_weights, weight_matrix.shape) + global_idx += flattened.shape[0] + + losses.append(self.mean_sqrd_error(y[:, 0].flatten(), self.get_weights_flat())) + self.set_weights(weights) + bar.postfix[1]["value"] = losses[-1] + bar.update() + return losses + + +if __name__ == '__main__': + with Experiment() as exp: + features, cells, layers = 2, 2, 2 + use_recurrent = False + if use_recurrent: + network = Network(features, cells, layers, recurrent=use_recurrent) + r = RecurrentNetwork(network) + loss = r.fit(epochs=10) + exp.save(rnet=r) + else: + network = Network(features, cells, layers, recurrent=use_recurrent) + ff = FeedForwardNetwork(network) + loss = ff.fit(epochs=10) + exp.save(ffnet=ff) + print(loss) diff --git a/code/network.py b/code/network.py new file mode 100644 index 0000000..21c83fc --- /dev/null +++ b/code/network.py @@ -0,0 +1,726 @@ +import numpy as np + +from tensorflow.python.keras.models import Sequential +from tensorflow.python.keras.callbacks import Callback +from tensorflow.python.keras.layers import SimpleRNN, Dense +from tensorflow.python.keras import backend as K + +from util import * +from experiment import * + +# Supress warnings and info messages +os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' + + +class SaveStateCallback(Callback): + def __init__(self, net, epoch=0): + super(SaveStateCallback, self).__init__() + self.net = net + self.init_epoch = epoch + + def on_epoch_end(self, epoch, logs={}): + description = dict(time=epoch+self.init_epoch) + description['action'] = 'train_self' + description['counterpart'] = None + self.net.save_state(**description) + return + + +class NeuralNetwork(PrintingObject): + + @staticmethod + def weights_to_string(weights): + s = "" + for layer_id, layer in enumerate(weights): + for cell_id, cell in enumerate(layer): + s += "[ " + for weight_id, weight in enumerate(cell): + s += str(weight) + " " + s += "]" + s += "\n" + return s + + @staticmethod + def are_weights_diverged(network_weights): + for layer_id, layer in enumerate(network_weights): + for cell_id, cell in enumerate(layer): + for weight_id, weight in enumerate(cell): + if np.isnan(weight): + return True + if np.isinf(weight): + return True + return False + + @staticmethod + def are_weights_within(network_weights, lower_bound, upper_bound): + for layer_id, layer in enumerate(network_weights): + for cell_id, cell in enumerate(layer): + for weight_id, weight in enumerate(cell): + # could be a chain comparission "lower_bound <= weight <= upper_bound" + if not (lower_bound <= weight and weight <= upper_bound): + return False + return True + + @staticmethod + def fill_weights(old_weights, new_weights_list): + new_weights = copy.deepcopy(old_weights) + current_weight_id = 0 + for layer_id, layer in enumerate(new_weights): + for cell_id, cell in enumerate(layer): + for weight_id, weight in enumerate(cell): + new_weight = new_weights_list[current_weight_id] + new_weights[layer_id][cell_id][weight_id] = new_weight + current_weight_id += 1 + return new_weights + + def __init__(self, **params): + super().__init__() + self.params = dict(epsilon=0.00000000000001) + self.params.update(params) + self.keras_params = dict(activation='linear', use_bias=False) + self.states = [] + + def get_model(self): + raise NotImplementedError + + def get_params(self): + return self.params + + def get_keras_params(self): + return self.keras_params + + def with_params(self, **kwargs): + self.params.update(kwargs) + return self + + def with_keras_params(self, **kwargs): + self.keras_params.update(kwargs) + return self + + def get_weights(self): + return self.model.get_weights() + + def get_weights_flat(self): + return np.hstack([weight.flatten() for weight in self.get_weights()]) + + def set_weights(self, new_weights): + return self.model.set_weights(new_weights) + + def apply_to_weights(self, old_weights): + raise NotImplementedError + + def apply_to_network(self, other_network): + new_weights = self.apply_to_weights(other_network.get_weights()) + return new_weights + + def attack(self, other_network): + other_network.set_weights(self.apply_to_network(other_network)) + return self + + def fuck(self, other_network): + self.set_weights(self.apply_to_network(other_network)) + return self + + def self_attack(self, iterations=1): + for _ in range(iterations): + self.attack(self) + return self + + def meet(self, other_network): + new_other_network = copy.deepcopy(other_network) + return self.attack(new_other_network) + + def is_diverged(self): + return self.are_weights_diverged(self.get_weights()) + + def is_zero(self, epsilon=None): + epsilon = epsilon or self.get_params().get('epsilon') + return self.are_weights_within(self.get_weights(), -epsilon, epsilon) + + def is_fixpoint(self, degree=1, epsilon=None): + assert degree >= 1, "degree must be >= 1" + epsilon = epsilon or self.get_params().get('epsilon') + old_weights = self.get_weights() + new_weights = copy.deepcopy(old_weights) + + for _ in range(degree): + new_weights = self.apply_to_weights(new_weights) + + if NeuralNetwork.are_weights_diverged(new_weights): + return False + for layer_id, layer in enumerate(old_weights): + for cell_id, cell in enumerate(layer): + for weight_id, weight in enumerate(cell): + new_weight = new_weights[layer_id][cell_id][weight_id] + if abs(new_weight - weight) >= epsilon: + return False + return True + + def repr_weights(self, weights=None): + return self.weights_to_string(weights or self.get_weights()) + + def print_weights(self, weights=None): + print(self.repr_weights(weights)) + + +class ParticleDecorator: + next_uid = 0 + + def __init__(self, net): + self.uid = self.__class__.next_uid + self.__class__.next_uid += 1 + self.net = net + self.states = [] + self.save_state(time=0, + action='init', + counterpart=None + ) + + def __getattr__(self, name): + return getattr(self.net, name) + + def get_uid(self): + return self.uid + + def make_state(self, **kwargs): + weights = self.net.get_weights_flat() + if any(np.isinf(weights)) or any(np.isnan(weights)): + return None + state = {'class': self.net.__class__.__name__, 'weights': weights} + state.update(kwargs) + return state + + def save_state(self, **kwargs): + state = self.make_state(**kwargs) + if state is not None: + self.states += [state] + else: + pass + + def update_state(self, number, **kwargs): + raise NotImplementedError('Result is vague') + if number < len(self.states): + self.states[number] = self.make_state(**kwargs) + else: + for i in range(len(self.states), number): + self.states += [None] + self.states += self.make_state(**kwargs) + + def get_states(self): + return self.states + + +class WeightwiseNeuralNetwork(NeuralNetwork): + + @staticmethod + def normalize_id(value, norm): + if norm > 1: + return float(value) / float(norm) + else: + return float(value) + + def __init__(self, width, depth, **kwargs): + super().__init__(**kwargs) + self.width = width + self.depth = depth + self.model = Sequential() + self.model.add(Dense(units=self.width, input_dim=4, **self.keras_params)) + for _ in range(self.depth-1): + self.model.add(Dense(units=self.width, **self.keras_params)) + self.model.add(Dense(units=1, **self.keras_params)) + + def get_model(self): + return self.model + + def apply(self, *inputs): + stuff = np.transpose(np.array([[inputs[0]], [inputs[1]], [inputs[2]], [inputs[3]]])) + return self.model.predict(stuff)[0][0] + + @classmethod + def compute_all_duplex_weight_points(cls, old_weights): + points = [] + normal_points = [] + max_layer_id = len(old_weights) - 1 + for layer_id, layer in enumerate(old_weights): + max_cell_id = len(layer) - 1 + for cell_id, cell in enumerate(layer): + max_weight_id = len(cell) - 1 + for weight_id, weight in enumerate(cell): + normal_layer_id = cls.normalize_id(layer_id, max_layer_id) + normal_cell_id = cls.normalize_id(cell_id, max_cell_id) + normal_weight_id = cls.normalize_id(weight_id, max_weight_id) + + points += [[weight, layer_id, cell_id, weight_id]] + normal_points += [[weight, normal_layer_id, normal_cell_id, normal_weight_id]] + return points, normal_points + + @classmethod + def compute_all_weight_points(cls, all_weights): + return cls.compute_all_duplex_weight_points(all_weights)[0] + + @classmethod + def compute_all_normal_weight_points(cls, all_weights): + return cls.compute_all_duplex_weight_points(all_weights)[1] + + def apply_to_weights(self, old_weights): + new_weights = copy.deepcopy(self.get_weights()) + for (weight_point, normal_weight_point) in zip(*self.__class__.compute_all_duplex_weight_points(old_weights)): + weight, layer_id, cell_id, weight_id = weight_point + _, normal_layer_id, normal_cell_id, normal_weight_id = normal_weight_point + + new_weight = self.apply(*normal_weight_point) + new_weights[layer_id][cell_id][weight_id] = new_weight + + if self.params.get("print_all_weight_updates", False) and not self.is_silent(): + print("updated old weight {weight}\t @ ({layer},{cell},{weight_id}) " + "to new value {new_weight}\t calling @ ({normal_layer},{normal_cell},{normal_weight_id})").format( + weight=weight, layer=layer_id, cell=cell_id, weight_id=weight_id, new_weight=new_weight, + normal_layer=normal_layer_id, normal_cell=normal_cell_id, normal_weight_id=normal_weight_id) + return new_weights + + def compute_samples(self): + samples = [] + for normal_weight_point in self.compute_all_normal_weight_points(self.get_weights()): + weight, normal_layer_id, normal_cell_id, normal_weight_id = normal_weight_point + + sample = np.transpose(np.array([[weight], [normal_layer_id], [normal_cell_id], [normal_weight_id]])) + samples += [sample[0]] + samples_array = np.asarray(samples) + return samples_array, samples_array[:, 0] + + +class AggregatingNeuralNetwork(NeuralNetwork): + + @staticmethod + def aggregate_average(weights): + total = 0 + count = 0 + for weight in weights: + total += float(weight) + count += 1 + return total / float(count) + + @staticmethod + def aggregate_max(weights): + max_found = weights[0] + for weight in weights: + max_found = weight > max_found and weight or max_found + return max_found + + @staticmethod + def deaggregate_identically(aggregate, amount): + return [aggregate for _ in range(amount)] + + @staticmethod + def shuffle_not(weights_list): + return weights_list + + @staticmethod + def shuffle_random(weights_list): + import random + random.shuffle(weights_list) + return weights_list + + def __init__(self, aggregates, width, depth, **kwargs): + super().__init__(**kwargs) + self.aggregates = aggregates + self.width = width + self.depth = depth + self.model = Sequential() + self.model.add(Dense(units=width, input_dim=self.aggregates, **self.keras_params)) + for _ in range(depth-1): + self.model.add(Dense(units=width, **self.keras_params)) + self.model.add(Dense(units=self.aggregates, **self.keras_params)) + + def get_model(self): + return self.model + + def get_aggregator(self): + return self.params.get('aggregator', self.aggregate_average) + + def get_deaggregator(self): + return self.params.get('deaggregator', self.deaggregate_identically) + + def get_shuffler(self): + return self.params.get('shuffler', self.shuffle_not) + + def get_amount_of_weights(self): + total_weights = 0 + for layer_id, layer in enumerate(self.get_weights()): + for cell_id, cell in enumerate(layer): + for weight_id, weight in enumerate(cell): + total_weights += 1 + return total_weights + + def apply(self, *inputs): + stuff = np.transpose(np.array([[inputs[i]] for i in range(self.aggregates)])) + return self.model.predict(stuff)[0] + + def apply_to_weights(self, old_weights): + # build aggregations from old_weights + collection_size = self.get_amount_of_weights() // self.aggregates + collections, leftovers = self.collect_weights(old_weights, collection_size) + + # call network + old_aggregations = [self.get_aggregator()(collection) for collection in collections] + new_aggregations = self.apply(*old_aggregations) + + # generate list of new weights + new_weights_list = [] + for aggregation_id, aggregation in enumerate(new_aggregations): + if aggregation_id == self.aggregates - 1: + new_weights_list += self.get_deaggregator()(aggregation, collection_size + leftovers) + else: + new_weights_list += self.get_deaggregator()(aggregation, collection_size) + new_weights_list = self.get_shuffler()(new_weights_list) + + # write back new weights + new_weights = self.fill_weights(old_weights, new_weights_list) + + # return results + if self.params.get("print_all_weight_updates", False) and not self.is_silent(): + print("updated old weight aggregations " + str(old_aggregations)) + print("to new weight aggregations " + str(new_aggregations)) + print("resulting in network weights ...") + print(self.weights_to_string(new_weights)) + return new_weights + + @staticmethod + def collect_weights(all_weights, collection_size): + collections = [] + next_collection = [] + current_weight_id = 0 + for layer_id, layer in enumerate(all_weights): + for cell_id, cell in enumerate(layer): + for weight_id, weight in enumerate(cell): + next_collection += [weight] + if (current_weight_id + 1) % collection_size == 0: + collections += [next_collection] + next_collection = [] + current_weight_id += 1 + collections[-1] += next_collection + leftovers = len(next_collection) + return collections, leftovers + + def get_collected_weights(self): + collection_size = self.get_amount_of_weights() // self.aggregates + return self.collect_weights(self.get_weights(), collection_size) + + def get_aggregated_weights(self): + collections, leftovers = self.get_collected_weights() + aggregations = [self.get_aggregator()(collection) for collection in collections] + return aggregations, leftovers + + def compute_samples(self): + aggregations, _ = self.get_aggregated_weights() + sample = np.transpose(np.array([[aggregations[i]] for i in range(self.aggregates)])) + return [sample], [sample] + + def is_fixpoint_after_aggregation(self, degree=1, epsilon=None): + assert degree >= 1, "degree must be >= 1" + epsilon = epsilon or self.get_params().get('epsilon') + + old_weights = self.get_weights() + old_aggregations, _ = self.get_aggregated_weights() + + new_weights = copy.deepcopy(old_weights) + for _ in range(degree): + new_weights = self.apply_to_weights(new_weights) + if NeuralNetwork.are_weights_diverged(new_weights): + return False + collection_size = self.get_amount_of_weights() // self.aggregates + collections, leftovers = self.__class__.collect_weights(new_weights, collection_size) + new_aggregations = [self.get_aggregator()(collection) for collection in collections] + + for aggregation_id, old_aggregation in enumerate(old_aggregations): + new_aggregation = new_aggregations[aggregation_id] + if abs(new_aggregation - old_aggregation) >= epsilon: + return False, new_aggregations + return True, new_aggregations + + +class FFTNeuralNetwork(NeuralNetwork): + + @staticmethod + def aggregate_fft(weights, dims): + flat = np.hstack([weight.flatten() for weight in weights]) + fft_reduction = np.fft.fftn(flat, dims)[None, ...] + return fft_reduction + + @staticmethod + def deaggregate_identically(aggregate, dims): + fft_inverse = np.fft.ifftn(aggregate, dims) + return fft_inverse + + @staticmethod + def shuffle_not(weights_list): + return weights_list + + @staticmethod + def shuffle_random(weights_list): + import random + random.shuffle(weights_list) + return weights_list + + def __init__(self, aggregates, width, depth, **kwargs): + super().__init__(**kwargs) + self.aggregates = aggregates + self.width = width + self.depth = depth + self.model = Sequential() + self.model.add(Dense(units=width, input_dim=self.aggregates, **self.keras_params)) + for _ in range(depth-1): + self.model.add(Dense(units=width, **self.keras_params)) + self.model.add(Dense(units=self.aggregates, **self.keras_params)) + + def get_model(self): + return self.model + + def get_shuffler(self): + return self.params.get('shuffler', self.shuffle_not) + + def get_amount_of_weights(self): + total_weights = 0 + for layer_id, layer in enumerate(self.get_weights()): + for cell_id, cell in enumerate(layer): + for weight_id, weight in enumerate(cell): + total_weights += 1 + return total_weights + + def apply(self, inputs): + sample = np.asarray(inputs) + return self.model.predict(sample)[0] + + def apply_to_weights(self, old_weights): + # build aggregations from old_weights + weights = self.get_weights_flat() + + # call network + old_aggregation = self.aggregate_fft(weights, self.aggregates) + new_aggregation = self.apply(old_aggregation) + + # generate list of new weights + new_weights_list = self.deaggregate_identically(new_aggregation, self.get_amount_of_weights()) + + new_weights_list = self.get_shuffler()(new_weights_list) + + # write back new weights + new_weights = self.fill_weights(old_weights, new_weights_list) + + # return results + if self.params.get("print_all_weight_updates", False) and not self.is_silent(): + print("updated old weight aggregations " + str(old_aggregation)) + print("to new weight aggregations " + str(new_aggregation)) + print("resulting in network weights ...") + print(self.__class__.weights_to_string(new_weights)) + return new_weights + + def compute_samples(self): + weights = self.get_weights() + sample = np.asarray(weights)[None, ...] + return [sample], [sample] + + +class RecurrentNeuralNetwork(NeuralNetwork): + + def __init__(self, width, depth, **kwargs): + super().__init__(**kwargs) + self.features = 1 + self.width = width + self.depth = depth + self.model = Sequential() + self.model.add(SimpleRNN(units=width, input_dim=self.features, return_sequences=True, **self.keras_params)) + for _ in range(depth-1): + self.model.add(SimpleRNN(units=width, return_sequences=True, **self.keras_params)) + self.model.add(SimpleRNN(units=self.features, return_sequences=True, **self.keras_params)) + + def get_model(self): + return self.model + + def apply(self, *inputs): + stuff = np.transpose(np.array([[[inputs[i]] for i in range(len(inputs))]])) + return self.model.predict(stuff)[0].flatten() + + def apply_to_weights(self, old_weights): + # build list from old weights + new_weights = copy.deepcopy(old_weights) + old_weights_list = [] + for layer_id, layer in enumerate(old_weights): + for cell_id, cell in enumerate(layer): + for weight_id, weight in enumerate(cell): + old_weights_list += [weight] + + # call network + new_weights_list = self.apply(*old_weights_list) + + # write back new weights from list of rnn returns + current_weight_id = 0 + for layer_id, layer in enumerate(new_weights): + for cell_id, cell in enumerate(layer): + for weight_id, weight in enumerate(cell): + new_weight = new_weights_list[current_weight_id] + new_weights[layer_id][cell_id][weight_id] = new_weight + current_weight_id += 1 + return new_weights + + def compute_samples(self): + # build list from old weights + old_weights_list = [] + for layer_id, layer in enumerate(self.get_weights()): + for cell_id, cell in enumerate(layer): + for weight_id, weight in enumerate(cell): + old_weights_list += [weight] + sample = np.asarray(old_weights_list)[None, ..., None] + return sample, sample + + +class TrainingNeuralNetworkDecorator(): + + def __init__(self, net, **kwargs): + self.net = net + self.compile_params = dict(loss='mse', optimizer='sgd') + self.model_compiled = False + + def __getattr__(self, name): + return getattr(self.net, name) + + def with_params(self, **kwargs): + self.net.with_params(**kwargs) + return self + + def with_keras_params(self, **kwargs): + self.net.with_keras_params(**kwargs) + return self + + def get_compile_params(self): + return self.compile_params + + def with_compile_params(self, **kwargs): + self.compile_params.update(kwargs) + return self + + def compile_model(self, **kwargs): + compile_params = copy.deepcopy(self.compile_params) + compile_params.update(kwargs) + return self.net.model.compile(**compile_params) + + def compiled(self, **kwargs): + if not self.model_compiled: + self.compile_model(**kwargs) + self.model_compiled = True + return self + + def train(self, batchsize=1, store_states=True, epoch=0): + self.compiled() + x, y = self.net.compute_samples() + savestatecallback = [SaveStateCallback(net=self, epoch=epoch)] if store_states else None + history = self.net.model.fit(x=x, y=y, epochs=epoch+1, verbose=0, batch_size=batchsize, callbacks=savestatecallback, initial_epoch=epoch) + return history.history['loss'][-1] + + def learn_from(self, other_network, batchsize=1): + self.compiled() + other_network.compiled() + x, y = other_network.net.compute_samples() + history = self.net.model.fit(x=x, y=y, verbose=0, batch_size=batchsize) + + return history.history['loss'][-1] + + +if __name__ == '__main__': + def run_exp(net, prints=False): + # INFO Run_ID needs to be more than 0, so that exp stores the trajectories! + exp.run_net(net, 100, run_id=run_id + 1) + exp.historical_particles[run_id] = net + if prints: + print("Fixpoint? " + str(net.is_fixpoint())) + print("Loss " + str(loss)) + + if True: + # WeightWise Neural Network + with FixpointExperiment() as exp: + for run_id in tqdm(range(100)): + net = ParticleDecorator(WeightwiseNeuralNetwork(width=2, depth=2) \ + .with_keras_params(activation='linear')) + run_exp(net) + K.clear_session() + exp.log(exp.counters) + + if True: + # Aggregating Neural Network + with FixpointExperiment() as exp: + for run_id in tqdm(range(100)): + net = ParticleDecorator(AggregatingNeuralNetwork(aggregates=4, width=2, depth=2) \ + .with_keras_params()) + run_exp(net) + K.clear_session() + exp.log(exp.counters) + + if True: + #FFT Neural Network + with FixpointExperiment() as exp: + for run_id in tqdm(range(100)): + net = ParticleDecorator(FFTNeuralNetwork(aggregates=4, width=2, depth=2) \ + .with_keras_params(activation='linear')) + run_exp(net) + K.clear_session() + exp.log(exp.counters) + + if True: + # ok so this works quite realiably + with FixpointExperiment() as exp: + for i in range(1): + run_count = 1000 + net = TrainingNeuralNetworkDecorator(ParticleDecorator(WeightwiseNeuralNetwork(width=2, depth=2))) + net.with_params(epsilon=0.0001).with_keras_params(optimizer='sgd') + for run_id in tqdm(range(run_count+1)): + net.compiled() + loss = net.train(epoch=run_id) + if run_id % 100 == 0: + run_exp(net) + K.clear_session() + + if False: + with FixpointExperiment() as exp: + run_count = 1000 + net = TrainingNeuralNetworkDecorator(AggregatingNeuralNetwork(4, width=2, depth=2)).with_params(epsilon=0.1e-6) + for run_id in tqdm(range(run_count+1)): + loss = net.compiled().train() + if run_id % 100 == 0: + net.print_weights() + old_aggs, _ = net.net.get_aggregated_weights() + print("old weights agg: " + str(old_aggs)) + fp, new_aggs = net.net.is_fixpoint_after_aggregation(epsilon=0.0001) + print("new weights agg: " + str(new_aggs)) + print("Fixpoint? " + str(net.is_fixpoint())) + print("Fixpoint after Agg? " + str(fp)) + print("Loss " + str(loss)) + print() + + if False: + # this explodes in our faces completely... NAN everywhere + # TODO: Wtf is happening here? + with FixpointExperiment() as exp: + run_count = 10000 + net = TrainingNeuralNetworkDecorator(RecurrentNeuralNetwork(width=2, depth=2))\ + .with_params(epsilon=0.1e-2).with_keras_params(optimizer='sgd', activation='linear') + for run_id in tqdm(range(run_count+1)): + loss = net.compiled().train() + if run_id % 500 == 0: + net.print_weights() + # print(net.apply_to_network(net)) + print("Fixpoint? " + str(net.is_fixpoint())) + print("Loss " + str(loss)) + print() + if False: + # and this gets somewhat interesting... we can still achieve non-trivial fixpoints + # over multiple applications when training enough in-between + with MixedFixpointExperiment() as exp: + for run_id in range(10): + net = TrainingNeuralNetworkDecorator(FFTNeuralNetwork(2, width=2, depth=2))\ + .with_params(epsilon=0.0001, activation='sigmoid') + exp.run_net(net, 500, 10) + + net.print_weights() + + print("Fixpoint? " + str(net.is_fixpoint())) + exp.log(exp.counters) diff --git a/code/results/Soup/experiment.dill b/code/results/Soup/experiment.dill new file mode 100644 index 0000000..83cfa68 Binary files /dev/null and b/code/results/Soup/experiment.dill differ diff --git a/code/results/Soup/log.txt b/code/results/Soup/log.txt new file mode 100644 index 0000000..af433b8 --- /dev/null +++ b/code/results/Soup/log.txt @@ -0,0 +1 @@ +{'divergent': 0, 'fix_zero': 0, 'fix_other': 13, 'fix_sec': 0, 'other': 7} diff --git a/code/results/Soup/soup.dill b/code/results/Soup/soup.dill new file mode 100644 index 0000000..fda1db9 Binary files /dev/null and b/code/results/Soup/soup.dill differ diff --git a/code/results/Soup/soup.html b/code/results/Soup/soup.html new file mode 100644 index 0000000..bdfec90 --- /dev/null +++ b/code/results/Soup/soup.html @@ -0,0 +1,7 @@ +
\ No newline at end of file diff --git a/code/results/Soup/weights.txt b/code/results/Soup/weights.txt new file mode 100644 index 0000000..8aa9eda --- /dev/null +++ b/code/results/Soup/weights.txt @@ -0,0 +1,30 @@ +[-0.15321673 1.0428386 -0.7245892 -0.04343993 0.42338863 0.02538261 + -0.40465942 -0.0242596 -1.226809 -0.8168446 0.26588777 -1.0929432 + 0.5383322 -0.73875046] +[-0.03072096 -1.369665 -0.357126 -0.21180922 0.3853204 0.22853081 + -0.3705557 -0.21977347 -0.6684716 0.12849599 1.0226644 -0.0922638 + -0.7828449 -0.6572327 ] +[-1.2444692 0.61213857 0.07965802 0.12361202 0.62641835 0.9720597 + 0.3863232 0.59948945 1.0857513 0.49231085 -0.5319295 0.29433587 + -0.64177823 0.17603302] +[-0.9938292 -0.4438207 -0.03172896 0.06261964 -0.3870194 0.7637992 + 0.0244509 -0.04825407 0.91551745 -0.78740424 0.29226422 -0.52767307 + -0.41744384 0.5567152 ] +[-0.39049304 0.8842579 -0.8447943 -0.19669186 0.7207061 0.16780053 + 0.3728221 0.08680353 0.7535456 -0.1000197 0.02029054 0.8640245 + -0.15881588 1.1905665 ] +[ 1.0482084 0.9248296 -0.26946014 0.57047915 -0.32660747 0.6914731 + -0.18025818 0.3816289 -0.69358927 0.21312684 -0.39932403 -0.02991759 + -0.83068466 0.45619962] +[ 0.75814664 0.10328437 0.07867077 -0.0743314 -0.53440267 0.50492585 + -0.54172474 0.51184535 0.3462249 1.0527638 -0.9503541 0.9235086 + -0.1665241 1.1497779 ] +[-0.77187353 1.1105504 0.24265823 0.53782856 -0.34098852 -0.75576884 + -0.25396293 -0.56288165 0.3851537 -0.67497945 0.14336896 0.763481 + -0.9224985 0.6374753 ] +[-0.79123825 0.68166596 -0.30061013 -0.19360289 0.5632736 0.36276665 + 0.7470975 0.48115698 0.10046808 -0.8064349 -1.036736 -0.68296516 + -1.156437 0.52633154] +[ 0.1788832 -1.5321186 -0.62001514 -0.3870902 0.97524184 0.6088638 + -0.08297889 -0.05180515 -0.29096788 0.7519439 0.8803648 0.82771575 + -0.854887 0.1742936 ] diff --git a/code/results/apply_fixpoints.png b/code/results/apply_fixpoints.png new file mode 100644 index 0000000..e8f4a02 Binary files /dev/null and b/code/results/apply_fixpoints.png differ diff --git a/code/results/exp-applying_fixpoint-_1552681870.3570378-0/all_counters.dill b/code/results/exp-applying_fixpoint-_1552681870.3570378-0/all_counters.dill new file mode 100644 index 0000000..7fb6bb1 Binary files /dev/null and b/code/results/exp-applying_fixpoint-_1552681870.3570378-0/all_counters.dill differ diff --git a/code/results/exp-applying_fixpoint-_1552681870.3570378-0/all_counters.html b/code/results/exp-applying_fixpoint-_1552681870.3570378-0/all_counters.html new file mode 100644 index 0000000..0d6d9b0 --- /dev/null +++ b/code/results/exp-applying_fixpoint-_1552681870.3570378-0/all_counters.html @@ -0,0 +1,7 @@ +
\ No newline at end of file diff --git a/code/results/exp-applying_fixpoint-_1552681870.3570378-0/all_names.dill b/code/results/exp-applying_fixpoint-_1552681870.3570378-0/all_names.dill new file mode 100644 index 0000000..745970a Binary files /dev/null and b/code/results/exp-applying_fixpoint-_1552681870.3570378-0/all_names.dill differ diff --git a/code/results/exp-applying_fixpoint-_1552681870.3570378-0/experiment.dill b/code/results/exp-applying_fixpoint-_1552681870.3570378-0/experiment.dill new file mode 100644 index 0000000..6344ffc Binary files /dev/null and b/code/results/exp-applying_fixpoint-_1552681870.3570378-0/experiment.dill differ diff --git a/code/results/exp-applying_fixpoint-_1552681870.3570378-0/log.txt b/code/results/exp-applying_fixpoint-_1552681870.3570378-0/log.txt new file mode 100644 index 0000000..3d1cd3b --- /dev/null +++ b/code/results/exp-applying_fixpoint-_1552681870.3570378-0/log.txt @@ -0,0 +1,12 @@ +WeightwiseNeuralNetwork activiation='linear' use_bias=False +{'divergent': 23, 'fix_zero': 27, 'fix_other': 0, 'fix_sec': 0, 'other': 0} + + +AggregatingNeuralNetwork activiation='linear' use_bias=False +{'divergent': 4, 'fix_zero': 46, 'fix_other': 0, 'fix_sec': 0, 'other': 0} + + +RecurrentNeuralNetwork activiation='linear' use_bias=False +{'divergent': 46, 'fix_zero': 4, 'fix_other': 0, 'fix_sec': 0, 'other': 0} + + diff --git a/code/results/exp-applying_fixpoint-_1552681870.3570378-0/trajectorys.dill b/code/results/exp-applying_fixpoint-_1552681870.3570378-0/trajectorys.dill new file mode 100644 index 0000000..7f99580 Binary files /dev/null and b/code/results/exp-applying_fixpoint-_1552681870.3570378-0/trajectorys.dill differ diff --git a/code/results/exp-learn-from-soup-_1552658566.5572753-0/all_data.dill b/code/results/exp-learn-from-soup-_1552658566.5572753-0/all_data.dill new file mode 100644 index 0000000..95eaad1 Binary files /dev/null and b/code/results/exp-learn-from-soup-_1552658566.5572753-0/all_data.dill differ diff --git a/code/results/exp-learn-from-soup-_1552658566.5572753-0/all_data.html b/code/results/exp-learn-from-soup-_1552658566.5572753-0/all_data.html new file mode 100644 index 0000000..25978e4 --- /dev/null +++ b/code/results/exp-learn-from-soup-_1552658566.5572753-0/all_data.html @@ -0,0 +1,7 @@ +
\ No newline at end of file diff --git a/code/results/exp-learn-from-soup-_1552658566.5572753-0/all_names.dill b/code/results/exp-learn-from-soup-_1552658566.5572753-0/all_names.dill new file mode 100644 index 0000000..364954d Binary files /dev/null and b/code/results/exp-learn-from-soup-_1552658566.5572753-0/all_names.dill differ diff --git a/code/results/exp-learn-from-soup-_1552658566.5572753-0/experiment.dill b/code/results/exp-learn-from-soup-_1552658566.5572753-0/experiment.dill new file mode 100644 index 0000000..c298169 Binary files /dev/null and b/code/results/exp-learn-from-soup-_1552658566.5572753-0/experiment.dill differ diff --git a/code/results/exp-learn-from-soup-_1552658566.5572753-0/log.txt b/code/results/exp-learn-from-soup-_1552658566.5572753-0/log.txt new file mode 100644 index 0000000..58dd8f7 --- /dev/null +++ b/code/results/exp-learn-from-soup-_1552658566.5572753-0/log.txt @@ -0,0 +1,4 @@ +TrainingNeuralNetworkDecorator activiation='linear' use_bias=False +{'xs': [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100], 'ys': [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], 'zs': [0.0, 1.2, 5.2, 7.4, 8.1, 9.1, 9.6, 9.8, 10.0, 9.9, 9.9]} + + diff --git a/code/results/exp-learn-from-soup-_1552658566.5572753-0/soup.dill b/code/results/exp-learn-from-soup-_1552658566.5572753-0/soup.dill new file mode 100644 index 0000000..bbdadf9 Binary files /dev/null and b/code/results/exp-learn-from-soup-_1552658566.5572753-0/soup.dill differ diff --git a/code/results/exp-learn-from-soup-_1552658566.5572753-0/soup.html b/code/results/exp-learn-from-soup-_1552658566.5572753-0/soup.html new file mode 100644 index 0000000..b8d5d50 --- /dev/null +++ b/code/results/exp-learn-from-soup-_1552658566.5572753-0/soup.html @@ -0,0 +1,7 @@ +
\ No newline at end of file diff --git a/code/results/exp-learn-from-soup-_1552658566.5572753-0/soup.png b/code/results/exp-learn-from-soup-_1552658566.5572753-0/soup.png new file mode 100644 index 0000000..303c16f Binary files /dev/null and b/code/results/exp-learn-from-soup-_1552658566.5572753-0/soup.png differ diff --git a/code/results/exp-mixed-self-fixpoints-_1552666977.5858653-0/all_data.dill b/code/results/exp-mixed-self-fixpoints-_1552666977.5858653-0/all_data.dill new file mode 100644 index 0000000..2e9beaa Binary files /dev/null and b/code/results/exp-mixed-self-fixpoints-_1552666977.5858653-0/all_data.dill differ diff --git a/code/results/exp-mixed-self-fixpoints-_1552666977.5858653-0/all_data.html b/code/results/exp-mixed-self-fixpoints-_1552666977.5858653-0/all_data.html new file mode 100644 index 0000000..3b93687 --- /dev/null +++ b/code/results/exp-mixed-self-fixpoints-_1552666977.5858653-0/all_data.html @@ -0,0 +1,7 @@ +
\ No newline at end of file diff --git a/code/results/exp-mixed-self-fixpoints-_1552666977.5858653-0/all_names.dill b/code/results/exp-mixed-self-fixpoints-_1552666977.5858653-0/all_names.dill new file mode 100644 index 0000000..745970a Binary files /dev/null and b/code/results/exp-mixed-self-fixpoints-_1552666977.5858653-0/all_names.dill differ diff --git a/code/results/exp-mixed-self-fixpoints-_1552666977.5858653-0/experiment.dill b/code/results/exp-mixed-self-fixpoints-_1552666977.5858653-0/experiment.dill new file mode 100644 index 0000000..a138a14 Binary files /dev/null and b/code/results/exp-mixed-self-fixpoints-_1552666977.5858653-0/experiment.dill differ diff --git a/code/results/exp-mixed-self-fixpoints-_1552666977.5858653-0/log.txt b/code/results/exp-mixed-self-fixpoints-_1552666977.5858653-0/log.txt new file mode 100644 index 0000000..8bdc4e6 --- /dev/null +++ b/code/results/exp-mixed-self-fixpoints-_1552666977.5858653-0/log.txt @@ -0,0 +1,12 @@ +WeightwiseNeuralNetwork activiation='linear' use_bias=False +{'xs': [0, 50, 100, 150, 200, 250, 300, 350, 400, 450, 500], 'ys': [0.2, 0.3, 0.15, 0.55, 0.7, 0.85, 0.8, 0.95, 0.9, 1.0, 1.0]} + + +AggregatingNeuralNetwork activiation='linear' use_bias=False +{'xs': [0, 50, 100, 150, 200, 250, 300, 350, 400, 450, 500], 'ys': [1.0, 0.95, 1.0, 1.0, 0.95, 0.9, 0.8, 1.0, 0.85, 1.0, 0.9]} + + +RecurrentNeuralNetwork activiation='linear' use_bias=False +{'xs': [0, 50, 100, 150, 200, 250, 300, 350, 400, 450, 500], 'ys': [0.05, 0.0, 0.05, 0.0, 0.0, 0.1, 0.1, 0.05, 0.1, 0.0, 0.0]} + + diff --git a/code/results/exp-mixed-soup-_1552674483.9866457-0/all_data.dill b/code/results/exp-mixed-soup-_1552674483.9866457-0/all_data.dill new file mode 100644 index 0000000..209d38d Binary files /dev/null and b/code/results/exp-mixed-soup-_1552674483.9866457-0/all_data.dill differ diff --git a/code/results/exp-mixed-soup-_1552674483.9866457-0/all_data.html b/code/results/exp-mixed-soup-_1552674483.9866457-0/all_data.html new file mode 100644 index 0000000..495691f --- /dev/null +++ b/code/results/exp-mixed-soup-_1552674483.9866457-0/all_data.html @@ -0,0 +1,7 @@ +
\ No newline at end of file diff --git a/code/results/exp-mixed-soup-_1552674483.9866457-0/all_names.dill b/code/results/exp-mixed-soup-_1552674483.9866457-0/all_names.dill new file mode 100644 index 0000000..573498f Binary files /dev/null and b/code/results/exp-mixed-soup-_1552674483.9866457-0/all_names.dill differ diff --git a/code/results/exp-mixed-soup-_1552674483.9866457-0/experiment.dill b/code/results/exp-mixed-soup-_1552674483.9866457-0/experiment.dill new file mode 100644 index 0000000..765a429 Binary files /dev/null and b/code/results/exp-mixed-soup-_1552674483.9866457-0/experiment.dill differ diff --git a/code/results/exp-mixed-soup-_1552674483.9866457-0/log.txt b/code/results/exp-mixed-soup-_1552674483.9866457-0/log.txt new file mode 100644 index 0000000..3fff177 --- /dev/null +++ b/code/results/exp-mixed-soup-_1552674483.9866457-0/log.txt @@ -0,0 +1,8 @@ +TrainingNeuralNetworkDecorator activiation='linear' use_bias=False +{'xs': [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100], 'ys': [0.0, 0.0, 0.1, 0.0, 0.0, 0.0, 0.0, 0.1, 0.0, 0.0, 0.0], 'zs': [0.0, 0.0, 0.7, 1.9, 3.6, 4.3, 6.0, 6.1, 8.3, 7.7, 8.8]} + + +TrainingNeuralNetworkDecorator activiation='linear' use_bias=False +{'xs': [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100], 'ys': [0.8, 0.4, 0.4, 0.3, 0.2, 0.2, 0.2, 0.2, 0.2, 0.4, 0.3], 'zs': [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]} + + diff --git a/code/results/exp-training_fixpoint-_1552658296.0913951-0/all_counters.dill b/code/results/exp-training_fixpoint-_1552658296.0913951-0/all_counters.dill new file mode 100644 index 0000000..abadfdf Binary files /dev/null and b/code/results/exp-training_fixpoint-_1552658296.0913951-0/all_counters.dill differ diff --git a/code/results/exp-training_fixpoint-_1552658296.0913951-0/all_counters.html b/code/results/exp-training_fixpoint-_1552658296.0913951-0/all_counters.html new file mode 100644 index 0000000..d5d4f81 --- /dev/null +++ b/code/results/exp-training_fixpoint-_1552658296.0913951-0/all_counters.html @@ -0,0 +1,7 @@ +
\ No newline at end of file diff --git a/code/results/exp-training_fixpoint-_1552658296.0913951-0/all_names.dill b/code/results/exp-training_fixpoint-_1552658296.0913951-0/all_names.dill new file mode 100644 index 0000000..745970a Binary files /dev/null and b/code/results/exp-training_fixpoint-_1552658296.0913951-0/all_names.dill differ diff --git a/code/results/exp-training_fixpoint-_1552658296.0913951-0/experiment.dill b/code/results/exp-training_fixpoint-_1552658296.0913951-0/experiment.dill new file mode 100644 index 0000000..df53769 Binary files /dev/null and b/code/results/exp-training_fixpoint-_1552658296.0913951-0/experiment.dill differ diff --git a/code/results/exp-training_fixpoint-_1552658296.0913951-0/log.txt b/code/results/exp-training_fixpoint-_1552658296.0913951-0/log.txt new file mode 100644 index 0000000..156be9d --- /dev/null +++ b/code/results/exp-training_fixpoint-_1552658296.0913951-0/log.txt @@ -0,0 +1,12 @@ +WeightwiseNeuralNetwork activiation='linear' use_bias=False +{'divergent': 0, 'fix_zero': 0, 'fix_other': 50, 'fix_sec': 0, 'other': 0} + + +AggregatingNeuralNetwork activiation='linear' use_bias=False +{'divergent': 0, 'fix_zero': 0, 'fix_other': 0, 'fix_sec': 0, 'other': 50} + + +RecurrentNeuralNetwork activiation='linear' use_bias=False +{'divergent': 38, 'fix_zero': 0, 'fix_other': 0, 'fix_sec': 0, 'other': 12} + + diff --git a/code/results/exp-training_fixpoint-_1552658296.0913951-0/trajectorys.dill b/code/results/exp-training_fixpoint-_1552658296.0913951-0/trajectorys.dill new file mode 100644 index 0000000..8f76d57 Binary files /dev/null and b/code/results/exp-training_fixpoint-_1552658296.0913951-0/trajectorys.dill differ diff --git a/code/results/known_fixpoint_variation/experiment.dill b/code/results/known_fixpoint_variation/experiment.dill new file mode 100644 index 0000000..c5ba06f Binary files /dev/null and b/code/results/known_fixpoint_variation/experiment.dill differ diff --git a/code/results/known_fixpoint_variation/experiment.html b/code/results/known_fixpoint_variation/experiment.html new file mode 100644 index 0000000..aefe4a9 --- /dev/null +++ b/code/results/known_fixpoint_variation/experiment.html @@ -0,0 +1,7 @@ +
\ No newline at end of file diff --git a/code/results/known_fixpoint_variation/log.txt b/code/results/known_fixpoint_variation/log.txt new file mode 100644 index 0000000..50bcc16 --- /dev/null +++ b/code/results/known_fixpoint_variation/log.txt @@ -0,0 +1,30 @@ +variation 10e-0 +avg time to vergence 3.63 +avg time as fixpoint 0 +variation 10e-1 +avg time to vergence 5.02 +avg time as fixpoint 0 +variation 10e-2 +avg time to vergence 6.46 +avg time as fixpoint 0 +variation 10e-3 +avg time to vergence 8.04 +avg time as fixpoint 0 +variation 10e-4 +avg time to vergence 9.61 +avg time as fixpoint 0.04 +variation 10e-5 +avg time to vergence 11.23 +avg time as fixpoint 1.38 +variation 10e-6 +avg time to vergence 12.99 +avg time as fixpoint 3.23 +variation 10e-7 +avg time to vergence 14.58 +avg time as fixpoint 4.84 +variation 10e-8 +avg time to vergence 21.95 +avg time as fixpoint 11.91 +variation 10e-9 +avg time to vergence 26.45 +avg time as fixpoint 16.47 diff --git a/code/results/known_fixpoint_variation_box.png b/code/results/known_fixpoint_variation_box.png new file mode 100644 index 0000000..8231b1a Binary files /dev/null and b/code/results/known_fixpoint_variation_box.png differ diff --git a/code/results/learn_severity.png b/code/results/learn_severity.png new file mode 100644 index 0000000..9dcba54 Binary files /dev/null and b/code/results/learn_severity.png differ diff --git a/code/results/mixed_self_fixpoints.png b/code/results/mixed_self_fixpoints.png new file mode 100644 index 0000000..93ffb26 Binary files /dev/null and b/code/results/mixed_self_fixpoints.png differ diff --git a/code/results/mixed_soup.png b/code/results/mixed_soup.png new file mode 100644 index 0000000..a988809 Binary files /dev/null and b/code/results/mixed_soup.png differ diff --git a/code/results/newplot (1).png b/code/results/newplot (1).png new file mode 100644 index 0000000..9592dc4 Binary files /dev/null and b/code/results/newplot (1).png differ diff --git a/code/results/newplot(2).png b/code/results/newplot(2).png new file mode 100644 index 0000000..65aa86e Binary files /dev/null and b/code/results/newplot(2).png differ diff --git a/code/results/self_application_aggregation_network/experiment.dill b/code/results/self_application_aggregation_network/experiment.dill new file mode 100644 index 0000000..3a1b6fd Binary files /dev/null and b/code/results/self_application_aggregation_network/experiment.dill differ diff --git a/code/results/self_application_aggregation_network/log.txt b/code/results/self_application_aggregation_network/log.txt new file mode 100644 index 0000000..b09a718 --- /dev/null +++ b/code/results/self_application_aggregation_network/log.txt @@ -0,0 +1 @@ +{'divergent': 0, 'fix_zero': 10, 'fix_other': 0, 'fix_sec': 0, 'other': 0} diff --git a/code/results/self_application_aggregation_network/trajectorys.dill b/code/results/self_application_aggregation_network/trajectorys.dill new file mode 100644 index 0000000..3a1b6fd Binary files /dev/null and b/code/results/self_application_aggregation_network/trajectorys.dill differ diff --git a/code/results/self_application_aggregation_network/trajectorys.html b/code/results/self_application_aggregation_network/trajectorys.html new file mode 100644 index 0000000..60814de --- /dev/null +++ b/code/results/self_application_aggregation_network/trajectorys.html @@ -0,0 +1,7 @@ +
\ No newline at end of file diff --git a/code/results/self_apply1.png b/code/results/self_apply1.png new file mode 100644 index 0000000..59e19b0 Binary files /dev/null and b/code/results/self_apply1.png differ diff --git a/code/results/self_apply2.png b/code/results/self_apply2.png new file mode 100644 index 0000000..e4a4d48 Binary files /dev/null and b/code/results/self_apply2.png differ diff --git a/code/results/self_train1.png b/code/results/self_train1.png new file mode 100644 index 0000000..9de3c09 Binary files /dev/null and b/code/results/self_train1.png differ diff --git a/code/results/self_train2.png b/code/results/self_train2.png new file mode 100644 index 0000000..a2eec49 Binary files /dev/null and b/code/results/self_train2.png differ diff --git a/code/results/self_training_weightwise_network/experiment.dill b/code/results/self_training_weightwise_network/experiment.dill new file mode 100644 index 0000000..9afbfa2 Binary files /dev/null and b/code/results/self_training_weightwise_network/experiment.dill differ diff --git a/code/results/self_training_weightwise_network/log.txt b/code/results/self_training_weightwise_network/log.txt new file mode 100644 index 0000000..e69de29 diff --git a/code/results/self_training_weightwise_network/trajectorys.dill b/code/results/self_training_weightwise_network/trajectorys.dill new file mode 100644 index 0000000..9afbfa2 Binary files /dev/null and b/code/results/self_training_weightwise_network/trajectorys.dill differ diff --git a/code/results/self_training_weightwise_network/trajectorys.html b/code/results/self_training_weightwise_network/trajectorys.html new file mode 100644 index 0000000..414fdde --- /dev/null +++ b/code/results/self_training_weightwise_network/trajectorys.html @@ -0,0 +1,7 @@ +
\ No newline at end of file diff --git a/code/results/soup1.png b/code/results/soup1.png new file mode 100644 index 0000000..e4bc26e Binary files /dev/null and b/code/results/soup1.png differ diff --git a/code/results/soup2.png b/code/results/soup2.png new file mode 100644 index 0000000..45ec01c Binary files /dev/null and b/code/results/soup2.png differ diff --git a/code/results/training_fixpoints.png b/code/results/training_fixpoints.png new file mode 100644 index 0000000..c8d86f3 Binary files /dev/null and b/code/results/training_fixpoints.png differ diff --git a/code/setups/applying-fixpoints.py b/code/setups/applying-fixpoints.py new file mode 100644 index 0000000..e8bdc9f --- /dev/null +++ b/code/setups/applying-fixpoints.py @@ -0,0 +1,70 @@ +import sys +import os + +# Concat top Level dir to system environmental variables +sys.path += os.path.join('..', '.') + +from util import * +from experiment import * +from network import * + +import keras.backend as K + +def generate_counters(): + return {'divergent': 0, 'fix_zero': 0, 'fix_other': 0, 'fix_sec': 0, 'other': 0} + +def count(counters, net, notable_nets=[]): + if net.is_diverged(): + counters['divergent'] += 1 + elif net.is_fixpoint(): + if net.is_zero(): + counters['fix_zero'] += 1 + else: + counters['fix_other'] += 1 + notable_nets += [net] + elif net.is_fixpoint(2): + counters['fix_sec'] += 1 + notable_nets += [net] + else: + counters['other'] += 1 + return counters, notable_nets + + +if __name__ == '__main__': + + with Experiment('applying_fixpoint') as exp: + exp.trials = 50 + exp.run_count = 100 + exp.epsilon = 1e-4 + net_generators = [] + for activation in ['linear']: # , 'sigmoid', 'relu']: + for use_bias in [False]: + net_generators += [lambda activation=activation, use_bias=use_bias: WeightwiseNeuralNetwork(width=2, depth=2).with_keras_params(activation=activation, use_bias=use_bias)] + net_generators += [lambda activation=activation, use_bias=use_bias: AggregatingNeuralNetwork(aggregates=4, width=2, depth=2).with_keras_params(activation=activation, use_bias=use_bias)] + net_generators += [lambda activation=activation, use_bias=use_bias: RecurrentNeuralNetwork(width=2, depth=2).with_keras_params(activation=activation, use_bias=use_bias)] + all_counters = [] + all_notable_nets = [] + all_names = [] + for net_generator_id, net_generator in enumerate(net_generators): + counters = generate_counters() + notable_nets = [] + for _ in tqdm(range(exp.trials)): + net = ParticleDecorator(net_generator()) + net.with_params(epsilon=exp.epsilon) + name = str(net.net.__class__.__name__) + " activiation='" + str(net.get_keras_params().get('activation')) + "' use_bias=" + str(net.get_keras_params().get('use_bias')) + for run_id in range(exp.run_count): + loss = net.self_attack() + count(counters, net, notable_nets) + all_counters += [counters] + all_notable_nets += [notable_nets] + all_names += [name] + K.clear_session() + exp.save(all_counters=all_counters) + exp.save(trajectorys=exp.without_particles()) + # net types reached in the end + # exp.save(all_notable_nets=all_notable_nets) + exp.save(all_names=all_names) #experiment setups + for exp_id, counter in enumerate(all_counters): + exp.log(all_names[exp_id]) + exp.log(all_counters[exp_id]) + exp.log('\n') diff --git a/code/setups/experiments/exp-learn-from-soup-_1552658566.5572753-0/all_data.dill b/code/setups/experiments/exp-learn-from-soup-_1552658566.5572753-0/all_data.dill new file mode 100644 index 0000000..95eaad1 Binary files /dev/null and b/code/setups/experiments/exp-learn-from-soup-_1552658566.5572753-0/all_data.dill differ diff --git a/code/setups/experiments/exp-learn-from-soup-_1552658566.5572753-0/all_data.html b/code/setups/experiments/exp-learn-from-soup-_1552658566.5572753-0/all_data.html new file mode 100644 index 0000000..25978e4 --- /dev/null +++ b/code/setups/experiments/exp-learn-from-soup-_1552658566.5572753-0/all_data.html @@ -0,0 +1,7 @@ +
\ No newline at end of file diff --git a/code/setups/experiments/exp-learn-from-soup-_1552658566.5572753-0/all_names.dill b/code/setups/experiments/exp-learn-from-soup-_1552658566.5572753-0/all_names.dill new file mode 100644 index 0000000..364954d Binary files /dev/null and b/code/setups/experiments/exp-learn-from-soup-_1552658566.5572753-0/all_names.dill differ diff --git a/code/setups/experiments/exp-learn-from-soup-_1552658566.5572753-0/experiment.dill b/code/setups/experiments/exp-learn-from-soup-_1552658566.5572753-0/experiment.dill new file mode 100644 index 0000000..c298169 Binary files /dev/null and b/code/setups/experiments/exp-learn-from-soup-_1552658566.5572753-0/experiment.dill differ diff --git a/code/setups/experiments/exp-learn-from-soup-_1552658566.5572753-0/log.txt b/code/setups/experiments/exp-learn-from-soup-_1552658566.5572753-0/log.txt new file mode 100644 index 0000000..58dd8f7 --- /dev/null +++ b/code/setups/experiments/exp-learn-from-soup-_1552658566.5572753-0/log.txt @@ -0,0 +1,4 @@ +TrainingNeuralNetworkDecorator activiation='linear' use_bias=False +{'xs': [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100], 'ys': [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], 'zs': [0.0, 1.2, 5.2, 7.4, 8.1, 9.1, 9.6, 9.8, 10.0, 9.9, 9.9]} + + diff --git a/code/setups/experiments/exp-learn-from-soup-_1552658566.5572753-0/soup.dill b/code/setups/experiments/exp-learn-from-soup-_1552658566.5572753-0/soup.dill new file mode 100644 index 0000000..bbdadf9 Binary files /dev/null and b/code/setups/experiments/exp-learn-from-soup-_1552658566.5572753-0/soup.dill differ diff --git a/code/setups/experiments/exp-learn-from-soup-_1552658566.5572753-0/soup.html b/code/setups/experiments/exp-learn-from-soup-_1552658566.5572753-0/soup.html new file mode 100644 index 0000000..b8d5d50 --- /dev/null +++ b/code/setups/experiments/exp-learn-from-soup-_1552658566.5572753-0/soup.html @@ -0,0 +1,7 @@ +
\ No newline at end of file diff --git a/code/setups/experiments/exp-learn-from-soup-_1552658566.5572753-0/soup.png b/code/setups/experiments/exp-learn-from-soup-_1552658566.5572753-0/soup.png new file mode 100644 index 0000000..303c16f Binary files /dev/null and b/code/setups/experiments/exp-learn-from-soup-_1552658566.5572753-0/soup.png differ diff --git a/code/setups/experiments/exp-training_fixpoint-_1552658296.0913951-0/all_counters.dill b/code/setups/experiments/exp-training_fixpoint-_1552658296.0913951-0/all_counters.dill new file mode 100644 index 0000000..abadfdf Binary files /dev/null and b/code/setups/experiments/exp-training_fixpoint-_1552658296.0913951-0/all_counters.dill differ diff --git a/code/setups/experiments/exp-training_fixpoint-_1552658296.0913951-0/all_counters.html b/code/setups/experiments/exp-training_fixpoint-_1552658296.0913951-0/all_counters.html new file mode 100644 index 0000000..44c48b0 --- /dev/null +++ b/code/setups/experiments/exp-training_fixpoint-_1552658296.0913951-0/all_counters.html @@ -0,0 +1,7 @@ +
\ No newline at end of file diff --git a/code/setups/experiments/exp-training_fixpoint-_1552658296.0913951-0/all_names.dill b/code/setups/experiments/exp-training_fixpoint-_1552658296.0913951-0/all_names.dill new file mode 100644 index 0000000..745970a Binary files /dev/null and b/code/setups/experiments/exp-training_fixpoint-_1552658296.0913951-0/all_names.dill differ diff --git a/code/setups/experiments/exp-training_fixpoint-_1552658296.0913951-0/experiment.dill b/code/setups/experiments/exp-training_fixpoint-_1552658296.0913951-0/experiment.dill new file mode 100644 index 0000000..df53769 Binary files /dev/null and b/code/setups/experiments/exp-training_fixpoint-_1552658296.0913951-0/experiment.dill differ diff --git a/code/setups/experiments/exp-training_fixpoint-_1552658296.0913951-0/log.txt b/code/setups/experiments/exp-training_fixpoint-_1552658296.0913951-0/log.txt new file mode 100644 index 0000000..156be9d --- /dev/null +++ b/code/setups/experiments/exp-training_fixpoint-_1552658296.0913951-0/log.txt @@ -0,0 +1,12 @@ +WeightwiseNeuralNetwork activiation='linear' use_bias=False +{'divergent': 0, 'fix_zero': 0, 'fix_other': 50, 'fix_sec': 0, 'other': 0} + + +AggregatingNeuralNetwork activiation='linear' use_bias=False +{'divergent': 0, 'fix_zero': 0, 'fix_other': 0, 'fix_sec': 0, 'other': 50} + + +RecurrentNeuralNetwork activiation='linear' use_bias=False +{'divergent': 38, 'fix_zero': 0, 'fix_other': 0, 'fix_sec': 0, 'other': 12} + + diff --git a/code/setups/experiments/exp-training_fixpoint-_1552658296.0913951-0/trajectorys.dill b/code/setups/experiments/exp-training_fixpoint-_1552658296.0913951-0/trajectorys.dill new file mode 100644 index 0000000..8f76d57 Binary files /dev/null and b/code/setups/experiments/exp-training_fixpoint-_1552658296.0913951-0/trajectorys.dill differ diff --git a/code/setups/experiments/exp-weightwise_self_application-_1552664922.4501734-0/experiment.dill b/code/setups/experiments/exp-weightwise_self_application-_1552664922.4501734-0/experiment.dill new file mode 100644 index 0000000..654df69 Binary files /dev/null and b/code/setups/experiments/exp-weightwise_self_application-_1552664922.4501734-0/experiment.dill differ diff --git a/code/setups/experiments/exp-weightwise_self_application-_1552664922.4501734-0/log.txt b/code/setups/experiments/exp-weightwise_self_application-_1552664922.4501734-0/log.txt new file mode 100644 index 0000000..c48d569 --- /dev/null +++ b/code/setups/experiments/exp-weightwise_self_application-_1552664922.4501734-0/log.txt @@ -0,0 +1 @@ +{'divergent': 11, 'fix_zero': 9, 'fix_other': 0, 'fix_sec': 0, 'other': 0} diff --git a/code/setups/experiments/exp-weightwise_self_application-_1552664922.4501734-0/trajectorys.dill b/code/setups/experiments/exp-weightwise_self_application-_1552664922.4501734-0/trajectorys.dill new file mode 100644 index 0000000..654df69 Binary files /dev/null and b/code/setups/experiments/exp-weightwise_self_application-_1552664922.4501734-0/trajectorys.dill differ diff --git a/code/setups/experiments/exp-weightwise_self_application-_1552664922.4501734-0/trajectorys.html b/code/setups/experiments/exp-weightwise_self_application-_1552664922.4501734-0/trajectorys.html new file mode 100644 index 0000000..cb9a800 --- /dev/null +++ b/code/setups/experiments/exp-weightwise_self_application-_1552664922.4501734-0/trajectorys.html @@ -0,0 +1,7 @@ +
\ No newline at end of file diff --git a/code/setups/fixpoint-density.py b/code/setups/fixpoint-density.py new file mode 100644 index 0000000..1c0419f --- /dev/null +++ b/code/setups/fixpoint-density.py @@ -0,0 +1,67 @@ +import sys +import os +# Concat top Level dir to system environmental variables +sys.path += os.path.join('..', '.') + +from util import * +from experiment import * +from network import * + +import keras.backend + +def generate_counters(): + return {'divergent': 0, 'fix_zero': 0, 'fix_other': 0, 'fix_sec': 0, 'other': 0} + +def count(counters, net, notable_nets=[]): + if net.is_diverged(): + counters['divergent'] += 1 + elif net.is_fixpoint(): + if net.is_zero(): + counters['fix_zero'] += 1 + else: + counters['fix_other'] += 1 + notable_nets += [net] + elif net.is_fixpoint(2): + counters['fix_sec'] += 1 + notable_nets += [net] + else: + counters['other'] += 1 + return counters, notable_nets + + +if __name__ == '__main__': + with Experiment('fixpoint-density') as exp: + #NOTE: settings could/should stay this way + #FFT doesn't work though + exp.trials = 100000 + exp.epsilon = 1e-4 + net_generators = [] + for activation in ['linear']: + net_generators += [lambda activation=activation: WeightwiseNeuralNetwork(width=2, depth=2).with_keras_params(activation=activation, use_bias=False)] + net_generators += [lambda activation=activation: AggregatingNeuralNetwork(aggregates=4, width=2, depth=2).with_keras_params(activation=activation, use_bias=False)] + # net_generators += [lambda activation=activation: FFTNeuralNetwork(aggregates=4, width=2, depth=2).with_keras_params(activation=activation, use_bias=False)] + # net_generators += [lambda activation=activation: RecurrentNeuralNetwork(width=2, depth=2).with_keras_params(activation=activation, use_bias=False)] + all_counters = [] + all_notable_nets = [] + all_names = [] + for net_generator_id, net_generator in enumerate(net_generators): + counters = generate_counters() + notable_nets = [] + for _ in tqdm(range(exp.trials)): + net = net_generator().with_params(epsilon=exp.epsilon) + net = ParticleDecorator(net) + name = str(net.__class__.__name__) + " activiation='" + str(net.get_keras_params().get('activation')) + "' use_bias='" + str(net.get_keras_params().get('use_bias')) + "'" + count(counters, net, notable_nets) + keras.backend.clear_session() + all_counters += [counters] + # all_notable_nets += [notable_nets] + all_names += [name] + exp.save(all_counters=all_counters) + exp.save(all_notable_nets=all_notable_nets) + exp.save(all_names=all_names) + for exp_id, counter in enumerate(all_counters): + exp.log(all_names[exp_id]) + exp.log(all_counters[exp_id]) + exp.log('\n') + + print('Done') diff --git a/code/setups/known-fixpoint-variation.py b/code/setups/known-fixpoint-variation.py new file mode 100644 index 0000000..e1c070f --- /dev/null +++ b/code/setups/known-fixpoint-variation.py @@ -0,0 +1,93 @@ +import sys + +import os + +# Concat top Level dir to system environmental variables +sys.path += os.path.join('..', '.') + +from util import * +from experiment import * +from network import * +from soup import prng + +import keras.backend + + +from statistics import mean +avg = mean + + +def generate_fixpoint_weights(): + return [ + np.array([[1.0, 0.0], [0.0, 0.0], [0.0, 0.0], [0.0, 0.0]], dtype=np.float32), + np.array([[1.0, 0.0], [0.0, 0.0]], dtype=np.float32), + np.array([[1.0], [0.0]], dtype=np.float32) + ] + + +def generate_fixpoint_net(): + #NOTE: Weightwise only is all we can do right now IMO + net = WeightwiseNeuralNetwork(width=2, depth=2).with_keras_params(activation='sigmoid') + # I don't know if this work for aggregaeting. We don't actually need it, though. + # net = AggregatingNeuralNetwork(aggregates=4, width=2, depth=2).with_keras_params(activation='sigmoid') + net.set_weights(generate_fixpoint_weights()) + return net + + +def vary(old_weights, e=1.0): + new_weights = copy.deepcopy(old_weights) + for layer_id, layer in enumerate(new_weights): + for cell_id, cell in enumerate(layer): + for weight_id, weight in enumerate(cell): + if prng() < 0.5: + new_weights[layer_id][cell_id][weight_id] = weight + prng() * e + else: + new_weights[layer_id][cell_id][weight_id] = weight - prng() * e + return new_weights + + +if __name__ == '__main__': + with Experiment('known-fixpoint-variation') as exp: + exp.depth = 10 + exp.trials = 100 + exp.max_steps = 100 + exp.epsilon = 1e-4 + exp.xs = [] + exp.ys = [] + exp.zs = [] + exp.notable_nets = [] + current_scale = 1.0 + for _ in range(exp.depth): + print('variation scale ' + str(current_scale)) + for _ in tqdm(range(exp.trials)): + net = generate_fixpoint_net().with_params(epsilon=exp.epsilon) + net = ParticleDecorator(net) + net.set_weights(vary(net.get_weights(), current_scale)) + time_to_something = 0 + time_as_fixpoint = 0 + still_fixpoint = True + for _ in range(exp.max_steps): + net.self_attack() + if net.is_zero() or net.is_diverged(): + break + if net.is_fixpoint(): + if still_fixpoint: + time_as_fixpoint += 1 + else: + print('remarkable') + exp.notable_nets += [net.get_weights()] + still_fixpoint = True + else: + still_fixpoint = False + time_to_something += 1 + exp.xs += [current_scale] + # time steps taken to reach divergence or zero (reaching another fix-point is basically never happening) + exp.ys += [time_to_something] + # time steps still regarded as sthe initial fix-point + exp.zs += [time_as_fixpoint] + keras.backend.clear_session() + current_scale /= 10.0 + for d in range(exp.depth): + exp.log('variation 10e-' + str(d)) + exp.log('avg time to vergence ' + str(avg(exp.ys[d*exp.trials:(d+1) * exp.trials]))) + exp.log('avg time as fixpoint ' + str(avg(exp.zs[d*exp.trials:(d+1) * exp.trials]))) diff --git a/code/setups/learn_from_soup.py b/code/setups/learn_from_soup.py new file mode 100644 index 0000000..f6bcb44 --- /dev/null +++ b/code/setups/learn_from_soup.py @@ -0,0 +1,110 @@ +import sys +import os + +# Concat top Level dir to system environmental variables +sys.path += os.path.join('..', '.') + +from typing import Tuple + +from util import * +from experiment import * +from network import * +from soup import * + + +import keras.backend + +from statistics import mean +avg = mean + + +def generate_counters(): + """ + Initial build of the counter dict, to store counts. + + :rtype: dict + :return: dictionary holding counter for: 'divergent', 'fix_zero', 'fix_sec', 'other' + """ + return {'divergent': 0, 'fix_zero': 0, 'fix_other': 0, 'fix_sec': 0, 'other': 0} + + +def count(counters, soup, notable_nets=[]): + """ + Count the occurences ot the types of weight trajectories. + + :param counters: A counter dictionary. + :param soup: A Soup + :param notable_nets: A list to store and save intersting candidates + + :rtype Tuple[dict, list] + :return: Both the counter dictionary and the list of interessting nets. + """ + + for net in soup.particles: + if net.is_diverged(): + counters['divergent'] += 1 + elif net.is_fixpoint(): + if net.is_zero(): + counters['fix_zero'] += 1 + else: + counters['fix_other'] += 1 + # notable_nets += [net] + # elif net.is_fixpoint(2): + # counters['fix_sec'] += 1 + # notable_nets += [net] + else: + counters['other'] += 1 + return counters, notable_nets + + +if __name__ == '__main__': + + with SoupExperiment('learn-from-soup') as exp: + exp.soup_size = 10 + exp.soup_life = 100 + exp.trials = 10 + exp.learn_from_severity_values = [10 * i for i in range(11)] + exp.epsilon = 1e-4 + net_generators = [] + for activation in ['linear']: # ['sigmoid', 'linear', 'relu']: + for use_bias in [False]: + net_generators += [lambda activation=activation, use_bias=use_bias: WeightwiseNeuralNetwork(width=2, depth=2).with_keras_params(activation=activation, use_bias=use_bias)] + # net_generators += [lambda activation=activation, use_bias=use_bias: AggregatingNeuralNetwork(aggregates=4, width=2, depth=2).with_keras_params(activation=activation, use_bias=use_bias)] + # net_generators += [lambda activation=activation, use_bias=use_bias: RecurrentNeuralNetwork(width=2, depth=2).with_keras_params(activation=activation, use_bias=use_bias)] + + all_names = [] + all_data = [] + for net_generator_id, net_generator in enumerate(net_generators): + xs = [] + ys = [] + zs = [] + notable_nets = [] + for learn_from_severity in exp.learn_from_severity_values: + counters = generate_counters() + results = [] + for _ in tqdm(range(exp.trials)): + soup = Soup(exp.soup_size, lambda net_generator=net_generator,exp=exp: TrainingNeuralNetworkDecorator(net_generator()).with_params(epsilon=exp.epsilon)) + soup.with_params(attacking_rate=-1, learn_from_rate=0.1, train=0, learn_from_severity=learn_from_severity) + soup.seed() + name = str(soup.particles[0].net.__class__.__name__) + " activiation='" + str(soup.particles[0].get_keras_params().get('activation')) + "' use_bias=" + str(soup.particles[0].get_keras_params().get('use_bias')) + for time in range(exp.soup_life): + soup.evolve() + count(counters, soup, notable_nets) + keras.backend.clear_session() + + xs += [learn_from_severity] + ys += [float(counters['fix_zero']) / float(exp.trials)] + zs += [float(counters['fix_other']) / float(exp.trials)] + all_names += [name] + # xs: learn_from_intensity according to exp.learn_from_intensity_values + # ys: zero-fixpoints after life time + # zs: non-zero-fixpoints after life time + all_data += [{'xs':xs, 'ys':ys, 'zs':zs}] + + exp.save(all_names=all_names) + exp.save(all_data=all_data) + exp.save(soup=soup.without_particles()) + for exp_id, name in enumerate(all_names): + exp.log(all_names[exp_id]) + exp.log(all_data[exp_id]) + exp.log('\n') diff --git a/code/setups/mixed-self-fixpoints.py b/code/setups/mixed-self-fixpoints.py new file mode 100644 index 0000000..d7c494e --- /dev/null +++ b/code/setups/mixed-self-fixpoints.py @@ -0,0 +1,101 @@ +import sys +import os + +from typing import Tuple + +# Concat top Level dir to system environmental variables +sys.path += os.path.join('..', '.') + +from util import * +from experiment import * +from network import * + +import keras.backend + + +def generate_counters(): + """ + Initial build of the counter dict, to store counts. + + :rtype: dict + :return: dictionary holding counter for: 'divergent', 'fix_zero', 'fix_sec', 'other' + """ + return {'divergent': 0, 'fix_zero': 0, 'fix_other': 0, 'fix_sec': 0, 'other': 0} + + +def count(counters, net, notable_nets=[]): + """ + Count the occurences ot the types of weight trajectories. + + :param counters: A counter dictionary. + :param net: A Neural Network + :param notable_nets: A list to store and save intersting candidates + + :rtype Tuple[dict, list] + :return: Both the counter dictionary and the list of interessting nets. + """ + + if net.is_diverged(): + counters['divergent'] += 1 + elif net.is_fixpoint(): + if net.is_zero(): + counters['fix_zero'] += 1 + else: + counters['fix_other'] += 1 + notable_nets += [net] + elif net.is_fixpoint(2): + counters['fix_sec'] += 1 + notable_nets += [net] + else: + counters['other'] += 1 + return counters, notable_nets + +if __name__ == '__main__': + + with Experiment('mixed-self-fixpoints') as exp: + exp.trials = 20 + exp.selfattacks = 4 + exp.trains_per_selfattack_values = [50 * i for i in range(11)] + exp.epsilon = 1e-4 + net_generators = [] + for activation in ['linear']: # , 'sigmoid', 'relu']: + for use_bias in [False]: + net_generators += [lambda activation=activation, use_bias=use_bias: WeightwiseNeuralNetwork(width=2, depth=2).with_keras_params(activation=activation, use_bias=use_bias)] + net_generators += [lambda activation=activation, use_bias=use_bias: AggregatingNeuralNetwork(aggregates=4, width=2, depth=2).with_keras_params(activation=activation, use_bias=use_bias)] + # net_generators += [lambda activation=activation, use_bias=use_bias: FFTNeuralNetwork(aggregates=4, width=2, depth=2).with_keras_params(activation=activation, use_bias=use_bias)] + net_generators += [lambda activation=activation, use_bias=use_bias: RecurrentNeuralNetwork(width=2, depth=2).with_keras_params(activation=activation, use_bias=use_bias)] + + all_names = [] + all_data = [] + + for net_generator_id, net_generator in enumerate(net_generators): + xs = [] + ys = [] + for trains_per_selfattack in exp.trains_per_selfattack_values: + counters = generate_counters() + notable_nets = [] + for _ in tqdm(range(exp.trials)): + net = ParticleDecorator(net_generator()) + net = TrainingNeuralNetworkDecorator(net).with_params(epsilon=exp.epsilon) + name = str(net.net.net.__class__.__name__) + " activiation='" + str(net.get_keras_params().get('activation')) + "' use_bias=" + str(net.get_keras_params().get('use_bias')) + for selfattack_id in range(exp.selfattacks): + net.self_attack() + for train_id in range(trains_per_selfattack): + loss = net.compiled().train(epoch=selfattack_id*trains_per_selfattack+train_id) + if net.is_diverged() or net.is_fixpoint(): + break + count(counters, net, notable_nets) + keras.backend.clear_session() + xs += [trains_per_selfattack] + ys += [float(counters['fix_zero'] + counters['fix_other']) / float(exp.trials)] + all_names += [name] + # xs: how many trains per self-attack from exp.trains_per_selfattack_values + # ys: average amount of fixpoints found + all_data += [{'xs': xs, 'ys': ys}] + + exp.save(all_names=all_names) + exp.save(all_data=all_data) + for exp_id, name in enumerate(all_names): + exp.log(all_names[exp_id]) + exp.log(all_data[exp_id]) + exp.log('\n') diff --git a/code/setups/mixed-soup.py b/code/setups/mixed-soup.py new file mode 100644 index 0000000..2471e2c --- /dev/null +++ b/code/setups/mixed-soup.py @@ -0,0 +1,108 @@ +import sys +import os + +# Concat top Level dir to system environmental variables +sys.path += os.path.join('..', '.') + +from typing import Tuple + +from util import * +from experiment import * +from network import * +from soup import * + +import keras.backend + + +def generate_counters(): + """ + Initial build of the counter dict, to store counts. + + :rtype: dict + :return: dictionary holding counter for: 'divergent', 'fix_zero', 'fix_sec', 'other' + """ + return {'divergent': 0, 'fix_zero': 0, 'fix_other': 0, 'fix_sec': 0, 'other': 0} + + +def count(counters, soup, notable_nets=[]): + """ + Count the occurences ot the types of weight trajectories. + + :param counters: A counter dictionary. + :param soup: A Soup + :param notable_nets: A list to store and save intersting candidates + + :rtype Tuple[dict, list] + :return: Both the counter dictionary and the list of interessting nets. + """ + + for net in soup.particles: + if net.is_diverged(): + counters['divergent'] += 1 + elif net.is_fixpoint(): + if net.is_zero(): + counters['fix_zero'] += 1 + else: + counters['fix_other'] += 1 + # notable_nets += [net] + # elif net.is_fixpoint(2): + # counters['fix_sec'] += 1 + # notable_nets += [net] + else: + counters['other'] += 1 + return counters, notable_nets + +if __name__ == '__main__': + + with Experiment('mixed-soup') as exp: + exp.trials = 10 + exp.soup_size = 10 + exp.soup_life = 5 + exp.trains_per_selfattack_values = [10 * i for i in range(11)] + exp.epsilon = 1e-4 + net_generators = [] + for activation in ['linear']: # ['linear', 'sigmoid', 'relu']: + for use_bias in [False]: + net_generators += [lambda activation=activation, use_bias=use_bias: WeightwiseNeuralNetwork(width=2, depth=2).with_keras_params(activation=activation, use_bias=use_bias)] + net_generators += [lambda activation=activation, use_bias=use_bias: AggregatingNeuralNetwork(aggregates=4, width=2, depth=2).with_keras_params(activation=activation, use_bias=use_bias)] + # net_generators += [lambda activation=activation, use_bias=use_bias: RecurrentNeuralNetwork(width=2, depth=2).with_keras_params(activation=activation, use_bias=use_bias)] + + all_names = [] + all_data = [] + for net_generator_id, net_generator in enumerate(net_generators): + xs = [] + ys = [] + zs = [] + for trains_per_selfattack in exp.trains_per_selfattack_values: + counters = generate_counters() + notable_nets = [] + for soup_idx in tqdm(range(exp.trials)): + soup = Soup(exp.soup_size, + lambda net_generator=net_generator, exp=exp: TrainingNeuralNetworkDecorator( + net_generator()).with_params(epsilon=exp.epsilon)) + soup.with_params(attacking_rate=0.1, learn_from_rate=-1, train=trains_per_selfattack, + learn_from_severity=-1) + soup.seed() + name = str(soup.particles[0].net.__class__.__name__) + " activiation='" + str( + soup.particles[0].get_keras_params().get('activation')) + "' use_bias=" + str( + soup.particles[0].get_keras_params().get('use_bias')) + for _ in range(exp.soup_life): + soup.evolve() + count(counters, soup, notable_nets) + keras.backend.clear_session() + + xs += [trains_per_selfattack] + ys += [float(counters['fix_zero']) / float(exp.trials)] + zs += [float(counters['fix_other']) / float(exp.trials)] + all_names += [name] + # xs: how many trains per self-attack from exp.trains_per_selfattack_values + # ys: average amount of zero-fixpoints found + # zs: average amount of non-zero fixpoints + all_data += [{'xs': xs, 'ys': ys, 'zs': zs}] + + exp.save(all_names=all_names) + exp.save(all_data=all_data) + for exp_id, name in enumerate(all_names): + exp.log(all_names[exp_id]) + exp.log(all_data[exp_id]) + exp.log('\n') diff --git a/code/setups/network_trajectorys.py b/code/setups/network_trajectorys.py new file mode 100644 index 0000000..73a7254 --- /dev/null +++ b/code/setups/network_trajectorys.py @@ -0,0 +1,112 @@ +import sys +import os + +# Concat top Level dir to system environmental variables +sys.path += os.path.join('..', '.') + +from soup import * +from experiment import * + + +if __name__ == '__main__': + def run_exp(net, prints=False): + # INFO Run_ID needs to be more than 0, so that exp stores the trajectories! + exp.run_net(net, 100, run_id=run_id + 1) + exp.historical_particles[run_id] = net + if prints: + print("Fixpoint? " + str(net.is_fixpoint())) + print("Loss " + str(loss)) + + if True: + # WeightWise Neural Network + with FixpointExperiment(name="weightwise_self_application") as exp: + for run_id in tqdm(range(20)): + net = ParticleDecorator(WeightwiseNeuralNetwork(width=2, depth=2) + .with_keras_params(activation='linear')) + run_exp(net) + K.clear_session() + exp.log(exp.counters) + exp.save(trajectorys=exp.without_particles()) + + if False: + # Aggregating Neural Network + with FixpointExperiment(name="aggregating_self_application") as exp: + for run_id in tqdm(range(10)): + net = ParticleDecorator(AggregatingNeuralNetwork(aggregates=4, width=2, depth=2) + .with_keras_params(activation='linear')) + run_exp(net) + K.clear_session() + exp.log(exp.counters) + exp.save(trajectorys=exp.without_particles()) + + if False: + #FFT Neural Network + with FixpointExperiment() as exp: + for run_id in tqdm(range(10)): + net = ParticleDecorator(FFTNeuralNetwork(aggregates=4, width=2, depth=2) + .with_keras_params(activation='linear')) + run_exp(net) + K.clear_session() + exp.log(exp.counters) + exp.save(trajectorys=exp.without_particles()) + + if False: + # ok so this works quite realiably + with FixpointExperiment(name="weightwise_learning") as exp: + for i in range(10): + run_count = 100 + net = TrainingNeuralNetworkDecorator(ParticleDecorator(WeightwiseNeuralNetwork(width=2, depth=2))) + net.with_params(epsilon=0.0001).with_keras_params(activation='linear') + exp.historical_particles[net.get_uid()] = net + for run_id in tqdm(range(run_count+1)): + net.compiled() + loss = net.train(epoch=run_id) + # run_exp(net) + # net.save_state(time=run_id) + K.clear_session() + exp.save(trajectorys=exp.without_particles()) + + if False: + # ok so this works quite realiably + with FixpointExperiment(name="aggregating_learning") as exp: + for i in range(10): + run_count = 100 + net = TrainingNeuralNetworkDecorator(ParticleDecorator(AggregatingNeuralNetwork(4, width=2, depth=2))) + net.with_params(epsilon=0.0001).with_keras_params(activation='linear') + exp.historical_particles[net.get_uid()] = net + for run_id in tqdm(range(run_count+1)): + net.compiled() + loss = net.train(epoch=run_id) + # run_exp(net) + # net.save_state(time=run_id) + K.clear_session() + exp.save(trajectorys=exp.without_particles()) + + if False: + # this explodes in our faces completely... NAN everywhere + # TODO: Wtf is happening here? + with FixpointExperiment() as exp: + run_count = 10000 + net = TrainingNeuralNetworkDecorator(RecurrentNeuralNetwork(width=2, depth=2))\ + .with_params(epsilon=0.1e-2).with_keras_params(optimizer='sgd', activation='linear') + for run_id in tqdm(range(run_count+1)): + loss = net.compiled().train() + if run_id % 500 == 0: + net.print_weights() + # print(net.apply_to_network(net)) + print("Fixpoint? " + str(net.is_fixpoint())) + print("Loss " + str(loss)) + print() + if False: + # and this gets somewhat interesting... we can still achieve non-trivial fixpoints + # over multiple applications when training enough in-between + with MixedFixpointExperiment() as exp: + for run_id in range(10): + net = TrainingNeuralNetworkDecorator(FFTNeuralNetwork(2, width=2, depth=2))\ + .with_params(epsilon=0.0001, activation='sigmoid') + exp.run_net(net, 500, 10) + + net.print_weights() + + print("Fixpoint? " + str(net.is_fixpoint())) + exp.log(exp.counters) diff --git a/code/setups/soup_trajectorys.py b/code/setups/soup_trajectorys.py new file mode 100644 index 0000000..4158cf7 --- /dev/null +++ b/code/setups/soup_trajectorys.py @@ -0,0 +1,32 @@ +import sys +import os + +# Concat top Level dir to system environmental variables +sys.path += os.path.join('..', '.') + +from soup import * +from experiment import * + + +if __name__ == '__main__': + if True: + with SoupExperiment("soup") as exp: + for run_id in range(1): + net_generator = lambda: TrainingNeuralNetworkDecorator(WeightwiseNeuralNetwork(2, 2)) \ + .with_keras_params(activation='linear').with_params(epsilon=0.0001) + # net_generator = lambda: TrainingNeuralNetworkDecorator(AggregatingNeuralNetwork(4, 2, 2))\ + # .with_keras_params(activation='linear') + # net_generator = lambda: TrainingNeuralNetworkDecorator(FFTNeuralNetwork(4, 2, 2))\ + # .with_keras_params(activation='linear') + # net_generator = lambda: RecurrentNeuralNetwork(2, 2).with_keras_params(activation='linear').with_params() + soup = Soup(20, net_generator).with_params(remove_divergent=True, remove_zero=True, + train=30, + learn_from_rate=-1) + soup.seed() + for _ in tqdm(range(100)): + soup.evolve() + exp.log(soup.count()) + # you can access soup.historical_particles[particle_uid].states[time_step]['loss'] + # or soup.historical_particles[particle_uid].states[time_step]['weights'] + # from soup.dill + exp.save(soup=soup.without_particles()) diff --git a/code/setups/training-fixpoints.py b/code/setups/training-fixpoints.py new file mode 100644 index 0000000..9d615d5 --- /dev/null +++ b/code/setups/training-fixpoints.py @@ -0,0 +1,70 @@ +import sys +import os + +# Concat top Level dir to system environmental variables +sys.path += os.path.join('..', '.') + +from util import * +from experiment import * +from network import * + +import keras.backend as K + +def generate_counters(): + return {'divergent': 0, 'fix_zero': 0, 'fix_other': 0, 'fix_sec': 0, 'other': 0} + +def count(counters, net, notable_nets=[]): + if net.is_diverged(): + counters['divergent'] += 1 + elif net.is_fixpoint(): + if net.is_zero(): + counters['fix_zero'] += 1 + else: + counters['fix_other'] += 1 + notable_nets += [net] + elif net.is_fixpoint(2): + counters['fix_sec'] += 1 + notable_nets += [net] + else: + counters['other'] += 1 + return counters, notable_nets + + +if __name__ == '__main__': + + with Experiment('training_fixpoint') as exp: + exp.trials = 50 + exp.run_count = 1000 + exp.epsilon = 1e-4 + net_generators = [] + for activation in ['linear']: # , 'sigmoid', 'relu']: + for use_bias in [False]: + net_generators += [lambda activation=activation, use_bias=use_bias: WeightwiseNeuralNetwork(width=2, depth=2).with_keras_params(activation=activation, use_bias=use_bias)] + net_generators += [lambda activation=activation, use_bias=use_bias: AggregatingNeuralNetwork(aggregates=4, width=2, depth=2).with_keras_params(activation=activation, use_bias=use_bias)] + net_generators += [lambda activation=activation, use_bias=use_bias: RecurrentNeuralNetwork(width=2, depth=2).with_keras_params(activation=activation, use_bias=use_bias)] + all_counters = [] + all_notable_nets = [] + all_names = [] + for net_generator_id, net_generator in enumerate(net_generators): + counters = generate_counters() + notable_nets = [] + for _ in tqdm(range(exp.trials)): + net = ParticleDecorator(net_generator()) + net = TrainingNeuralNetworkDecorator(net).with_params(epsilon=exp.epsilon) + name = str(net.net.net.__class__.__name__) + " activiation='" + str(net.get_keras_params().get('activation')) + "' use_bias=" + str(net.get_keras_params().get('use_bias')) + for run_id in range(exp.run_count): + loss = net.compiled().train(epoch=run_id+1) + count(counters, net, notable_nets) + all_counters += [counters] + all_notable_nets += [notable_nets] + all_names += [name] + K.clear_session() + exp.save(all_counters=all_counters) + exp.save(trajectorys=exp.without_particles()) + # net types reached in the end + # exp.save(all_notable_nets=all_notable_nets) + exp.save(all_names=all_names) #experiment setups + for exp_id, counter in enumerate(all_counters): + exp.log(all_names[exp_id]) + exp.log(all_counters[exp_id]) + exp.log('\n') diff --git a/code/soup.py b/code/soup.py new file mode 100644 index 0000000..bf11a9d --- /dev/null +++ b/code/soup.py @@ -0,0 +1,147 @@ +import random + +from network import * + + +def prng(): + return random.random() + + +class Soup(object): + + def __init__(self, size, generator, **kwargs): + self.size = size + self.generator = generator + self.particles = [] + self.historical_particles = {} + self.params = dict(attacking_rate=0.1, learn_from_rate=0.1, train=0, learn_from_severity=1) + self.params.update(kwargs) + self.time = 0 + + def __copy__(self): + copy_ = Soup(self.size, self.generator, **self.params) + copy_.__dict__ = {attr: self.__dict__[attr] for attr in self.__dict__ if + attr not in ['particles', 'historical_particles']} + return copy_ + + def without_particles(self): + self_copy = copy.copy(self) + # self_copy.particles = [particle.states for particle in self.particles] + self_copy.historical_particles = {key: val.states for key, val in self.historical_particles.items()} + return self_copy + + def with_params(self, **kwargs): + self.params.update(kwargs) + return self + + def generate_particle(self): + new_particle = ParticleDecorator(self.generator()) + self.historical_particles[new_particle.get_uid()] = new_particle + return new_particle + + def get_particle(self, uid, otherwise=None): + return self.historical_particles.get(uid, otherwise) + + def seed(self): + self.particles = [] + for _ in range(self.size): + self.particles += [self.generate_particle()] + return self + + def evolve(self, iterations=1): + for _ in range(iterations): + self.time += 1 + for particle_id, particle in enumerate(self.particles): + description = {'time': self.time} + if prng() < self.params.get('attacking_rate'): + other_particle_id = int(prng() * len(self.particles)) + other_particle = self.particles[other_particle_id] + particle.attack(other_particle) + description['action'] = 'attacking' + description['counterpart'] = other_particle.get_uid() + if prng() < self.params.get('learn_from_rate'): + other_particle_id = int(prng() * len(self.particles)) + other_particle = self.particles[other_particle_id] + for _ in range(self.params.get('learn_from_severity', 1)): + particle.learn_from(other_particle) + description['action'] = 'learn_from' + description['counterpart'] = other_particle.get_uid() + for _ in range(self.params.get('train', 0)): + particle.compiled() + # callbacks on save_state are broken for TrainingNeuralNetwork + loss = particle.train(store_states=False) + description['fitted'] = self.params.get('train', 0) + description['loss'] = loss + description['action'] = 'train_self' + description['counterpart'] = None + if self.params.get('remove_divergent') and particle.is_diverged(): + new_particle = self.generate_particle() + self.particles[particle_id] = new_particle + description['action'] = 'divergent_dead' + description['counterpart'] = new_particle.get_uid() + if self.params.get('remove_zero') and particle.is_zero(): + new_particle = self.generate_particle() + self.particles[particle_id] = new_particle + description['action'] = 'zweo_dead' + description['counterpart'] = new_particle.get_uid() + particle.save_state(**description) + + def count(self): + counters = dict(divergent=0, fix_zero=0, fix_other=0, fix_sec=0, other=0) + for particle in self.particles: + if particle.is_diverged(): + counters['divergent'] += 1 + elif particle.is_fixpoint(): + if particle.is_zero(): + counters['fix_zero'] += 1 + else: + counters['fix_other'] += 1 + elif particle.is_fixpoint(2): + counters['fix_sec'] += 1 + else: + counters['other'] += 1 + return counters + + def print_all(self): + for particle in self.particles: + particle.print_weights() + print(particle.is_fixpoint()) + + +if __name__ == '__main__': + if False: + with SoupExperiment() as exp: + for run_id in range(1): + net_generator = lambda: WeightwiseNeuralNetwork(2, 2).with_keras_params(activation='linear').with_params() + # net_generator = lambda: FFTNeuralNetwork(2, 2).with_keras_params(activation='linear').with_params() + # net_generator = lambda: AggregatingNeuralNetwork(4, 2, 2).with_keras_params(activation='sigmoid')\ + # .with_params(shuffler=AggregatingNeuralNetwork.shuffle_random) + # net_generator = lambda: RecurrentNeuralNetwork(2, 2).with_keras_params(activation='linear').with_params() + soup = Soup(100, net_generator).with_params(remove_divergent=True, remove_zero=True) + soup.seed() + for _ in tqdm(range(1000)): + soup.evolve() + exp.log(soup.count()) + exp.save(soup=soup.without_particles()) + + if True: + with SoupExperiment("soup") as exp: + for run_id in range(1): + net_generator = lambda: TrainingNeuralNetworkDecorator(WeightwiseNeuralNetwork(2, 2))\ + .with_keras_params(activation='linear').with_params(epsilon=0.0001) + # net_generator = lambda: TrainingNeuralNetworkDecorator(AggregatingNeuralNetwork(4, 2, 2)) + # .with_keras_params(activation='linear')\ + # .with_params(shuffler=AggregatingNeuralNetwork.shuffle_random) + # net_generator = lambda: TrainingNeuralNetworkDecorator(FFTNeuralNetwork(4, 2, 2))\ + # .with_keras_params(activation='linear')\ + # .with_params(shuffler=AggregatingNeuralNetwork.shuffle_random) + # net_generator = lambda: RecurrentNeuralNetwork(2, 2).with_keras_params(activation='linear').with_params() + soup = Soup(100, net_generator).with_params(remove_divergent=True, remove_zero=True, train=20) + soup.seed() + for _ in tqdm(range(100)): + soup.evolve() + exp.log(soup.count()) + # you can access soup.historical_particles[particle_uid].states[time_step]['loss'] + # or soup.historical_particles[particle_uid].states[time_step]['weights'] + # from soup.dill + exp.save(soup=soup.without_particles()) diff --git a/code/test.py b/code/test.py new file mode 100644 index 0000000..156e354 --- /dev/null +++ b/code/test.py @@ -0,0 +1,111 @@ +from experiment import * +from network import * +from soup import * +import numpy as np + + +class LearningNeuralNetwork(NeuralNetwork): + + @staticmethod + def mean_reduction(weights, features): + single_dim_weights = np.hstack([w.flatten() for w in weights]) + shaped_weights = np.reshape(single_dim_weights, (1, features, -1)) + x = np.mean(shaped_weights, axis=-1) + return x + + @staticmethod + def fft_reduction(weights, features): + single_dim_weights = np.hstack([w.flatten() for w in weights]) + x = np.fft.fft(single_dim_weights, n=features)[None, ...] + return x + + @staticmethod + def random_reduction(_, features): + x = np.random.rand(features)[None, ...] + return x + + def __init__(self, width, depth, features, **kwargs): + raise DeprecationWarning + super().__init__(**kwargs) + self.width = width + self.depth = depth + self.features = features + self.compile_params = dict(loss='mse', optimizer='sgd') + self.model = Sequential() + self.model.add(Dense(units=self.width, input_dim=self.features, **self.keras_params)) + for _ in range(self.depth - 1): + self.model.add(Dense(units=self.width, **self.keras_params)) + self.model.add(Dense(units=self.features, **self.keras_params)) + self.model.compile(**self.compile_params) + + def apply_to_weights(self, old_weights, **kwargs): + reduced = kwargs.get('reduction', self.fft_reduction)() + raise NotImplementedError + # build aggregations from old_weights + weights = self.get_weights_flat() + + # call network + old_aggregation = self.aggregate_fft(weights, self.aggregates) + new_aggregation = self.apply(old_aggregation) + + # generate list of new weights + new_weights_list = self.deaggregate_identically(new_aggregation, self.get_amount_of_weights()) + + new_weights_list = self.get_shuffler()(new_weights_list) + + # write back new weights + new_weights = self.fill_weights(old_weights, new_weights_list) + + # return results + if self.params.get("print_all_weight_updates", False) and not self.is_silent(): + print("updated old weight aggregations " + str(old_aggregation)) + print("to new weight aggregations " + str(new_aggregation)) + print("resulting in network weights ...") + print(self.__class__.weights_to_string(new_weights)) + return new_weights + + def with_compile_params(self, **kwargs): + self.compile_params.update(kwargs) + return self + + def learn(self, epochs, reduction, batchsize=1): + with tqdm(total=epochs, ascii=True, + desc='Type: {t} @ Epoch:'.format(t=self.__class__.__name__), + postfix=["Loss", dict(value=0)]) as bar: + for epoch in range(epochs): + old_weights = self.get_weights() + x = reduction(old_weights, self.features) + savestateCallback = SaveStateCallback(self, epoch=epoch) + history = self.model.fit(x=x, y=x, verbose=0, batch_size=batchsize, callbacks=savestateCallback) + bar.postfix[1]["value"] = history.history['loss'][-1] + bar.update() + + +def vary(e=0.0, f=0.0): + return [ + np.array([[1.0+e, 0.0+f], [0.0+f, 0.0+f], [0.0+f, 0.0+f], [0.0+f, 0.0+f]], dtype=np.float32), + np.array([[1.0+e, 0.0+f], [0.0+f, 0.0+f]], dtype=np.float32), + np.array([[1.0+e], [0.0+f]], dtype=np.float32) + ] + +if __name__ == '__main__': + + net = WeightwiseNeuralNetwork(width=2, depth=2).with_keras_params(activation='sigmoid') + if False: + net.set_weights([ + np.array([[1.0, 0.0], [0.0, 0.0], [0.0, 0.0], [0.0, 0.0]], dtype=np.float32), + np.array([[1.0, 0.0], [0.0, 0.0]], dtype=np.float32), + np.array([[1.0], [0.0]], dtype=np.float32) + ]) + print(net.get_weights()) + net.self_attack(100) + print(net.get_weights()) + print(net.is_fixpoint()) + + if True: + net.set_weights(vary(0.01, 0.0)) + print(net.get_weights()) + for _ in range(5): + net.self_attack() + print(net.get_weights()) + print(net.is_fixpoint()) diff --git a/code/util.py b/code/util.py new file mode 100644 index 0000000..a8604c4 --- /dev/null +++ b/code/util.py @@ -0,0 +1,39 @@ +class PrintingObject: + + class SilenceSignal(): + def __init__(self, obj, value): + self.obj = obj + self.new_silent = value + def __enter__(self): + self.old_silent = self.obj.get_silence() + self.obj.set_silence(self.new_silent) + def __exit__(self, exception_type, exception_value, traceback): + self.obj.set_silence(self.old_silent) + + def __init__(self): + self.silent = True + + def is_silent(self): + return self.silent + + def get_silence(self): + return self.is_silent() + + def set_silence(self, value=True): + self.silent = value + return self + + def unset_silence(self): + self.silent = False + return self + + def with_silence(self, value=True): + self.set_silence(value) + return self + + def silence(self, value=True): + return self.__class__.SilenceSignal(self, value) + + def _print(self, *args, **kwargs): + if not self.silent: + print(*args, **kwargs) \ No newline at end of file diff --git a/code/visualization.py b/code/visualization.py new file mode 100644 index 0000000..69594ac --- /dev/null +++ b/code/visualization.py @@ -0,0 +1,283 @@ +import os + +from experiment import Experiment +# noinspection PyUnresolvedReferences +from soup import Soup + +from argparse import ArgumentParser +import numpy as np + +import plotly as pl +import plotly.graph_objs as go + +import colorlover as cl + +import dill + +from sklearn.manifold.t_sne import TSNE, PCA + + +def build_args(): + arg_parser = ArgumentParser() + arg_parser.add_argument('-i', '--in_file', nargs=1, type=str) + arg_parser.add_argument('-o', '--out_file', nargs='?', default='out', type=str) + return arg_parser.parse_args() + + +def build_from_soup_or_exp(soup): + particles = soup.historical_particles + particle_list = [] + for particle in particles.values(): + particle_dict = dict( + trajectory=[event['weights'] for event in particle], + time=[event['time'] for event in particle], + action=[event.get('action', None) for event in particle], + counterpart=[event.get('counterpart', None) for event in particle] + ) + if any([x is not None for x in particle_dict['counterpart']]): + print('counterpart') + particle_list.append(particle_dict) + return particle_list + + +def plot_latent_trajectories(soup_or_experiment, filename='latent_trajectory_plot'): + assert isinstance(soup_or_experiment, (Experiment, Soup)) + bupu = cl.scales['11']['div']['RdYlGn'] + data_dict = build_from_soup_or_exp(soup_or_experiment) + scale = cl.interp(bupu, len(data_dict)+1) # Map color scale to N bins + + # Fit the mebedding space + transformer = TSNE() + for particle_dict in data_dict: + array = np.asarray([np.hstack([x.flatten() for x in timestamp]).flatten() + for timestamp in particle_dict['trajectory']]) + particle_dict['trajectory'] = array + transformer.fit(array) + + # Transform data accordingly and plot it + data = [] + for p_id, particle_dict in enumerate(data_dict): + transformed = transformer._fit(np.asarray(particle_dict['trajectory'])) + line_trace = go.Scatter( + x=transformed[:, 0], + y=transformed[:, 1], + text='Hovertext goes here'.format(), + line=dict(color=scale[p_id]), + # legendgroup='Position -{}'.format(pos), + name='Particle - {}'.format(p_id), + showlegend=True, + # hoverinfo='text', + mode='lines') + line_start = go.Scatter(mode='markers', x=[transformed[0, 0]], y=[transformed[0, 1]], + marker=dict( + color='rgb(255, 0, 0)', + size=4 + ), + showlegend=False + ) + line_end = go.Scatter(mode='markers', x=[transformed[-1, 0]], y=[transformed[-1, 1]], + marker=dict( + color='rgb(0, 0, 0)', + size=4 + ), + showlegend=False + ) + data.extend([line_trace, line_start, line_end]) + + layout = dict(title='{} - Latent Trajectory Movement'.format('Penis'), + height=800, width=800, margin=dict(l=0, r=0, t=0, b=0)) + # import plotly.io as pio + # pio.write_image(fig, filename) + fig = go.Figure(data=data, layout=layout) + pl.offline.plot(fig, auto_open=True, filename=filename) + pass + + +def plot_latent_trajectories_3D(soup_or_experiment, filename='plot'): + def norm(val, a=0, b=0.25): + return (val - a) / (b - a) + + data_list = build_from_soup_or_exp(soup_or_experiment) + if not data_list: + return + + base_scale = cl.scales['9']['div']['RdYlGn'] + # base_scale = cl.scales['9']['qual']['Set1'] + scale = cl.interp(base_scale, len(data_list)+1) # Map color scale to N bins + + # Fit the embedding space + transformer = PCA(n_components=2) + + array = [] + for particle_dict in data_list: + array.append(particle_dict['trajectory']) + + transformer.fit(np.vstack(array)) + + # Transform data accordingly and plot it + data = [] + for p_id, particle_dict in enumerate(data_list): + transformed = transformer.transform(particle_dict['trajectory']) + line_trace = go.Scatter3d( + x=transformed[:, 0], + y=transformed[:, 1], + z=np.asarray(particle_dict['time']), + text='Particle: {}
It had {} lifes.'.format(p_id, len(particle_dict['trajectory'])), + line=dict( + color=scale[p_id], + width=4 + ), + # legendgroup='Particle - {}'.format(p_id), + name='Particle -{}'.format(p_id), + showlegend=False, + hoverinfo='text', + mode='lines') + + line_start = go.Scatter3d(mode='markers', x=[transformed[0, 0]], y=[transformed[0, 1]], + z=np.asarray(particle_dict['time'][0]), + marker=dict( + color='rgb(255, 0, 0)', + size=4 + ), + showlegend=False + ) + + line_end = go.Scatter3d(mode='markers', x=[transformed[-1, 0]], y=[transformed[-1, 1]], + z=np.asarray(particle_dict['time'][-1]), + marker=dict( + color='rgb(0, 0, 0)', + size=4 + ), + showlegend=False + ) + + data.extend([line_trace, line_start, line_end]) + + axis_layout = dict(gridcolor='rgb(255, 255, 255)', + gridwidth=3, + zerolinecolor='rgb(255, 255, 255)', + showbackground=True, + backgroundcolor='rgb(230, 230,230)', + titlefont=dict( + color='black', + size=30 + ) + ) + + layout = go.Layout(scene=dict( + # aspectratio=dict(x=2, y=2, z=2), + xaxis=dict(title='Transformed X', **axis_layout), + yaxis=dict(title='Transformed Y', **axis_layout), + zaxis=dict(title='Epoch', **axis_layout)), + # title='{} - Latent Trajectory Movement'.format('Soup'), + + width=1024, height=1024, + margin=dict(l=0, r=0, b=0, t=0) + ) + + fig = go.Figure(data=data, layout=layout) + pl.offline.plot(fig, auto_open=True, filename=filename, validate=True) + pass + + +def plot_histogram(bars_dict_list, filename='histogram_plot'): + # catagorical + ryb = cl.scales['10']['div']['RdYlBu'] + + data = [] + for bar_id, bars_dict in bars_dict_list: + hist = go.Histogram( + histfunc="count", + y=bars_dict.get('value', 14), + x=bars_dict.get('name', 'gimme a name'), + showlegend=False, + marker=dict( + color=ryb[bar_id] + ), + ) + data.append(hist) + + layout=dict(title='{} Histogram Plot'.format('Experiment Name Penis'), + height=400, width=400, margin=dict(l=0, r=0, t=0, b=0)) + + fig = go.Figure(data=data, layout=layout) + pl.offline.plot(fig, auto_open=True, filename=filename) + + pass + + +def line_plot(line_dict_list, filename='lineplot'): + # lines with standard deviation + # Transform data accordingly and plot it + data = [] + rdylgn = cl.scales['10']['div']['RdYlGn'] + rdylgn_background = [scale + (0.4,) for scale in cl.to_numeric(rdylgn)] + for line_id, line_dict in enumerate(line_dict_list): + name = line_dict.get('name', 'gimme a name') + + upper_bound = go.Scatter( + name='Upper Bound', + x=line_dict['x'], + y=line_dict['upper_y'], + mode='lines', + marker=dict(color="#444"), + line=dict(width=0), + fillcolor=rdylgn_background[line_id], + ) + + trace = go.Scatter( + x=line_dict['x'], + y=line_dict['main_y'], + mode='lines', + name=name, + line=dict(color=line_id), + fillcolor=rdylgn_background[line_id], + fill='tonexty') + + lower_bound = go.Scatter( + name='Lower Bound', + x=line_dict['x'], + y=line_dict['lower_y'], + marker=dict(color="#444"), + line=dict(width=0), + mode='lines') + + data.extend([upper_bound, trace, lower_bound]) + + layout=dict(title='{} Line Plot'.format('Experiment Name Penis'), + height=800, width=800, margin=dict(l=0, r=0, t=0, b=0)) + + fig = go.Figure(data=data, layout=layout) + pl.offline.plot(fig, auto_open=True, filename=filename) + pass + + +def search_and_apply(absolut_file_or_folder, plotting_function, files_to_look_for=[]): + if os.path.isdir(absolut_file_or_folder): + for sub_file_or_folder in os.scandir(absolut_file_or_folder): + search_and_apply(sub_file_or_folder.path, plotting_function, files_to_look_for=files_to_look_for) + elif absolut_file_or_folder.endswith('.dill'): + file_or_folder = os.path.split(absolut_file_or_folder)[-1] + if file_or_folder in files_to_look_for and not os.path.exists('{}.html'.format(absolut_file_or_folder[:-5])): + print('Apply Plotting function "{func}" on file "{file}"'.format(func=plotting_function.__name__, + file=absolut_file_or_folder) + ) + with open(absolut_file_or_folder, 'rb') as in_f: + exp = dill.load(in_f) + try: + plotting_function(exp, filename='{}.html'.format(absolut_file_or_folder[:-5])) + except ValueError: + pass + except AttributeError: + pass + else: + # This was either another FilyType or Plot.html alerady exists. + pass + + +if __name__ == '__main__': + args = build_args() + in_file = args.in_file[0] + out_file = args.out_file + + search_and_apply(in_file, plot_latent_trajectories_3D, ["trajectorys.dill", "soup.dill"]) diff --git a/related/EP/src/FeatureReduction.py b/related/EP/src/FeatureReduction.py new file mode 100644 index 0000000..b27e07d --- /dev/null +++ b/related/EP/src/FeatureReduction.py @@ -0,0 +1,95 @@ +import numpy as np +import numbers + +class FeatureReduction(): + def __init__(self, type): + self.type = type + self.VecFromWeigths = None + + def calc(self, vec, n): + self.weigthsToVec(vec) + return { + 'fft' : self.fft(self.VecFromWeigths, n), + 'rfft': self.rfftn(self.VecFromWeigths, n), + 'mean': self.mean(self.VecFromWeigths,n), + 'meanShuffled':self.mean(self.shuffelVec(self.VecFromWeigths,3),n) + }[self.type] + + def fft(self, vec, n): + return np.fft.fft(vec, n) + + def rfftn(self, vec, n): + return np.fft.rfft(vec, n) + + def shuffelVec(self, vec, mod): + newVec = np.array([]) + rVec = np.array([]) + i = 0 + while i < len(vec): + if i % mod == 0: + newVec = np.append(newVec, vec[i]) + else: + rVec = np.append(rVec, vec[i]) + i += 1 + if len(newVec) != len(vec): + newVec = np.append(newVec, self.shuffelVec(rVec, mod)) + return newVec + + def mean(self,vec, n): + ''' + Zerlegt einen Vektor in n gleich große Teile und berechnet den Mitteltwert. + :param vec: Eingabevektor als array mit x Komponenten + :param n: Die Größe des Ausgabevektors + :return:Vektor als array mit n Komponenten + ''' + if n > len(vec): + Exception("n is bigger than len(vec) - no feature reduction avaiable") + x = len(vec)/n + result = np.array([]) + factor =1 + if x - int(x) != 0: + factor = x - int(x) + actFactor = factor + vv = 0 + for value in vec: + if round(x,5) <= 1: + x = len(vec) / n + vv += actFactor * value + result = np.append(result, [round(vv / (len(vec) / n),6)]) + vv = (1 - actFactor) * value + if round((1 - actFactor),5) > 0: + x -= (1-actFactor) + actFactor += factor + if round(actFactor,5) > 1: + actFactor -= 1 + else: + actFactor = factor + else: + vv += value + x -= 1 + return result + + def weigthsToVec(self, weights, vec=np.array([])): + ''' + Die Keras liefert die Gewichte eines neuronalen Netzwerkes in einem mehrdimensionalen Array. Dieses Array + beinhaltet nicht nur die Gewichte der einzelnen Schichten, sondern auch der Status der Ausgabe der einzelnen + Neuronen. Die Gewichte ines Netzes mit einem Neuron in der Eingabeschicht, zwei Neuronen in einer versteckten + Schicht und einem Neuron in der Ausgabeschicht hat beispielsweise folgende Darstellung: + [[[1 2]] + [0. 0.] + [[2] [3]] + [0.]] + Diese Funktion überführt die Darstellung in einen Vektor. Dabei werden die Informationen um die Ausgabe der + einzelnen Neuronen verworfen. Der Vektor der die oben beschriebenen Gewichte darstellt hat folgende Form: + [1, 2, 2, 3] + :param weights: mehrdimensionales Array der Gewichte aus Keras + :return: Vektor in Form eines Arrays + ''' + if isinstance(weights, np.float32): + vec = np.append(vec, weights) + else: + for x in weights: + if isinstance(x[0], np.ndarray): + for xx in x: + vec = np.append(vec, xx) + self.VecFromWeigths = vec diff --git a/related/EP/src/Functions.py b/related/EP/src/Functions.py new file mode 100644 index 0000000..e0547e4 --- /dev/null +++ b/related/EP/src/Functions.py @@ -0,0 +1,66 @@ +import glob +import random +import numpy as np + +def checkFileExists(fileName): + ''' + prüft ob eine Datei existiert und gibt gegebenenfalls den Pfad zurück, sonst False + :param fileName: + :return: Boolean + ''' + + file = glob.glob(fileName) + if len(file) > 0: + return file[0] + else: + return False + +def calcMeanSquaredError(a, b): + ''' + Berechnet den MSE zwischen a und b + :param a: + :param b: + :return: MSE + ''' + + a = a.astype(float) + b = b.astype(float) + mse = ((a - b) ** 2).mean() + return mse + +def calcScale(array): + ''' + Berechnet die Skala eines Arrays + :param array: + :return: + ''' + return abs(max(array)-min(array)) + +def getRandomLayer(tuple, standardDeviation=0.01): + ''' + Liefert ein zufällige Gewichte für die übergebene Schicht im Keras Format + :param tuple: ein Tupel für die Schicht (12, 75) ist beispielweise eine Schicht mit 12 auf 75 Neuronen + :param standardDeviation: + :return: Zufällige Gewichte für die Schicht im Keras Format + ''' + randomLayer = [] + i = 0 + while i < tuple[0]: + randomNeuron = [] + x = 0 + while x < tuple[1]: + randomNeuron.append(getRandomGausNumber(standardDeviation)) + x += 1 + randomLayer.append(randomNeuron) + i+= 1 + randomLayer = [randomLayer] + randomLayer.append([0.]*tuple[1]) + return randomLayer + +def getRandomGausNumber(standardDeviation): + ''' + Liefert eine Zufallszahl um null mit der angegebenen Standardabweichung + :param standardDeviation: + :return: + ''' + return np.random.normal(0.0, standardDeviation) \ No newline at end of file diff --git a/related/EP/src/LossHistory.py b/related/EP/src/LossHistory.py new file mode 100644 index 0000000..6f924a3 --- /dev/null +++ b/related/EP/src/LossHistory.py @@ -0,0 +1,11 @@ +import keras + +class LossHistory(keras.callbacks.Callback): + def on_train_begin(self, logs={}): + self.losses = [] + + def on_batch_end(self, batch, logs={}): + self.losses.append(logs.get('loss')) + + def addLoss(self,loss): + self.losses.append(loss) \ No newline at end of file diff --git a/related/EP/src/NeuralNetwork.py b/related/EP/src/NeuralNetwork.py new file mode 100644 index 0000000..54475bd --- /dev/null +++ b/related/EP/src/NeuralNetwork.py @@ -0,0 +1,364 @@ +import matplotlib +matplotlib.use('Agg') +import datetime +from keras import backend +from keras.models import Sequential +from keras.layers.core import Dense, Activation +from keras.optimizers import Adadelta +from keras.models import load_model +from keras import utils +import copy +import numpy as np +import collections +from operator import add + +try: + from src.Functions import Functions + from src.PltData import PltData + from src.FeatureReduction import FeatureReduction + from src.LossHistory import LossHistory +except ImportError: + import Functions + from PltData import PltData + from FeatureReduction import FeatureReduction + from LossHistory import LossHistory + +class NeuralNetwork: + + def __init__(self, numberOfNeurons, activationFunctions, featureReduction, + numberLoops, loss='mean_squared_error', printVectors=False, path="../images/", + fitByHillClimber=False, standardDeviation = 0.01, numberOtRandomShots=20, checkNewWeightsIsReallyBetter=False): + ''' + :param numberOfNeurons: Array mit Integers. Gibt die Anzahl der Neuronen der einzelnen Schichten an + :param activationFunctions: Array mit Strings für die Aktivierungsfunktionen der einzelnen Schichten + :param featureReduction: String der die Funktion zur Feature Reduzierung angibt + :param numberLoops: die Anzahl der Schleifendruchläufe + :param loss: Fehlerfunktion + :param printVectors: Boolean gibt an ob die Gewichte und der dazugehörige die die feature reduction funktion + transformierte Vektor ausgeben werden soll + :param path: der Pfad zu den Ergebnissen + ''' + backend.clear_session() + self.model = Sequential() + self.optimzier = Adadelta() + self.epochs = 1 + self.fitByHillClimber = fitByHillClimber + self.checkNewWeightsIsReallyBetter=checkNewWeightsIsReallyBetter + self.numberOtRandomShots = numberOtRandomShots + self.standardDeviation = standardDeviation + self.numberOfNeurons = numberOfNeurons + self.activationFunctions = activationFunctions + self.featureReduction = featureReduction + self.featureReductionFunction = FeatureReduction(self.featureReduction) + self.numberLoops = numberLoops + self.loss = loss + self.addedLayers = "No_Layers_added" + self.result = [] + self.fileForVectors = None + self.printVectors = printVectors + self.path = path + self.beginGrowing = 0 + self.stopGrowing = 0 + self.LM = 0 + self.dataHistory = [] + self.minFailure = 100 + self.minFailureLoop = None + + def addLayers(self): + i = 2 + self.addedLayers = "inputDim_" + str(self.numberOfNeurons[0]) + "_" + str(self.activationFunctions[0]) + \ + "_" + str(self.numberOfNeurons[1]) + self.model.add(Dense(self.numberOfNeurons[1], kernel_initializer="uniform", input_dim=self.numberOfNeurons[0], + activation=self.activationFunctions[0])) + while i < len(self.numberOfNeurons): + self.addLayer(self.activationFunctions[i-1], self.numberOfNeurons[i]) + i+= 1 + + def addLayer(self, activationFunction, numberOfNeurons): + self.model.add(Dense(numberOfNeurons, kernel_initializer="uniform")) + self.model.add((Activation(activationFunction))) + self.addedLayers += "_" + activationFunction+"_"+ str(numberOfNeurons) + + def fitByStochasticHillClimberV3(self, inputD, outputD, callbacks=None): + ''' + Diese Version des stochastischen Hill Climbers, überorüft den Fehler nur Anhand der neuen Gewichte. + :param inputD: + :param outputD: + :param callbacks: + :return: + ''' + + weights = self.model.get_weights() + aktWeights = self.model.get_weights() + memDict = {} + i = 0 + if callbacks != None: + for f in callbacks: + f.on_train_begin() + while i <= self.numberOtRandomShots: + i+= 1 + loss = Functions.calcMeanSquaredError(self.model.predict(inputD, batch_size=1), outputD) + if i == 1: + if callbacks != None: + for f in callbacks: + f.addLoss(loss) + memDict[loss] = weights + weights = self.joinWeights(self.getRandomWeights(),weights) + self.model.set_weights(weights) + inputD = np.array([self.featureReductionFunction.calc(self.model.get_weights(), self.numberOfNeurons[0])]) + outputD = inputD + + od = collections.OrderedDict(sorted(memDict.items())) + od = list(od.items()) + self.model.set_weights(od[0][1]) + return + + def fitByStochasticHillClimber(self, inputD, outputD, callbacks=None): + ''' + Die ersten beiden Versionen des Hill Climber. + V1 wird ausgeführt wenn self.checkNewWeightsIsReallyBetter nicht True ist. In diesem Fall wird nur gegen die + alten Gewichte und dessen Repräsentation geprüft. + V2 wird ausgeführt wenn self.checkNewWeightsIsReallyBetter True ist. In diesem Fall wird ein zweiter Check auf + die neuen Gewichte ausgeführt. Nur wenn beide ein besseres Ergebnis liefern, werden die neuen Gewichte übernommen. + Die bessere Variante ist fitByStochasticHillClimberV3 - in der nur gegen die neuen Gewichte geprüft wird. + :param inputD: + :param outputD: + :param callbacks: + :return: + ''' + weights = self.model.get_weights() + aktWeights = self.model.get_weights() + memDict = {} + i = 0 + if callbacks != None: + for f in callbacks: + f.on_train_begin() + while i <= self.numberOtRandomShots: + i+= 1 + loss = Functions.calcMeanSquaredError(self.model.predict(inputD), outputD) + if i == 1: + if callbacks != None: + for f in callbacks: + f.addLoss(loss) + memDict[loss] = weights + weights = self.joinWeights(self.getRandomWeights(),weights) + self.model.set_weights(weights) + od = collections.OrderedDict(sorted(memDict.items())) + od = list(od.items()) + if self.checkNewWeightsIsReallyBetter: + self.model.set_weights(od[0][1]) + iData = np.array([self.featureReductionFunction.calc(self.model.get_weights(), self.numberOfNeurons[0])]) + errorWithNewWeights = Functions.calcMeanSquaredError(self.model.predict(iData, batch_size=1), iData) + self.model.set_weights(aktWeights) + errorWithOldWeights = Functions.calcMeanSquaredError(self.model.predict(iData, batch_size=1), iData) + if errorWithNewWeights 2500: + break + if searchForThreshold: + if self.checkGrowing(self.result, 100): + return self.result[0], True + if i > 1000: + return self.result[0], False + if checkLM: + if len(self.result) > 1000: + dd = np.sum(np.array(self.result[-1000:])) + if dd == 0.: + # Wenn die Summe der letzten 1000 Fehler echt null ist - muss ein Fixpunkt gefunden worden sein + self.beginGrowing = 0 + break + if self.checkGrowing(self.result, 10) and self.beginGrowing == 0: + # Fehler steigt wieder + self.beginGrowing = i + if stepWise: + self.numberLoops = i + self.printEvaluation() + if self.beginGrowing > 0: + ''' + if len(self.result) > 1000: + if (i > 10000 and self.checkGrowing(self.result, 100)): + if stepWise: + self.numberLoops = i + self.printEvaluation() + #print("BREAK 1", round(dd,6), dd) + break + ''' + if not self.checkGrowing(self.result, 10, checkSame=False) and i-self.beginGrowing>500 and not iamHere: + # In einigen Fällen ist der Wachstum sehr langsam, deswegen checkSame = False, + # nach beginGrowing kommt es manchmal vor, dass der Wachstum kurz aussetzt, deswegen + # müssen sollten zwischen beginGrowing und endGrowing 500 Schritte liegen + self.stopGrowing = i + self.LM =self.result[len(self.result) - 1] + if stepWise: + self.numberLoops = i + self.printEvaluation() + iamHere = True + else: + break + + pl = PltData(np.array(self.result)) + pl.linePlot(self.getFileName(i), width=1600, text=self.getDescription()) + + def printEvaluation(self): + start = -100000 + stop = 100000 + step = 1 + data = np.arange(start, stop, step) + self.evaluate(data, str(start) + "_" + str(stop) + "_" + str(step), + text=self.getDescription() + "\nStart: " + str(start) + "\nStop " + str(stop) + "\nStep " + str(step)) + + def checkGrowing(self, mArray, range, checkSame=True): + if len(mArray) < range*2: + return False + values = np.array(mArray[-1*range*2:]) + values = values.reshape(-1, int(len(values)/2)) + if np.sum(values[0]) == np.sum(values[1]) and checkSame: + return False + if np.sum(values[0]) > np.sum(values[1]): + return False + else: + return True + + def evaluate(self, inputData, filename, text=""): + pD = self.model.predict(inputData, batch_size=1) + pD = np.reshape(pD,(1,len(pD)))[0] + pl = PltData(pD) + pl.linePlot(self.path + self.getFileName() + "_" + filename, width=1024, text=text, xLegend="X", yLegend="Y", x=inputData, yTextPos=-0.0015, xTextPos=-10000) + + def loadModel(self): + file = "../nnModels/" + self.getFileName() + ".h5" + if not Functions.checkFileExists(file): + print("no model found in " + str(file)) + return + self.model = load_model(file) + print("Model loaded from " + str(file)) + + def saveModel(self): + self.model.save("../nnModels/" + str(self.getFileName()) + ".h5") + + def printVec(self, loop, weight, input): + if self.fileForVectors == None: + self.fileForVectors = open(self.path + self.getFileName() + ".txt", "w") + self.fileForVectors.write("numberOfLoop \t weights \t " +self.featureReduction + " result\n") + self.fileForVectors.write(str(loop) + " \t " + repr(weight) +" \t " + repr(input) + " \n") + + + def getFileName(self, numberLoops=None): + if numberLoops is None: + numberLoops = self.numberLoops + fileName ="nOL_" + str(len(self.activationFunctions)) + \ + self.addedLayers + "_nLoops_" + str(numberLoops) + "_fR_" +self.featureReduction + if self.fitByHillClimber: + fileName += "_standardDeviation_" +str(self.standardDeviation) +\ + "_numberOtRandomShots_"+str(self.numberOtRandomShots) + if self.checkNewWeightsIsReallyBetter: + fileName += "_checkNewWeightsIsReallyBetter" + return fileName + + def getDescription(self): + text = "Loops: " + str(self.numberLoops) + \ + "\nLayers:" + self.getLayerText() +\ + "\nOptimizer: Adadelta" + \ + "\nFeature Reduction: " + self.featureReduction + if self.fitByHillClimber: + text += "\nStandard Deviation: " +str(self.standardDeviation) +\ + "\nNumber Of Random Shots: " + str(self.numberOtRandomShots) +\ + "\nMinimaler Fehler: " +str(self.minFailure) +" bei Loop: " + str(self.minFailureLoop)+\ + "\ncheckNewWeightsIsReallyBetter:" + str(self.checkNewWeightsIsReallyBetter) + + return text + + def getLayerText(self): + text = "" + i = 0 + for l in self.activationFunctions: + text += "\n" + str(i+1) + " Layer " + l + " " + str(self.numberOfNeurons[i+1]) + " Neuronen" + i += 1 + return text + diff --git a/related/EP/src/PltData.py b/related/EP/src/PltData.py new file mode 100644 index 0000000..e7683e8 --- /dev/null +++ b/related/EP/src/PltData.py @@ -0,0 +1,175 @@ +import matplotlib +matplotlib.use('Agg') + +import numpy as np +import matplotlib.pyplot as plt +import networkx as nx + +class PltData: + + def __init__(self, data): + self.data = data + + + def linePlot(self, fileName, x = None, legend=[], text="", yLegend="Mittle quadratische Fehler", xLegend="Anzahl der Loops",plotText = True, dest="images", + height=800, multiFigs=False, pltDiff=True, width=None, xTextPos = 0, yTextPos = 0): + myDbi = 96 + dim = len(self.data.shape) + if width == None: + try: + size = len(self.data[0]) * 4.5 / myDbi + except TypeError: + size = len(self.data)* 4.5 /myDbi + else: + size = width/myDbi + if size > 2^16: + size = 2^16 + + height = height/myDbi + plt.figure(figsize=(size, height)) + + if dim == 2: + i = 0 + for row in self.data: + if len(legend) > 0: + label = legend[i] + else: + label = "" + if multiFigs: + if i == 0: + f, axarr = plt.subplots(len(self.data), sharex=True, sharey=True) + f.set_figheight(height) + f.set_figwidth(size) + f.text(0.04, 0.5, yLegend, va='center', rotation='vertical') + axarr[i].plot(row) + axarr[i].grid(True) + axarr[i].set_ylabel(label) + + else: + if x is None: + plt.plot(row, label=label) + else: + plt.plot(x, row, label=label) + i += 1 + if pltDiff: + plt.plot(np.subtract(self.data[0].astype(float), self.data[1].astype(float)), label="Differenz") + else: + if x is None: + plt.plot(self.data) + else: + plt.plot(x,self.data) + + plt.legend() + if not multiFigs: + plt.ylabel(yLegend) + plt.xlabel(xLegend) + if plotText: + plt.text(0+xTextPos, np.amax(self.data)+yTextPos, text) + plt.grid(True) + plt.savefig("../"+ dest + "/" + fileName+ ".png", bbox_inches='tight') + plt.close() + + def plotNNModel(self, data, fileName, dest="images"): + data, pos = self.getModelData(data) + Gp = nx.Graph() + Gp.add_weighted_edges_from(data) + plt.figure(figsize=(15, 15)) + nx.draw(Gp, pos=pos) + nx.draw_networkx_labels(Gp, pos=pos) + nx.draw_networkx_edge_labels(Gp, pos=pos) + plt.savefig("../" + dest + "/" + fileName, bbox_inches='tight') + plt.close() + + def plotPoints(self, data, labels, filename, xlabel = ""): + plt.figure(figsize=(1600/96, 5)) + i = 0 + dots = ["ro", "go", "bo","yo"] + for row in data: + plt.plot(row, [i] * (len(row)), dots[i], label=labels[i]) + i+=1 + plt.legend() + plt.xlabel(xlabel) + plt.grid(True) + + plt.savefig(filename, bbox_inches='tight') + plt.close() + + def getModelData(self, data): + pos = {} + xRange, yRange = self.getPositionRanges(data) + layer = 1000 + layerSteps = 1000 + modelData = [] + firstLayer = True + z = 0 + r = 0 + while z < len(data)-1: + x = data[z] + if firstLayer: nextNodeNumber = 0 + nodeNumber = 0 + if isinstance(x[0], np.ndarray): + xPos = xRange[r] + xPosNext = xRange[r+1] + r += 1 + if firstLayer: + yKor = int(self.getLenOfFirstLayer(x)% len(yRange)/2) + else: + yKor = int((len(data[z+1])% len(yRange))/2) + if len(data) > z+3: + yKorNext = int(len(yRange)/(len(data[z + 3])) / 2) + for array in x: + if not firstLayer: nextNodeNumber = 0 + for value in array: + modelData.append((layer+nodeNumber, layer+layerSteps+nextNodeNumber, value)) + try: + yPos = yRange[nodeNumber + yKor] + except IndexError: + yPos = yRange[nodeNumber] + if layer+nodeNumber not in pos: + pos[layer+nodeNumber] = np.array([xPos, yPos]) + if layer+layerSteps+nextNodeNumber not in pos: + pos[layer+layerSteps+nextNodeNumber] = np.array([xPosNext, yRange[nextNodeNumber * yKorNext]]) + if firstLayer: + nodeNumber += 1 + else: + nextNodeNumber += 1 + if not firstLayer: + nodeNumber += 1 + else: + nextNodeNumber += 1 + + layer += layerSteps + z += 1 + firstLayer = False + return modelData, pos + + def getPositionRanges(self, data): + nOLayers = len(data)/2+1 + myMax = self.getLenOfFirstLayer(data[0]) + for x in data: + if isinstance(x[0], np.float32): + if len(x) > myMax: + myMax = len(x) + xRange = np.arange(-1, 1.1, (2 / (nOLayers - 1))) + yRange = np.arange(-1, 1.1, (2 / (myMax - 1))) + return xRange, yRange + + def getLenOfFirstLayer(self, data): + y = 0 + for x in data: + y += len(x) + return y +''' + for x in data: + nextNodeNumber = 0 + nodeNumber = 0 + if isinstance(x[0], np.ndarray): + for array in x: + for value in array: + modelData.append((layer+nodeNumber, layer+layerSteps+ nextNodeNumber, value)) + + nodeNumber += 1 + + nextNodeNumber += 1 + layer += layerSteps +''' \ No newline at end of file diff --git a/related/EP/src/evalSomething.py b/related/EP/src/evalSomething.py new file mode 100644 index 0000000..4a56ad5 --- /dev/null +++ b/related/EP/src/evalSomething.py @@ -0,0 +1,65 @@ +import matplotlib +matplotlib.use('Agg') +import datetime +from keras.utils import plot_model + +import copy +import numpy as np +import decimal + +try: + from src.PltData import PltData + from src.Functions import Functions + from src.NeuralNetwork import NeuralNetwork + from src.FeatureReduction import FeatureReduction +except ImportError: + from PltData import PltData + from NeuralNetwork import NeuralNetwork + from FeatureReduction import FeatureReduction + import Functions + +def getRangeAroundNumber(myNumber, rangeWidth): + ''' + Gibt einen Zahlen Bereich rund um myNumber aus + :param myNumber: + :return: + ''' + try: + myNumber = myNumber.real + except TypeError: + myNumber = myNumber + d = decimal.Decimal(myNumber.real) + ex = 3 + print(myNumber*(10**ex)) + start = myNumber*(10**ex)-rangeWidth + stop = myNumber * (10**ex) + rangeWidth + data = np.arange(start, stop, 1) + data = data / (10**ex) + return data + +def evalSomething(numberOfNeurons, activationFunctions, featureReduction, + numberLoops, loss): + + nn = NeuralNetwork(numberOfNeurons, activationFunctions, featureReduction, + numberLoops, loss, printVectors=False) + nn.addLayers() + nn.loadModel() + weights = nn.model.get_weights() + data = np.array([nn.featureReductionFunction.calc(weights, nn.numberOfNeurons[0])]) + fp = data[0][0] + #data = getRangeAroundNumber(fp, 30) + data = np.arange(-10000, 10000, 1) + start = min(data) + stop = max(data) + step = abs((start-stop)/len(data)) + text = nn.getDescription() +"\nFixpunkt: "+ str(fp) + nn.evaluate(data, str(start)+"_"+str(stop)+"_"+str(step), text= text + "\nStart: " +str(start) +"\nStop "+ str(stop) + "\nStep "+ str(step)) + +v = np.array([1,2,3,24]) +for i in v: + evalSomething(numberOfNeurons=[1, i, 1], activationFunctions=["sigmoid", "linear"], featureReduction='rfft', + numberLoops=100000, loss='mean_squared_error') + i-=1 + + + diff --git a/related/EP/src/testSomething.py b/related/EP/src/testSomething.py new file mode 100644 index 0000000..dbd33a2 --- /dev/null +++ b/related/EP/src/testSomething.py @@ -0,0 +1,3089 @@ +import matplotlib +matplotlib.use('Agg') +import matplotlib.pyplot as plt +from multiprocessing.pool import ThreadPool +import datetime +from keras.utils import plot_model + +import copy +import numpy as np + +try: + from src.PltData import PltData + from src.Functions import Functions + from src.NeuralNetwork import NeuralNetwork + from src.FeatureReduction import FeatureReduction +except ImportError: + from PltData import PltData + from NeuralNetwork import NeuralNetwork + from FeatureReduction import FeatureReduction + import Functions + +def testSomething(numberOfNeurons, activationFunctions, featureReduction, + numberLoops, loss, printVecs, plotModel, cLM, stepWise, searchForThreshold): + ''' + Funktion die die einzelnen tests ausführt + :param numberOfNeurons: + :param activationFunctions: + :param featureReduction: + :param numberLoops: + :param loss: + :param printVecs: Boolean, Schreibt die Gewicht und dessen Repräsentation in eine Textdati + :param plotModel: Boolean, Plotet das neuronale Netz (Funktion ist nicht vollständig) + :param cLM: Boolean, zur Suche nach dem lokalen Maximum + :param stepWise: + :param searchForThreshold: + :return: + ''' + + nn = NeuralNetwork(numberOfNeurons, activationFunctions, featureReduction, + numberLoops, loss, printVectors=printVecs) + nn.addLayers() + + if searchForThreshold: + value, growing = nn.fit(stepWise, cLM, searchForThreshold) + return value, growing + else: + nn.fit(stepWise, cLM) + nn.saveModel() + if cLM: + return nn.beginGrowing, nn.stopGrowing, nn.LM + + if plotModel: + PltData(None).plotNNModel(nn.model.get_weights(), nn.getFileName()+"_model.png") + + del nn + #plot_model(nn.model, to_file="../images/"+nn.getFileName()+"_model.png", show_shapes=True) + +#estSomething(numberOfNeurons=[20, 200, 200, 200, 200, 20], activationFunctions=["linear", "sigmoid","sigmoid","sigmoid","sigmoid", "linear"], featureReduction='rfft', +# numberLoops=2000, loss='mean_squared_error', printVecs = False, plotModel=False, cLM = False, stepWise=False, searchForThreshold=False) + +def testSomethingStochasticHillClimber(numberOfNeurons, activationFunctions, featureReduction, + numberLoops, loss, printVecs, standardDeviation, numberOtRandomShots): + ''' + Startet den Test für den Hill Climber + :param numberOfNeurons: + :param activationFunctions: + :param featureReduction: + :param numberLoops: + :param loss: + :param printVecs: + :param standardDeviation: + :param numberOtRandomShots: + :return: + ''' + nn = NeuralNetwork(numberOfNeurons, activationFunctions, featureReduction, + numberLoops, loss, printVectors=printVecs, standardDeviation=standardDeviation, + numberOtRandomShots=numberOtRandomShots, fitByHillClimber=False, checkNewWeightsIsReallyBetter=True) + nn.addLayers() + nn.fit() + print(nn.result) + +#testSomethingStochasticHillClimber([1,20, 200, 1], activationFunctions= ["linear","sigmoid", "linear"], featureReduction='meanShuffled', +# numberLoops=10000, loss='mean_squared_error', printVecs=False, standardDeviation=0.00001, +# numberOtRandomShots = 1) + +def plotLerningCurveResults(): + legend = ['Run 1 - VS: 20 linear, 200 Sigmoid', + 'Run 2 - VS: 20 linear, 400 Sigmoid', + 'Run 3 - VS: 20 linear, 600 Sigmoid'] + run1 = [0.03907143, 0.023101171, 0.012541397, 0.0064110383, 0.0031485965, 0.0015067505, 0.00070864701, 0.00032914028, 0.00015132887, 6.8941888e-05, 3.1128071e-05, 1.3933181e-05, 6.1819665e-06, 2.7148787e-06, 1.180582e-06, 5.0955316e-07, 2.1698938e-07, 9.1370673e-08, 3.8020879e-08, 1.5622867e-08, 6.3417342e-09, 2.5369082e-09, 1.002379e-09, 3.903306e-10, 1.4863072e-10, 5.6360049e-11, 2.094506e-11, 7.168975e-12, 2.5646978e-12, 7.938537e-13, 2.7279451e-13, 8.0455011e-14, 2.6053138e-14, 1.81264e-14, 1.4644322e-14, 8.902794e-15, 5.6644447e-15, 5.6119965e-15, 5.285489e-15, 4.9687664e-15, 4.9196521e-15, 4.1220316e-15, 3.6154382e-15, 3.3543352e-15, 1.8204059e-15, 1.4983166e-15, 1.4803459e-15, 1.4624837e-15, 1.4447299e-15, 1.4270845e-15, 1.4095475e-15, 1.392119e-15, 1.3747988e-15, 1.3575871e-15, 1.3404838e-15, 1.0663162e-15, 9.3385382e-16, 2.3793155e-16, 2.3435369e-16, 2.3080293e-16, 2.2727927e-16, 2.2378272e-16, 2.2031327e-16, 1.2102746e-16, 1.1847958e-16, 1.1595881e-16, 1.1346515e-16, 1.1099859e-16, 1.0855913e-16, 1.0614678e-16, 1.0376154e-16, 1.014034e-16, 9.9072362e-17, 9.6768432e-17, 9.4491607e-17, 9.2241888e-17, 9.0019274e-17, 8.7823764e-17, 8.565536e-17, 8.351406e-17, 8.1399866e-17, 7.9312777e-17, 7.7252793e-17, 7.5219914e-17, 2.334084e-17, 1.0376154e-16, 2.334084e-17, 1.0376154e-16, 2.334084e-17, 1.0376154e-16, 2.334084e-17, 1.0376154e-16, 2.334084e-17, 1.0376154e-16, 2.334084e-17, 1.0376154e-16, 2.334084e-17, 1.0376154e-16, 7.5219914e-17, 2.334084e-17, 1.0376154e-16, 7.5219914e-17, 2.334084e-17, 1.0376154e-16, 7.5219914e-17, 1.0376154e-16, 7.5219914e-17, 1.0376154e-16, 7.5219914e-17, 1.0376154e-16, 7.5219914e-17, 1.0376154e-16, 1.1099859e-16, 1.0376154e-16, 1.1099859e-16, 1.0376154e-16, 1.1099859e-16, 1.0614678e-16, 1.1099859e-16, 1.0614678e-16, 1.1099859e-16, 1.0614678e-16, 1.1099859e-16, 1.0614678e-16, 1.1099859e-16, 1.0614678e-16, 1.1099859e-16, 1.0614678e-16, 1.1099859e-16, 1.0855913e-16, 1.1099859e-16, 1.0855913e-16, 1.1099859e-16, 1.0855913e-16, 1.1099859e-16, 8.436482e-16, 9.0794105e-15, 1.0904e-13, 1.7023066e-12, 2.9501533e-11, 5.3653454e-10, 1.0387742e-08, 2.1411108e-07, 4.6733003e-06, 9.9560391e-05, 0.00072649203, 0.00075327634, 0.00077965664, 0.00080627226, 0.00083316793, 0.00086021004, 0.00088745769, 0.00091490505, 0.00094258628, 0.00097035535, 0.00099827035, 0.0010263207, 0.0010545554, 0.0010828193, 0.0011112511, 0.001139752, 0.0011683198, 0.001196943, 0.0012256964, 0.0012543972, 0.0012831399, 0.0013119053, 0.0013407804, 0.0013696461, 0.0013986051, 0.0014274616, 0.0014563295, 0.0014851684, 0.0015140958, 0.0015428948, 0.0015717814, 0.0016006163, 0.0016294435, 0.0016582116, 0.0016870564, 0.0017157437, 0.0017445141, 0.0017732044, 0.0018018826, 0.0018304759, 0.0018591513, 0.001887733, 0.0019163896, 0.0019448469, 0.0019733876, 0.0020018176, 0.0020302401, 0.002058553, 0.0020869495, 0.0021151365, 0.0021434228, 0.0021715835, 0.0021997413, 0.0022277783, 0.0022559145, 0.0022838253, 0.002311849, 0.0023397387, 0.0023677379, 0.0023955884, 0.002423445, 0.0024511595, 0.0024789902, 0.0025065683, 0.0025342731, 0.0025618256, 0.0025895012, 0.0026170141, 0.0026445454, 0.0026719109, 0.0026994103, 0.0027266329, 0.0027540007, 0.0027811979, 0.0028085399, 0.0028356998, 0.0028628977, 0.0028899161, 0.0029170914, 0.0029439682, 0.002971008, 0.0029978587, 0.0030248659, 0.0030516763, 0.0030785445, 0.0031052143, 0.0031320569, 0.0031585807, 0.0031852885, 0.0032117798, 0.0032384607, 0.0032649268, 0.003291578, 0.0033180092, 0.0033445051, 0.003370767, 0.0033972317, 0.0034233478, 0.0034496705, 0.0034757569, 0.0035020567, 0.003528113, 0.0035543775, 0.0035803884, 0.0036064887, 0.0036322188, 0.0036581841, 0.0036838984, 0.0037098464, 0.0037355279, 0.0037614463, 0.003787094, 0.0038129741, 0.0038385764, 0.0038642881, 0.0038895993, 0.0039151716, 0.0039404659, 0.003966019, 0.0039912802, 0.0040168017, 0.0040420252, 0.0040675076, 0.0040926859, 0.0041181259, 0.0041431179, 0.0041682604, 0.0041931057, 0.0042182328, 0.0042430433, 0.0042681471, 0.0042929277, 0.0043179961, 0.0043427343, 0.0043677622, 0.0043924446, 0.0044174218, 0.004441909, 0.0044665649, 0.0044908915, 0.0045155422, 0.0045398502, 0.0045644757, 0.0045887418, 0.0046133287, 0.0046375496, 0.00466209, 0.0046861162, 0.0047104824, 0.0047344756, 0.0047586691, 0.0047824965, 0.0048066727, 0.0048304717, 0.004854626, 0.0048783873, 0.0049024955, 0.0049261996, 0.0049502607, 0.0049737692, 0.0049976436, 0.005021113, 0.00504481, 0.0050681029, 0.005091785, 0.0051150532, 0.005138699, 0.0051619154, 0.0051855156, 0.0052086795, 0.0052322354, 0.005255355, 0.0052788616, 0.0053017638, 0.0053250706, 0.005347929, 0.0053710504, 0.0053937281, 0.005416824, 0.0054394621, 0.0054625282, 0.0054851263, 0.0055081476, 0.0055306912, 0.0055536479, 0.0055761267, 0.0055990331, 0.0056212908, 0.0056439973, 0.0056662206, 0.0056887404, 0.0057107746, 0.0057332674, 0.0057552652, 0.0057777269, 0.0057996851, 0.0058220974, 0.0058439961, 0.0058663534, 0.0058881869, 0.0059104897, 0.0059321029, 0.0059541957, 0.0059757582, 0.0059976578, 0.0060190386, 0.006040914, 0.006062258, 0.0060840934, 0.0061053843, 0.0061271894, 0.0061484366, 0.0061701792, 0.0061913608, 0.0062130513, 0.006234169, 0.0062557855, 0.0062766578, 0.0062978962, 0.0063185804, 0.0063398099, 0.0063604717, 0.0063816737, 0.0064022909, 0.0064234468, 0.0064440193, 0.0064651384, 0.0064856536, 0.0065067038, 0.0065271379, 0.0065481192, 0.0065684868, 0.0065894071, 0.0066097029, 0.0066303867, 0.00665029, 0.0066707828, 0.0066906558, 0.0067111133, 0.0067309425, 0.0067513571, 0.0067711426, 0.0067915185, 0.0068112551, 0.0068315766, 0.0068512387, 0.0068714977, 0.0068910974, 0.0069112834, 0.006930796, 0.0069507458, 0.0069700424, 0.0069899466, 0.0070091803, 0.0070290365, 0.0070480439, 0.0070676878, 0.0070866533, 0.0071062506, 0.0071251681, 0.0071447217, 0.0071635833, 0.0071830861, 0.0072018853, 0.0072213239, 0.0072400514, 0.0072592478, 0.0072777411, 0.0072968965, 0.0073153437, 0.0073344493, 0.0073528336, 0.007371888, 0.0073902146, 0.0074091996, 0.0074274447, 0.0074463603, 0.0074645304, 0.007483372, 0.0075012981, 0.0075197429, 0.0075374651, 0.0075558946, 0.0075735832, 0.0075919735, 0.0076096142, 0.0076279589, 0.0076455399, 0.0076638362, 0.0076813628, 0.0076996093, 0.0077170786, 0.0077352496, 0.0077526374, 0.0077707395, 0.0077880472, 0.0078058988, 0.0078229699, 0.007840774, 0.0078577939, 0.0078755626, 0.0078925248, 0.0079102218, 0.0079271151, 0.0079447515, 0.0079615731, 0.0079791388, 0.0079958681, 0.0080133444, 0.0080300029, 0.0080474196, 0.0080638165, 0.0080808019, 0.008096979, 0.0081139524, 0.0081301099, 0.0081470516, 0.0081631634, 0.008180066, 0.0081961276, 0.0082129762, 0.0082289753, 0.008245755, 0.0082616815, 0.0082784155, 0.0082942881, 0.0083109429, 0.0083267232, 0.0083431229, 0.008358662, 0.0083750244, 0.0083905179, 0.00840683, 0.0084222667, 0.0084385118, 0.0084538721, 0.0084700631, 0.0084853629, 0.008501485, 0.0085167112, 0.008532769, 0.0085479198, 0.0085638994, 0.0085789654, 0.0085946806, 0.0086094905, 0.0086251516, 0.0086399121, 0.0086555229, 0.0086702202, 0.0086857798, 0.0087004192, 0.0087159174, 0.0087304786, 0.0087459115, 0.0087604029, 0.0087757567, 0.0087901708, 0.008805261, 0.0088194218, 0.0088344729, 0.0088485852, 0.0088635869, 0.0088776406, 0.0088925799, 0.0089065647, 0.0089214435, 0.008935363, 0.0089501804, 0.008964031, 0.0089787757, 0.0089925397, 0.0090070125, 0.0090205241, 0.009034968, 0.0090484358, 0.0090628276, 0.0090762498, 0.0090905875, 0.0091039445, 0.0091182152, 0.0091314875, 0.0091457032, 0.0091589298, 0.0091730775, 0.0091862185, 0.0092000952, 0.009212981, 0.0092268223, 0.0092396643, 0.0092534572, 0.0092662554, 0.0092800064, 0.0092927404, 0.0093064364, 0.009319108, 0.0093327248, 0.0093453238, 0.0093588885, 0.0093714138, 0.0093847131, 0.0093969991, 0.0094102612, 0.0094224969, 0.0094357152, 0.0094479006, 0.0094610723, 0.009473199, 0.0094863102, 0.0094983792, 0.0095114307, 0.0095234225, 0.0095364023, 0.0095483186, 0.0095610358, 0.0095727146, 0.0095853927, 0.0095970202, 0.0096096704, 0.0096212551, 0.0096338512, 0.0096453754, 0.0096579092, 0.0096693775, 0.0096818684, 0.0096932752, 0.0097054979, 0.0097166542, 0.0097288517, 0.0097399782, 0.0097521394, 0.0097632194, 0.0097753406, 0.0097863805, 0.0097984476, 0.0098094167, 0.0098214308, 0.0098323412, 0.0098440899, 0.0098549519, 0.0098668542, 0.0098776417, 0.0098894788, 0.0099001927, 0.0099119609, 0.0099226022, 0.0099342903, 0.0099448562, 0.0099564809, 0.0099669844, 0.0099783484, 0.0099885873, 0.0099999001, 0.0100101, 0.010021371, 0.01003151, 0.010042726, 0.010052814, 0.010063994, 0.010074031, 0.010085141, 0.010095118, 0.010105989, 0.010115716, 0.010126538, 0.01013622, 0.010147002, 0.010156653, 0.010167423, 0.01017724, 0.010188126, 0.010197839, 0.010208652, 0.010218286, 0.01022881, 0.010238183, 0.010248669, 0.010257986, 0.010268422, 0.010277685, 0.01028807, 0.010297286, 0.010307617, 0.010316759, 0.010326816, 0.010335717, 0.010345766, 0.010354635, 0.010364647, 0.01037348, 0.010383454, 0.010392448, 0.010402563, 0.010411475, 0.010421302, 0.010429939, 0.010439735, 0.010448331, 0.010458073, 0.010466611, 0.010476304, 0.010484798, 0.010494442, 0.010502876, 0.010512263, 0.010520456, 0.010529818, 0.010537979, 0.010547326, 0.010555671, 0.010565152, 0.010573409, 0.010582831, 0.010591009, 0.010600141, 0.010608065, 0.010617169, 0.010625054, 0.010634128, 0.010641964, 0.010650977, 0.010658756, 0.010667719, 0.010675451, 0.01068416, 0.010691857, 0.010700749, 0.010708389, 0.010717214, 0.010724797, 0.010733569, 0.010741089, 0.010749804, 0.010757259, 0.010765705, 0.010772915, 0.010781341, 0.010788521, 0.010796917, 0.01080406, 0.010812427, 0.010819751, 0.010828269, 0.010835508, 0.010843731, 0.010850689, 0.010858885, 0.010865818, 0.010873965, 0.010880838, 0.01088894, 0.010895775, 0.010903629, 0.010910435, 0.010918469, 0.010925225, 0.01093321, 0.010939918, 0.010947841, 0.010954469, 0.010962124, 0.010968509, 0.010976154, 0.010982529, 0.010990162, 0.010996715, 0.011004496, 0.011010981, 0.011018699, 0.011025099, 0.011032528, 0.011038681, 0.011046094, 0.011052209, 0.011059577, 0.011065653, 0.011072993, 0.011079252, 0.011086536, 0.011092516, 0.011099768, 0.011105706, 0.011112902, 0.011118795, 0.011125964, 0.01113182, 0.01113873, 0.011144349, 0.011151256, 0.011157067, 0.011164148, 0.011169904, 0.011176929, 0.011182625, 0.01118937, 0.011194808, 0.011201544, 0.011206965, 0.01121368, 0.011219288, 0.011226161, 0.011231693, 0.011238288, 0.011243565, 0.011250141, 0.011255387, 0.011261928, 0.011267138, 0.011273646, 0.011279033, 0.011285482, 0.011290605, 0.011297036, 0.011302124, 0.011308506, 0.01131355, 0.011319682, 0.011324494, 0.011330633, 0.011335652, 0.011341968, 0.011346924, 0.011353184, 0.011358093, 0.011364085, 0.011368735, 0.011374718, 0.011379577, 0.011385738, 0.011390534, 0.011396637, 0.011401368, 0.011407188, 0.011411675, 0.011417489, 0.011422169, 0.011428169, 0.011432783, 0.011438495, 0.01144286, 0.011448549, 0.011452884, 0.011458556, 0.011462869, 0.011468515, 0.011473006, 0.011478601, 0.01148283, 0.0114884, 0.0114926, 0.011498133, 0.011502297, 0.011507588, 0.011511733, 0.01151722, 0.011521332, 0.011526774, 0.011530838, 0.011536252, 0.011540285, 0.011545434, 0.011549434, 0.011554772, 0.011558719, 0.011564013, 0.011567923, 0.011572969, 0.011576643, 0.011581676, 0.011585556, 0.011590774, 0.011594595, 0.011599546, 0.011603123, 0.011608073, 0.011611857, 0.011616983, 0.011620703, 0.011625558, 0.011629037, 0.011633878, 0.011637328, 0.011642153, 0.011645797, 0.011650573, 0.011653967, 0.011658729, 0.011662099, 0.011666843, 0.011670195, 0.011674908, 0.011678436, 0.011683093, 0.011686346, 0.011690985, 0.011694224, 0.011698825, 0.011702244, 0.011706798, 0.011709941, 0.011714471, 0.011717598, 0.011722097, 0.011725179, 0.011729424, 0.011732512, 0.011736964, 0.011739995, 0.011744414, 0.011747416, 0.011751587, 0.011754576, 0.011758947, 0.011761904, 0.011766247, 0.011769163, 0.011773237, 0.011776128, 0.011780404, 0.011783257, 0.011787277, 0.011789885, 0.011793899, 0.011796731, 0.011800935, 0.011803703, 0.011807651, 0.011810198, 0.011814148, 0.0118169, 0.011821026, 0.011823707, 0.011827556, 0.011829996, 0.011833851, 0.011836283, 0.011840119, 0.011842752, 0.011846562, 0.011848954, 0.011852743, 0.011855109, 0.011858899, 0.011861483, 0.011865227, 0.011867537, 0.011871247, 0.011873519, 0.011876991, 0.011879283, 0.011882984, 0.011885243, 0.011888904, 0.011891126, 0.011894543, 0.011896766, 0.011900394, 0.011902588, 0.011906195, 0.011908562, 0.011912104, 0.011914201, 0.011917721, 0.011919805, 0.011923081, 0.01192515, 0.011928629, 0.011930658, 0.011934107, 0.011936111, 0.011939304, 0.011941295, 0.011944702, 0.011946653, 0.011950013, 0.011951926, 0.011955048, 0.011956959, 0.011960291, 0.011962165, 0.011965238, 0.011966876, 0.011969957, 0.011971824, 0.011975097, 0.011976913, 0.011979937, 0.011981742, 0.011984962, 0.011986712, 0.011989674, 0.011991203, 0.011994169, 0.011995913, 0.011999075, 0.012000767, 0.012003661, 0.012005339, 0.012008446, 0.012010078, 0.012012918, 0.012014315, 0.012017155, 0.012018769, 0.012021581, 0.012022948, 0.012025766, 0.012027134, 0.012029944, 0.012031516, 0.012034296, 0.012035614, 0.012038375, 0.012039916, 0.012042649, 0.012043927, 0.012046651, 0.012047917, 0.012050632, 0.012052106, 0.012054782, 0.012055995, 0.012058657, 0.012060079, 0.012062702, 0.01206386, 0.012066473, 0.012067633, 0.012070016, 0.012071176, 0.012073785, 0.012074924, 0.012077515, 0.012078856, 0.012081387, 0.012082466, 0.012085009, 0.012086297, 0.012088784, 0.0120898, 0.012092273, 0.01209327, 0.012095494, 0.012096494, 0.012098951, 0.012099938, 0.012102155, 0.012103142, 0.012105567, 0.012106519, 0.012108702, 0.012109648, 0.012112052, 0.012112981, 0.012115362, 0.012116262, 0.012118381, 0.012119267, 0.012121615, 0.012122475, 0.012124568, 0.012125423, 0.012127738, 0.01212857, 0.012130637, 0.01213146, 0.012133732, 0.012134521, 0.012136544, 0.012137327, 0.012139563, 0.012140315, 0.0121423, 0.012142811, 0.012144797, 0.012145548, 0.012147525, 0.012148035, 0.012150023, 0.012150771, 0.012152971, 0.012153677, 0.012155605, 0.012156281, 0.012158413, 0.012159057, 0.01216094, 0.012161576, 0.012163665, 0.012164258, 0.012166088, 0.012166665, 0.012168696, 0.012169252, 0.012171055, 0.012171603, 0.012173595, 0.0121741, 0.012175848, 0.012176351, 0.012178324, 0.012178791, 0.012180487, 0.012180944, 0.012182864, 0.012183302, 0.012184977, 0.01218517, 0.012186855, 0.012187291, 0.012188967, 0.012189173, 0.01219086, 0.012191285, 0.012192933, 0.012193103, 0.012194768, 0.012195177, 0.012196815, 0.012196972, 0.012198617, 0.012199005, 0.012200619, 0.012200758, 0.012202382, 0.01220274, 0.012204333, 0.012204441, 0.012206034, 0.012206368, 0.012207927, 0.012208006, 0.012209347, 0.012209443, 0.012211037, 0.01221136, 0.012212898, 0.012212947, 0.012214494, 0.012214775, 0.012216292, 0.012216317, 0.012217819, 0.012218058, 0.012219535, 0.012219525, 0.012220993, 0.012221185, 0.012222631, 0.012222595, 0.012224022, 0.012224178, 0.012225581, 0.012225502, 0.012226905, 0.012227034, 0.012228415, 0.01222831, 0.012229679, 0.012229783, 0.012231138, 0.012231007, 0.012232129, 0.012231999, 0.012233354, 0.012233217, 0.012234348, 0.012234232, 0.012235591, 0.012235678, 0.012236997, 0.012236825, 0.012238139, 0.012238177, 0.012239455, 0.012239252, 0.012240533, 0.012240541, 0.012241783, 0.01224153, 0.012242541, 0.012242297, 0.012243547, 0.0122433, 0.012244317, 0.012244086, 0.01224532, 0.012245053, 0.012246063, 0.012245823, 0.012247049, 0.012246993, 0.012248181, 0.012247879, 0.012248843, 0.012248543, 0.012249728, 0.012249414, 0.012250364, 0.012250056, 0.012251217, 0.012250895, 0.012251844, 0.012251532, 0.012252471, 0.012252148, 0.012253313, 0.012252967, 0.012253877, 0.012253541, 0.012254687, 0.012254323, 0.012255215, 0.012254852, 0.012255961, 0.012255791, 0.01225687, 0.012256447, 0.012257275, 0.012256837, 0.012257888, 0.012257444, 0.012258267, 0.012257831, 0.012258879, 0.012258641, 0.012259643, 0.012259144, 0.012259901, 0.012259409, 0.012260405, 0.012259901, 0.012260661, 0.012260158, 0.012260915, 0.012260418, 0.012261405, 0.012260895, 0.012261644, 0.012261128, 0.012262085, 0.012261537, 0.012262257, 0.012261725, 0.012262465, 0.012261933, 0.012262887, 0.012262342, 0.012263048, 0.012262488, 0.0122634, 0.012262811, 0.012263495, 0.012262913, 0.012263589, 0.012263007, 0.012263907, 0.012263301, 0.012263959, 0.01226336, 0.012264021, 0.012263412, 0.012264278, 0.012263641, 0.012264261, 0.012263621, 0.01226425, 0.01226339, 0.012264038, 0.012263425, 0.012264072, 0.012263446, 0.012264299, 0.012263649, 0.012264252, 0.01226359, 0.012264192, 0.012263527, 0.012264336, 0.012263636, 0.012264199, 0.012263499, 0.012264073, 0.012263384, 0.012264173, 0.012263448, 0.012263974, 0.012263243, 0.012263777, 0.012263048, 0.012263796, 0.012263034, 0.012263532, 0.012262763, 0.012263262, 0.012262499, 0.012263222, 0.012262437, 0.012262907, 0.012262118, 0.01226259, 0.012261808, 0.012262514, 0.01226171, 0.012262167, 0.012261364, 0.012261817, 0.012261, 0.012261659, 0.012260812, 0.01226124, 0.012260408, 0.012260839, 0.01226001, 0.012260658, 0.012259788, 0.012260192, 0.012259338, 0.012259743, 0.012258891, 0.012259298, 0.012258212, 0.012258637, 0.012257795, 0.012258207, 0.01225736, 0.012257759, 0.012256667, 0.012257072, 0.012256218, 0.012256627, 0.012255771, 0.012256165, 0.012255284, 0.012255882, 0.012254971, 0.012255322, 0.012254411, 0.012254768, 0.012253866, 0.012254217, 0.012253082, 0.012253452, 0.012252551, 0.012252905, 0.012251992, 0.012252334, 0.012251185, 0.012251549, 0.01225065, 0.012250995, 0.012250064, 0.012250389, 0.012249448, 0.012249765, 0.012248599, 0.012248926, 0.012247986, 0.012248312, 0.012247362, 0.01224767, 0.012246491, 0.012246808, 0.012245855, 0.012246161, 0.012245198, 0.012245478, 0.012244501, 0.012244785, 0.012243568, 0.012243852, 0.012242872, 0.01224315, 0.012242153, 0.012242412, 0.012241412, 0.012241672, 0.012240449, 0.01224071, 0.012239702, 0.012239959, 0.012238952, 0.01223919, 0.012238157, 0.01223838, 0.012237122, 0.012237356, 0.012236313, 0.012236532, 0.012235485, 0.012235695, 0.012234643, 0.012234853, 0.012233566, 0.012233768, 0.012232713, 0.012232924, 0.012231858, 0.012232031, 0.012230951, 0.012231133, 0.012229827, 0.012230007, 0.012228925, 0.012229105, 0.01222803, 0.012228191, 0.012227084, 0.012227239, 0.012225916, 0.012226087, 0.012224983, 0.012225138, 0.012224037, 0.012224178, 0.012223059, 0.012223204, 0.012221854, 0.012221988, 0.012220855, 0.012220982, 0.012219848, 0.012219972, 0.012218824, 0.012218924, 0.012217771, 0.012217875, 0.012216492, 0.012216595, 0.012215436, 0.012215536, 0.01221438, 0.012214481, 0.012213313, 0.012213392, 0.012212215, 0.012212293, 0.012210878, 0.012210958, 0.012209778, 0.012209851, 0.012208673, 0.012208744, 0.01220755, 0.012207608, 0.012206397, 0.012206439, 0.012205009, 0.012205069, 0.01220387, 0.012203915, 0.012202697, 0.012202736, 0.012201517, 0.012201551, 0.012200327, 0.012200344, 0.012198878, 0.012198906, 0.012197682, 0.01219771, 0.012196467, 0.012196489, 0.012195253, 0.012195266, 0.012194017, 0.01219401, 0.012192519, 0.012192315, 0.012190871, 0.012190904, 0.012189673, 0.012189697, 0.012188463, 0.012188467, 0.012187212, 0.012187209, 0.012185951, 0.012185944, 0.012184455, 0.01218423, 0.012182754, 0.012182776, 0.012181544, 0.012181554, 0.012180296, 0.012180279, 0.012179007, 0.012178986, 0.012177704, 0.012177665, 0.012176363, 0.012176306, 0.012174787, 0.012174759, 0.012173467, 0.012173418, 0.01217211, 0.012172046, 0.012170725, 0.012170656, 0.012169329, 0.012169246, 0.012167912, 0.012167822, 0.012166474, 0.012166373, 0.012164806, 0.012164733, 0.012163405, 0.012163325, 0.012161984, 0.012161875, 0.012160518, 0.012160417, 0.012159064, 0.012158954, 0.012157585, 0.012157463, 0.012156093, 0.012155967, 0.012154367, 0.012154253, 0.012152888, 0.012152773, 0.012151399, 0.012151264, 0.012149881, 0.012149743, 0.012148356, 0.01214822, 0.012146829, 0.012146675, 0.012145272, 0.012145114, 0.012143707, 0.01214355, 0.012142142, 0.01214198, 0.012140346, 0.012140207, 0.012138811, 0.012138649, 0.012137244, 0.012137079, 0.012135664, 0.012135495, 0.012134075, 0.012133901, 0.012132475, 0.012132289, 0.01213085, 0.012130658, 0.01212922, 0.012129038, 0.012127601, 0.0121274, 0.012125956, 0.012125751, 0.012124082, 0.012123902, 0.012122473, 0.012122289, 0.012120846, 0.012120635, 0.012119174, 0.012118969, 0.012117519, 0.012117302, 0.012115843, 0.012115619, 0.01211415, 0.012113928, 0.012112457, 0.012112229, 0.012110757, 0.01211053, 0.012109054, 0.012108817, 0.012107329, 0.012107092, 0.012105615, 0.012105376, 0.012103895, 0.012103644, 0.012101924, 0.012101693, 0.012100218, 0.012099987, 0.012098503, 0.012098253, 0.012096765, 0.01209651, 0.012095004, 0.012094744, 0.012093239, 0.012092968, 0.012091451, 0.012091185, 0.012089681, 0.012089416, 0.01208791, 0.012087651, 0.012086145, 0.012085863, 0.012084337, 0.012084053, 0.012082535, 0.012082248, 0.01208072, 0.012080435, 0.012078904, 0.012078616, 0.012077081, 0.012076778, 0.012075239, 0.012074944, 0.012073405, 0.012073094, 0.012071546, 0.012071249, 0.012069711, 0.012069409, 0.01206786, 0.012067536, 0.012065971, 0.01206565, 0.012064096, 0.012063778, 0.012062223, 0.012061905, 0.012060349, 0.012060024, 0.012058238, 0.012057929, 0.012056389, 0.012056079, 0.012054523, 0.01205421, 0.012052656, 0.01205234, 0.012050788, 0.012050468, 0.012048909, 0.012048578, 0.012047014, 0.012046681, 0.012045106, 0.012044765, 0.012043183, 0.012042834, 0.012041256, 0.012040908, 0.012039321, 0.012038967, 0.012037382, 0.012037028, 0.012035437, 0.012035083, 0.012033486, 0.012033126, 0.012031532, 0.012031155, 0.012029546, 0.01202918, 0.012027576, 0.01202721, 0.012025824, 0.012025651, 0.01202423, 0.012024023, 0.012022559, 0.012022092, 0.012020407, 0.012019953, 0.012018269, 0.012017825, 0.012016148, 0.012015709, 0.012014044, 0.012013617, 0.012011968, 0.012011545, 0.012009903, 0.012009493, 0.012007843, 0.012007423, 0.012005772, 0.012005349, 0.012003702, 0.012003286, 0.012001641, 0.012001227, 0.011999583, 0.011999165, 0.01199752, 0.01199711, 0.011995472, 0.011995057, 0.011993407, 0.011992982, 0.011991338, 0.011990921, 0.011989268, 0.011988845, 0.011987197, 0.011986772, 0.011985119, 0.011984688, 0.011983024, 0.011982588, 0.011980935, 0.011980504, 0.011978845, 0.011978411, 0.011976754, 0.011976319, 0.011974867, 0.011974622, 0.011973136, 0.011972643, 0.011970925, 0.011970441, 0.011968741, 0.011968253, 0.011966548, 0.011966072, 0.01196437, 0.011963899, 0.011962208, 0.011961741, 0.011960052, 0.011959581, 0.011957883, 0.011957409, 0.011955711, 0.011955242, 0.01195355, 0.011953081, 0.011951383, 0.011950921, 0.011949241, 0.011948773, 0.011947298, 0.011947028, 0.011945521, 0.011944995, 0.011943244, 0.011942719, 0.011940975, 0.011940463, 0.011938731, 0.011938216, 0.011936489, 0.011935987, 0.011934265, 0.011933761, 0.011932041, 0.011931549, 0.011929833, 0.011929333, 0.011927839, 0.011927552, 0.011926019, 0.011925677, 0.011924105, 0.011923512, 0.011921705, 0.011921125, 0.011919346, 0.01191879, 0.01191703, 0.011916501, 0.011914749, 0.011914197, 0.011912432, 0.011911898, 0.011910151, 0.011909631, 0.011908099, 0.011907757, 0.011906188, 0.011905593, 0.011903794, 0.011903216, 0.011901426, 0.011900859, 0.011899082, 0.011898525, 0.01189675, 0.011896198, 0.011894434, 0.011893888, 0.01189235, 0.011892011, 0.011890432, 0.011890051, 0.011888447, 0.011887825, 0.011885989, 0.011885379, 0.011883569, 0.011882975, 0.011881172, 0.011880595, 0.011878801, 0.011878218, 0.011876644, 0.011876262, 0.011874659, 0.011874031, 0.011872199, 0.011871601, 0.011869797, 0.011869191, 0.011867376, 0.011866792, 0.011865005, 0.011864417, 0.011862828, 0.011862445, 0.011860842, 0.011860423, 0.011858783, 0.011858123, 0.011856263, 0.011855626, 0.01185379, 0.01185317, 0.011851337, 0.011850712, 0.011849108, 0.011848699, 0.011847058, 0.011846405, 0.011844561, 0.01184392, 0.011842069, 0.011841437, 0.011839601, 0.011838981, 0.011837373, 0.011836966, 0.011835339, 0.011834895, 0.011833229, 0.011832542, 0.011830651, 0.011829979, 0.011828113, 0.011827459, 0.011825822, 0.01182538, 0.011823718, 0.011823238, 0.011821545, 0.011820833, 0.01181893, 0.01181825, 0.011816379, 0.011815724, 0.011814083, 0.011813615, 0.011811929, 0.01181144, 0.011809738, 0.011809008, 0.011807084, 0.011806378, 0.011804475, 0.011803784, 0.011802129, 0.011801657, 0.011799964, 0.011799249, 0.011797343, 0.011796646, 0.011794751, 0.011794063, 0.011792398, 0.011791927, 0.011790239, 0.011789741, 0.011788029, 0.011787295, 0.011785369, 0.01178464, 0.011782945, 0.011782442, 0.011780726, 0.011780201, 0.011778462, 0.011777704, 0.011775761, 0.011775023, 0.011773096, 0.011772389, 0.011770706, 0.011770209, 0.011768502, 0.011767755, 0.011765813, 0.011765081, 0.011763383, 0.01176287, 0.011761151, 0.011760613, 0.011758863, 0.011758089, 0.011756121, 0.011755358, 0.011753636, 0.0117531, 0.011751368, 0.011750815, 0.011749052, 0.011748266, 0.011746295, 0.011745531, 0.011743806, 0.011743263, 0.011741515, 0.01174095, 0.011739179, 0.011738379, 0.011736397, 0.011735622, 0.011733895, 0.011733338, 0.011731571, 0.01173078, 0.011728805, 0.011728043, 0.01172631, 0.011725748, 0.011723985, 0.011723406, 0.011721623, 0.011720806, 0.011718821, 0.011718045, 0.011716304, 0.011715733, 0.011713962, 0.011713162, 0.011711189, 0.011710417, 0.011708676, 0.011708113, 0.011706349, 0.011705758, 0.011703978, 0.011703177, 0.011701406, 0.011700795, 0.011698991, 0.011698382, 0.011696578, 0.01169573, 0.011693929, 0.011693314, 0.011691502, 0.011690873, 0.01168905, 0.011688198, 0.01168617, 0.011685332, 0.011683539, 0.011682932, 0.011681132, 0.011680283, 0.011678267, 0.011677457, 0.011675684, 0.011675085, 0.011673291, 0.011672458, 0.011670456, 0.01166966, 0.01166789, 0.011667293, 0.011665497, 0.011664672, 0.011662674, 0.011661862, 0.011660091, 0.011659487, 0.011657692, 0.011656858, 0.01165485, 0.011654034, 0.01165226, 0.011651658, 0.011649864, 0.011649034, 0.011647251, 0.011646625, 0.011644812, 0.011644175, 0.011642351, 0.011641486, 0.01163967, 0.011639034, 0.011637202, 0.011636537, 0.011634684, 0.011633792, 0.011631962, 0.011631306, 0.011629463, 0.01162879, 0.011626927, 0.011626017, 0.011624158, 0.011623479, 0.011621612, 0.011620708, 0.011618863, 0.011618191, 0.011616336, 0.011615649, 0.011613778, 0.01161286, 0.011610995, 0.011610306, 0.011608433, 0.01160773, 0.01160584, 0.011604911, 0.011603043, 0.011602347, 0.011600471, 0.011599551, 0.011597685, 0.011596988, 0.011595112, 0.011594411, 0.011592531, 0.011591605, 0.011589728, 0.011589018, 0.01158713, 0.011586202, 0.011584334, 0.011583632, 0.011581744, 0.011581027, 0.011579135, 0.011578194, 0.011576316, 0.011575608, 0.011573711, 0.011572762, 0.011570876, 0.011570158, 0.011568264, 0.01156754, 0.011565864, 0.011565113, 0.011563183, 0.011562423, 0.011560486, 0.011559502, 0.011557591, 0.011556848, 0.011554934, 0.011554189, 0.011552482, 0.011551706, 0.011549759, 0.011548977, 0.011547235, 0.011546428, 0.011544456, 0.011543657, 0.011541691, 0.011540677, 0.011538736, 0.011537963, 0.01153602, 0.011535238, 0.011533494, 0.011532688, 0.011530724, 0.011529929, 0.011528182, 0.011527362, 0.011525378, 0.011524555, 0.011522778, 0.011521946, 0.011519955, 0.01151912, 0.011517132, 0.01151609, 0.01151412, 0.01151332, 0.011511347, 0.011510326, 0.01150838, 0.011507584, 0.011505622, 0.011504835, 0.011503099, 0.011502284, 0.011500303, 0.011499482, 0.011497722, 0.011496891, 0.011494897, 0.011494063, 0.01149228, 0.011491421, 0.011489408, 0.011488559, 0.011486754, 0.011485878, 0.011483856, 0.011483001, 0.011481205, 0.011480336, 0.011478309, 0.011477445, 0.011475638, 0.011474754, 0.01147272, 0.011471852, 0.011470045, 0.011469166, 0.011467126, 0.011466251, 0.011464441, 0.011463557, 0.011461517, 0.011460635, 0.011458808, 0.011457901, 0.011455851, 0.011454972, 0.011453157, 0.011452261, 0.011450212, 0.011449317, 0.011447483, 0.011446576, 0.01144452, 0.011443626, 0.011441796, 0.011440889, 0.011438834, 0.011437945, 0.011436113, 0.011435199, 0.011433141, 0.011432245, 0.011430411, 0.011429491, 0.011427429, 0.011426523, 0.011424684, 0.011423762, 0.011421703, 0.011420801, 0.011418964, 0.011418037, 0.011416182, 0.011415462, 0.011413577, 0.011412619, 0.011410722, 0.011409746, 0.011407642, 0.011406699, 0.011404817, 0.011403852, 0.011401752, 0.011400805, 0.011398931, 0.011397983, 0.011395893, 0.011394959, 0.011393098, 0.011392155, 0.011390276, 0.011389525, 0.011387615, 0.011386625, 0.011384717, 0.011383948, 0.011382019, 0.011381007, 0.011379068, 0.011378054, 0.011375906, 0.011374913, 0.011372997, 0.011372005, 0.011369882, 0.011368908, 0.011367013, 0.011366034, 0.011364124, 0.011363347, 0.011361417, 0.011360409, 0.011358478, 0.011357452, 0.011355301, 0.011354319, 0.011352411, 0.011351413, 0.011349496, 0.011348704, 0.011346764, 0.01134574, 0.011343794, 0.011342763, 0.011340601, 0.0113396, 0.011337684, 0.011336679, 0.011334755, 0.011333961, 0.011332007, 0.011330976, 0.011329023, 0.011327978, 0.011325804, 0.011324783, 0.011322849, 0.011321829, 0.011319897, 0.011319087, 0.011317118, 0.011316068, 0.011314115, 0.01131307, 0.011311113, 0.01131028, 0.011308303, 0.011307241, 0.011305262, 0.011304413, 0.011302422, 0.011301343, 0.011299358, 0.011298284, 0.011296298, 0.011295438, 0.011293439, 0.011292353, 0.011290354, 0.011289271, 0.011287287, 0.011286427, 0.01128442, 0.011283321, 0.011281323, 0.011280454, 0.011278659, 0.011277749, 0.011275697, 0.011274565, 0.011272538, 0.011271633, 0.01126959, 0.011268462, 0.011266434, 0.011265321, 0.011263303, 0.01126241, 0.01126038, 0.011259259, 0.01125723, 0.011256105, 0.011254089, 0.011253202, 0.011251175, 0.011250049, 0.011248023, 0.011246908, 0.011244901, 0.011244006, 0.011241968, 0.01124084, 0.01123881, 0.011237686, 0.011235666, 0.011234775, 0.011232958, 0.011232014, 0.011229942, 0.011228781, 0.011226722, 0.011225787, 0.011223934, 0.011222973, 0.01122089, 0.011219708, 0.01121763, 0.011216681, 0.011214814, 0.01121383, 0.011211726, 0.011210535, 0.011208452, 0.011207275, 0.011205198, 0.011204237, 0.011202153, 0.011200971, 0.011198903, 0.011197748, 0.011195695, 0.011194753, 0.011192899, 0.011191922, 0.011189828, 0.011188642, 0.011186563, 0.011185606, 0.011183732, 0.011182737, 0.011180618, 0.011179404, 0.011177306, 0.011176111, 0.011174024, 0.011173055, 0.011171171, 0.011170161, 0.011168049, 0.011166846, 0.011164743, 0.011163755, 0.011161861, 0.011160844, 0.011158925, 0.011157888, 0.011155732, 0.011154484, 0.011152358, 0.011151343, 0.011149419, 0.011148376, 0.011146429, 0.011145368, 0.011143201, 0.011141938, 0.011139795, 0.011138767, 0.011136833, 0.011135776, 0.011133822, 0.011132748, 0.011130562, 0.011129286, 0.011127134, 0.0111261, 0.011124162, 0.011123095, 0.011121131, 0.011120049, 0.011117854, 0.011116555, 0.011114383, 0.011113319, 0.011111356, 0.011110292, 0.01110833, 0.011107242, 0.01110526, 0.01110415, 0.011101932, 0.011100838, 0.011098854, 0.011097739, 0.01109573, 0.011094603, 0.011092578, 0.011091434, 0.01108919, 0.011087846, 0.011085635, 0.01108454, 0.011082552, 0.01108144, 0.011079454, 0.01107835, 0.011076342, 0.011075209, 0.011072968, 0.011071634, 0.011069437, 0.011068348, 0.011066359, 0.011065247, 0.011063252, 0.011062126, 0.011060114, 0.011058975, 0.011056742, 0.011055405, 0.011053194, 0.011052084, 0.011050086, 0.011048963, 0.011046951, 0.011045809, 0.011043787, 0.011042638, 0.011040601, 0.011039435, 0.011037178, 0.011036033, 0.011034004, 0.011032844, 0.011030794, 0.011029614, 0.011027556, 0.011026382, 0.01102433, 0.011023152, 0.01102109, 0.011019891, 0.011017609, 0.011016435, 0.011014381, 0.011013199, 0.011011137, 0.011009951, 0.011007885, 0.011006689, 0.011004614, 0.011003412, 0.011001333, 0.011000127, 0.01099805, 0.010996847, 0.010994555, 0.010993354, 0.010991283, 0.010990082, 0.010988004, 0.010986793, 0.010984707, 0.01098349, 0.010981405, 0.010980189, 0.010978089, 0.010976857, 0.010974759, 0.010973536, 0.010971439, 0.010970416, 0.010968286, 0.010967035, 0.01096492, 0.01096367, 0.010961551, 0.010960296, 0.010958168, 0.01095691, 0.010954794, 0.01095354, 0.010951417, 0.010950159, 0.010948028, 0.010946775, 0.010944661, 0.010943615, 0.010941681, 0.010940592, 0.010938412, 0.010937103, 0.010934933, 0.010933637, 0.010931478, 0.010930186, 0.010928028, 0.010926736, 0.010924583, 0.010923292, 0.010921132, 0.010919844, 0.010917699, 0.010916414, 0.010914272, 0.010912997, 0.010910858, 0.010909786, 0.01090783, 0.010906721, 0.010904729, 0.010903578, 0.010901553, 0.010900377, 0.010898125, 0.010896744, 0.010894518, 0.010893154, 0.01089093, 0.010889574, 0.010887365, 0.010886023, 0.01088383, 0.010882506, 0.010880327, 0.010879002, 0.010876813, 0.010875488, 0.01087331, 0.01087199, 0.010869807, 0.010868493, 0.010866327, 0.01086501, 0.010862838, 0.010861519, 0.010859357, 0.010858268, 0.010856298, 0.010855155, 0.010853139, 0.010851963, 0.010849921, 0.01084872, 0.010846654, 0.010845426, 0.010843339, 0.010842104, 0.010840003, 0.01083875, 0.010836639, 0.010835376, 0.010833247, 0.010831948, 0.010829804, 0.010828516, 0.010826373, 0.010825074, 0.010822915, 0.010821608, 0.010819458, 0.010818153, 0.010815989, 0.01081467, 0.010812497, 0.010811171, 0.010808999, 0.010807666, 0.010805487, 0.01080416, 0.010801976, 0.010800644, 0.010798465, 0.010797133, 0.010794944, 0.010793598, 0.010791413, 0.010790073, 0.010787891, 0.010786548, 0.010784357, 0.010783015, 0.010780824, 0.010779475, 0.010777277, 0.010775922, 0.010773722, 0.010772364, 0.010770163, 0.010768815, 0.010766618, 0.010765255, 0.010763053, 0.010761695, 0.010759499, 0.010758138, 0.010755938, 0.010754566, 0.010752348, 0.010750977, 0.010748768, 0.010747408, 0.010745201, 0.010743834, 0.010741631, 0.010740262, 0.01073805, 0.010736675, 0.010734463, 0.010733088, 0.010730874, 0.010729498, 0.010727282, 0.010725894, 0.010723664, 0.010722271, 0.010720044, 0.01071866, 0.010716441, 0.01071485, 0.010712438, 0.010710879, 0.010708507, 0.010706978, 0.010704827, 0.010703513, 0.010701356, 0.010700022, 0.010697857, 0.010696515, 0.010694335, 0.010692982, 0.01069078, 0.010689406, 0.0106872, 0.010685828, 0.010683608, 0.010682216, 0.01067999, 0.0106786, 0.010676377, 0.010674977, 0.010672749, 0.010671358, 0.010669132, 0.010667738, 0.010665509, 0.010664107, 0.010662081, 0.010660656, 0.010658405, 0.010656982, 0.010654724, 0.010653295, 0.010651042, 0.010649618, 0.010647357, 0.010645933, 0.010643679, 0.010642252, 0.010639991, 0.010638558, 0.010636305, 0.010634878, 0.010632622, 0.010631192, 0.010629139, 0.01062789, 0.010625806, 0.01062432, 0.010622007, 0.010620522, 0.010618218, 0.01061674, 0.01061444, 0.010612974, 0.010610691, 0.01060922, 0.010606927, 0.010605461, 0.010603167, 0.010601705, 0.010599631, 0.010598354, 0.01059624, 0.010594731, 0.0105924, 0.010590883, 0.010588556, 0.010587061, 0.010584748, 0.010583256, 0.010580945, 0.010579451, 0.010577146, 0.010575664, 0.010573571, 0.010572284, 0.01057016, 0.010568628, 0.010566288, 0.01056476, 0.010562421, 0.01056091, 0.010558587, 0.010557081, 0.010554755, 0.010553242, 0.01055112, 0.010549802, 0.010547657, 0.010546109, 0.010543754, 0.010542215, 0.010539863, 0.01053834, 0.010536015, 0.010534496, 0.010532367, 0.010531032, 0.010528867, 0.010527505, 0.010525315, 0.010523718, 0.010521318, 0.010519742, 0.010517362, 0.010515795, 0.010513633, 0.010512267, 0.010510076, 0.010508684, 0.010506465, 0.010504847, 0.010502432, 0.010500833, 0.01049843, 0.010496839, 0.01049467, 0.01049329, 0.010491075, 0.01048966, 0.010487434, 0.010485796, 0.010483364, 0.010481754, 0.010479349, 0.010477753, 0.010475561, 0.010474164, 0.010471952, 0.010470532, 0.010468297, 0.01046665, 0.010464208, 0.010462584, 0.010460369, 0.010458941, 0.010456703, 0.010455264, 0.010453008, 0.010451336, 0.010448878, 0.01044724, 0.010445021, 0.010443584, 0.01044133, 0.010439867, 0.010437598, 0.010436123, 0.010433839, 0.01043214, 0.010429864, 0.010428381, 0.010426096, 0.010424603, 0.010422311, 0.010420806, 0.010418499, 0.01041678, 0.010414484, 0.010412972, 0.010410666, 0.010409156, 0.010406841, 0.010405322, 0.010403004, 0.010401264, 0.010398944, 0.010397417, 0.010395093, 0.010393566, 0.010391238, 0.010389498, 0.01038719, 0.010385672, 0.010383353, 0.010381813, 0.010379474, 0.010377932, 0.010375595, 0.010373844, 0.010371523, 0.010369986, 0.01036766, 0.010366117, 0.010363773, 0.010362224, 0.010360093, 0.01035852, 0.010356149, 0.01035457, 0.010352206, 0.010350625, 0.010348451, 0.010346849, 0.010344464, 0.01034286, 0.010340464, 0.010338861, 0.010336477, 0.010334668, 0.010332292, 0.01033071, 0.010328349, 0.010326774, 0.010324406, 0.010322819, 0.01032065, 0.010319042, 0.010316643, 0.010315028, 0.010312626, 0.010311003, 0.010308802, 0.010307171, 0.010304758, 0.010303121, 0.010300705, 0.010299075, 0.010296867, 0.010295225, 0.010292808, 0.010291169, 0.010288748, 0.0102871, 0.010284878, 0.01028322, 0.010280785, 0.010279126, 0.010276696, 0.010275047, 0.010272827, 0.010271162, 0.010268728, 0.01026708, 0.010264848, 0.010263375, 0.010261115, 0.010259409, 0.010256938, 0.01025525, 0.010252988, 0.010251285, 0.010248814, 0.010247124, 0.010244664, 0.010242978, 0.010240728, 0.010239035, 0.010236572, 0.010234886, 0.010232626, 0.010231128, 0.010228846, 0.010227122, 0.010224628, 0.010222909, 0.010220629, 0.010219102, 0.010216791, 0.010215039, 0.010212732, 0.010211187, 0.010208851, 0.010207067, 0.010204538, 0.010202786, 0.010200474, 0.010198912, 0.010196565, 0.010194776, 0.010192441, 0.010190865, 0.01018851, 0.010186707, 0.010184153, 0.010182379, 0.010180048, 0.010178468, 0.010176114, 0.010174312, 0.010171959, 0.010170364, 0.010167995, 0.010166186, 0.010163637, 0.010161849, 0.010159498, 0.010157906, 0.010155543, 0.01015374, 0.010151388, 0.010149781, 0.010147404, 0.010145588, 0.010143225, 0.010141607, 0.010139219, 0.010137384, 0.010135, 0.010133373, 0.010130974, 0.010129327, 0.01012692, 0.010125058, 0.010122651, 0.010120995, 0.010118581, 0.010116726, 0.010114322, 0.01011267, 0.01011026, 0.010108395, 0.010105997, 0.010104353, 0.010101939, 0.010100069, 0.010097666, 0.010096012, 0.010093598, 0.010091934, 0.010089712, 0.010088012, 0.010085553, 0.010083845, 0.010081583, 0.01007985, 0.010077371, 0.010075648, 0.010073368, 0.01007161, 0.010069106, 0.010067352, 0.010064853, 0.010062912, 0.010060443, 0.010058721, 0.010056246, 0.010054315, 0.010051855, 0.010050146, 0.010047684, 0.01004577, 0.01004332, 0.010041613, 0.010039154, 0.010037241, 0.010034792, 0.010033078, 0.010030614, 0.010028699, 0.010026261, 0.010024558, 0.010022302, 0.010020567, 0.01001809, 0.010016352, 0.010014069, 0.010012311, 0.010009807, 0.010008038, 0.01000573, 0.010003957, 0.010001442, 0.0099996636, 0.0099973436, 0.0099955481, 0.0099930186, 0.0099912314, 0.0099889077, 0.0099870982, 0.009984551, 0.0099827461, 0.0099804085, 0.0099785971, 0.0099760517, 0.0099742422, 0.0099718925, 0.0099700671, 0.0099675078, 0.0099656917, 0.0099633429, 0.0099615091, 0.0099591501, 0.0099575166, 0.0099551296, 0.0099532614, 0.0099508706, 0.0099490024, 0.009946404, 0.0099445516, 0.0099421693, 0.0099403048, 0.0099377166, 0.0099358661, 0.0099334838, 0.0099316239, 0.0099290404, 0.009927188, 0.0099248076, 0.0099229468, 0.009920557, 0.00991889, 0.0099164741, 0.0099145658, 0.0099121463, 0.0099102501, 0.0099076293, 0.009905749, 0.0099033481, 0.0099014612, 0.0098990537, 0.0098973513, 0.0098949084, 0.0098929862, 0.0098905526, 0.0098888306, 0.0098863775, 0.0098844515, 0.0098820068, 0.0098800743, 0.0098776268, 0.0098758927, 0.0098734191, 0.009871454, 0.009868986, 0.0098672435, 0.0098647662, 0.0098627992, 0.0098603219, 0.0098583652, 0.0098558981, 0.0098541547, 0.0098516755, 0.0098497057, 0.009847221, 0.0098454552, 0.0098429723, 0.0098409969, 0.0098385075, 0.0098365378, 0.0098340567, 0.0098322835, 0.0098297847, 0.0098277973, 0.009825306, 0.0098235309, 0.0098212315, 0.0098194238, 0.0098168915, 0.0098148752, 0.0098123578, 0.0098105511, 0.0098080263, 0.0098060118, 0.0098034972, 0.0098014986, 0.0097989924, 0.0097971912, 0.0097946767, 0.0097926715, 0.00979017, 0.0097883744, 0.0097860498, 0.0097842086, 0.0097816549, 0.0097796181, 0.0097770821, 0.0097752577, 0.0097729173, 0.0097710593, 0.0097684925, 0.0097664399, 0.009763889, 0.0097620385, 0.0097596785, 0.0097578121, 0.0097552389, 0.0097531732, 0.0097506093, 0.0097487522, 0.0097463839, 0.0097445073, 0.00974192, 0.0097398376, 0.0097372681, 0.0097354073, 0.0097330324, 0.0097311437, 0.009728549, 0.0097264592, 0.0097238831, 0.009722013, 0.0097196326, 0.009717741, 0.0097153438, 0.00971343, 0.0097108176, 0.0097089102, 0.0097065037, 0.0097045796, 0.0097021442, 0.0097001949, 0.0096975574, 0.0096956324, 0.0096932044, 0.0096912552, 0.0096887993, 0.0096868416, 0.0096841957, 0.0096822577, 0.0096798195, 0.0096778572, 0.0096753994, 0.0096734269, 0.0096709644, 0.0096689882, 0.0096663171, 0.0096643465, 0.0096618859, 0.0096599096, 0.0096574426, 0.0096554644, 0.0096529927, 0.0096511906, 0.0096486816, 0.0096466616, 0.009644161, 0.0096421335, 0.0096396217, 0.0096375998, 0.009635088, 0.0096332598, 0.0096307304, 0.0096286871, 0.009626165, 0.0096241217, 0.0096215913, 0.0096195452, 0.0096168183, 0.0096147954, 0.0096122883, 0.009610259, 0.0096077546, 0.0096057272, 0.0096032107, 0.0096013714, 0.0095990337, 0.0095971618, 0.0095946044, 0.0095925266, 0.0095899682, 0.0095878914, 0.0095853396, 0.0095834695, 0.0095810965, 0.0095791798, 0.0095765823, 0.0095744738, 0.0095718922, 0.0095697911, 0.0095672142, 0.0095651131, 0.0095625427, 0.0095606511, 0.0095580667, 0.0095559647, 0.0095533952, 0.0095513007, 0.0095487274, 0.0095466413, 0.0095440801, 0.0095421867, 0.0095398137, 0.0095378971, 0.0095352978, 0.0095331771, 0.0095305843, 0.0095284646, 0.0095258756, 0.0095237587, 0.0095211705, 0.0095192557, 0.0095168613, 0.0095149251, 0.009512309, 0.0095101697, 0.0095075713, 0.0095054461, 0.0095028561, 0.0095009338, 0.0094985235, 0.009496564, 0.0094941324, 0.0094921514, 0.00948969, 0.0094876904, 0.0094850231, 0.0094828261, 0.0094801737, 0.0094782012, 0.0094757462, 0.0094737448, 0.0094712703, 0.0094692549, 0.0094667682, 0.0094647296, 0.0094622262, 0.0094601838, 0.0094574783, 0.0094552496, 0.0094525665, 0.0094505455, 0.0094480589, 0.0094460323, 0.0094435429, 0.0094414959, 0.0094389832, 0.0094369324, 0.0094344104, 0.0094323326, 0.0094295964, 0.0094273388, 0.0094246417, 0.0094226124, 0.0094201118, 0.0094180712, 0.0094155669, 0.0094135124, 0.0094109923, 0.009408921, 0.0094063915, 0.0094043184, 0.0094017824, 0.0093996944, 0.0093971491, 0.0093950564, 0.0093923109, 0.0093902294, 0.0093876915, 0.0093855951, 0.0093830414, 0.0093809487, 0.0093783969, 0.0093762921, 0.0093737291, 0.0093716187, 0.0093690539, 0.0093669426, 0.0093643805, 0.009362272, 0.0093597099, 0.009357783, 0.0093551939, 0.0093530612, 0.0093504731, 0.0093483292, 0.0093457401, 0.0093436055, 0.0093410229, 0.0093388865, 0.0093362955, 0.0093341544, 0.0093315691, 0.0093294308, 0.0093268445, 0.0093247015, 0.0093221106, 0.0093199536, 0.0093173562, 0.0093154013, 0.0093129883, 0.0093110027, 0.0093085505, 0.0093065295, 0.0093038576, 0.0093016373, 0.0092989784, 0.009296773, 0.009294129, 0.0092919329, 0.0092892973, 0.0092871059, 0.0092844721, 0.0092822788, 0.0092796534, 0.0092774713, 0.0092748562, 0.0092726806, 0.0092700664, 0.0092678908, 0.0092652738, 0.0092632929, 0.0092608556, 0.0092588346, 0.009256362, 0.0092543131, 0.0092518236, 0.0092497608, 0.009247249, 0.00924516, 0.0092426259, 0.0092405193, 0.0092379656, 0.0092358394, 0.0092332819, 0.0092311502, 0.0092285769, 0.009226446, 0.0092238756, 0.0092217242, 0.0092189433, 0.0092166178, 0.009213876, 0.0092115803, 0.0092088608, 0.00920658, 0.0092038773, 0.0092016123, 0.0091989236, 0.0091966745, 0.0091940006, 0.0091917589, 0.0091890963, 0.0091868648, 0.0091842059, 0.0091819856, 0.0091793351, 0.0091771167, 0.0091744782, 0.0091724554, 0.0091699837, 0.0091679245, 0.0091654314, 0.0091633471, 0.0091608223, 0.0091587184, 0.0091561833, 0.009154059, 0.0091514988, 0.0091493623, 0.0091467984, 0.0091446564, 0.0091420775, 0.0091399131, 0.0091373278, 0.009135168, 0.0091325762, 0.0091304034, 0.0091278078, 0.0091256304, 0.0091230292, 0.0091208406, 0.0091182319, 0.0091160452, 0.0091134375, 0.0091112396, 0.0091086226, 0.0091064163, 0.0091037909, 0.0091015873, 0.009098961, 0.0090967501, 0.0090941284, 0.0090919174, 0.0090892874, 0.0090870699, 0.0090846233, 0.0090825781, 0.0090800943, 0.0090780137, 0.0090755112, 0.0090734102, 0.0090708816, 0.0090687498, 0.0090661887, 0.0090640364, 0.0090614725, 0.0090593081, 0.0090567218, 0.0090543497, 0.0090515772, 0.009049233, 0.0090464856, 0.0090441648, 0.0090414425, 0.0090391301, 0.0090364134, 0.0090341186, 0.0090314234, 0.0090291398, 0.0090264482, 0.0090241674, 0.0090214778, 0.0090192053, 0.0090165325, 0.0090142712, 0.0090116002, 0.0090093361, 0.0090066688, 0.0090044113, 0.0090017505, 0.0089994902, 0.0089970119, 0.0089949276, 0.0089924289, 0.0089903139, 0.0089877807, 0.0089856405, 0.0089830803, 0.0089809122, 0.008978338, 0.0089761661, 0.0089735836, 0.0089713829, 0.0089687761, 0.0089665651, 0.0089639444, 0.0089615313, 0.0089587411, 0.0089563662, 0.0089536011, 0.0089512467, 0.0089485031, 0.0089461645, 0.0089436239, 0.0089414716, 0.0089389132, 0.0089367358, 0.0089341495, 0.0089319507, 0.0089293523, 0.0089271395, 0.008924529, 0.0089223152, 0.0089196982, 0.0089174779, 0.0089148553, 0.0089126136, 0.0089099798, 0.0089075444, 0.0089047318, 0.0089023309, 0.0088997399, 0.0088975355, 0.0088949259, 0.0088927029, 0.0088900831, 0.0088878507, 0.0088852197, 0.0088829696, 0.0088803312, 0.008878083, 0.0088754399, 0.0088731851, 0.008870542, 0.0088682817, 0.0088656265, 0.0088631688, 0.0088605303, 0.0088582803, 0.0088556428, 0.0088533834, 0.0088507412, 0.0088484772, 0.008845821, 0.0088435495, 0.0088408859, 0.0088386061, 0.0088359388, 0.0088336589, 0.0088311872, 0.0088290814, 0.0088265752, 0.0088242432, 0.0088215275, 0.0088192048, 0.0088165011, 0.0088141747, 0.0088114776, 0.0088091623, 0.0088064652, 0.0088041518, 0.0088016512, 0.0087995138, 0.0087969778, 0.0087948134, 0.0087922607, 0.0087898802, 0.0087871253, 0.0087847561, 0.0087820077, 0.008779645, 0.0087769115, 0.0087745581, 0.0087720258, 0.0087698549, 0.0087672863, 0.0087650903, 0.0087625152, 0.0087601114, 0.0087573463, 0.0087549621, 0.0087522082, 0.0087498389, 0.0087472778, 0.0087450836, 0.0087425141, 0.0087403096, 0.0087377159, 0.0087354723, 0.0087328441, 0.0087303976, 0.0087275924, 0.0087251766, 0.008722594, 0.0087203626, 0.0087177521, 0.0087155048, 0.0087128822, 0.0087106247, 0.0087079965, 0.008705535, 0.0087027196, 0.0087002888, 0.0086976858, 0.0086954376, 0.0086928206, 0.008690563, 0.008687933, 0.0086856605, 0.0086830193, 0.0086805504, 0.0086779147, 0.0086756404, 0.0086729974, 0.00867071, 0.0086680586, 0.0086657619, 0.0086630974, 0.0086607933, 0.0086581288, 0.0086556394, 0.0086529879, 0.0086506894, 0.0086480314, 0.0086457273, 0.0086430581, 0.0086407484, 0.0086380737, 0.0086355703, 0.0086329104, 0.0086306082, 0.0086279493, 0.0086256489, 0.0086229807, 0.0086206617, 0.0086179823, 0.0086156595, 0.0086131664, 0.0086108278, 0.0086081354, 0.0086057996, 0.0086030988, 0.0086007463, 0.0085980436, 0.0085956948, 0.0085931821, 0.0085908128, 0.0085880989, 0.0085857464, 0.0085830344, 0.00858068, 0.008578158, 0.008575961, 0.0085734017, 0.008570997, 0.0085682431, 0.0085658431, 0.0085631032, 0.0085607208, 0.0085581774, 0.0085559674, 0.0085533904, 0.008550968, 0.0085482001, 0.0085457861, 0.0085430332, 0.0085406313, 0.0085380748, 0.0085356655, 0.0085329181, 0.0085305134, 0.0085277651, 0.0085253716, 0.0085228216, 0.0085206041, 0.0085180299, 0.0085156057, 0.0085128415, 0.0085104248, 0.008507859, 0.0085056266, 0.0085030394, 0.0085007716, 0.0084981509, 0.0084956801, 0.0084928777, 0.008490433, 0.008487843, 0.0084855743, 0.0084829507, 0.0084804837, 0.0084776869, 0.008475245, 0.0084726531, 0.0084703844, 0.0084677702, 0.0084652994, 0.0084625073, 0.0084600635, 0.008457466, 0.0084551917, 0.0084525729, 0.0084502846, 0.0084476545, 0.0084451661, 0.0084425369, 0.0084402394, 0.0084375981, 0.0084352782, 0.0084326193, 0.0084301084, 0.0084274635, 0.0084251408, 0.0084224772, 0.0084201498, 0.0084174927, 0.0084149698, 0.0084123081, 0.0084099798, 0.008407318, 0.0084049776, 0.0084023038, 0.0083997762, 0.0083971173, 0.0083947862, 0.0083921179, 0.0083897738, 0.0083871, 0.0083845649, 0.0083818994, 0.0083795628, 0.0083768982, 0.0083745504, 0.0083720526, 0.0083696702, 0.0083669629, 0.008364588, 0.0083618881, 0.0083595132, 0.008356994, 0.0083545931, 0.0083518727, 0.0083494848, 0.0083467737, 0.0083443783, 0.0083418442, 0.0083394349, 0.008336707, 0.0083343033, 0.0083317608, 0.0083295256, 0.0083269542, 0.008324502, 0.0083217369, 0.0083192997, 0.0083167339, 0.0083142854, 0.0083115315, 0.0083091026, 0.0083063506, 0.0083039207, 0.0083013605, 0.0082989195, 0.0082961721, 0.0082937442, 0.0082911849, 0.0082889237, 0.0082863299, 0.0082838554, 0.0082810754, 0.0082786176, 0.0082760351, 0.0082737571, 0.0082711568, 0.0082686683, 0.0082660541, 0.0082637481, 0.0082611255, 0.0082586231, 0.0082558189, 0.0082533369, 0.0082507385, 0.0082484363, 0.008245809, 0.0082433065, 0.0082406858, 0.0082383649, 0.0082357246, 0.0082332101, 0.0082305791, 0.0082282471, 0.0082255993, 0.0082232524, 0.0082205879, 0.0082180435, 0.0082153976, 0.0082130479, 0.0082103861, 0.0082078455, 0.0082051968, 0.0082028471, 0.0082001844, 0.0081978273, 0.0081953434, 0.0081929592, 0.0081902724, 0.0081878817, 0.0081851855, 0.0081826048, 0.0081799198, 0.0081775347, 0.0081748469, 0.0081722774, 0.0081696054, 0.0081672315, 0.0081645586, 0.0081621734, 0.0081596673, 0.0081572616, 0.0081545571, 0.0081521515, 0.0081496248, 0.0081471987, 0.0081444765, 0.0081420522, 0.0081393374, 0.0081367344, 0.0081340363, 0.008131641, 0.0081289429, 0.0081265429, 0.0081240283, 0.0081216041, 0.0081188874, 0.0081164632, 0.0081139235, 0.0081114862, 0.0081087602, 0.0081063267, 0.0081037842, 0.0081013376, 0.0080986004, 0.0080961511, 0.0080935983, 0.0080911461, 0.0080884015, 0.0080859475, 0.0080833873, 0.0080811046, 0.0080785239, 0.008076041, 0.0080734547, 0.0080711441, 0.0080685318, 0.0080660218, 0.0080632307, 0.0080607301, 0.0080581382, 0.0080556441, 0.0080528641, 0.0080503756, 0.008047794, 0.0080453074, 0.0080425451, 0.0080400724, 0.0080374973, 0.0080350097, 0.0080322456, 0.0080297701, 0.0080271969, 0.0080247177, 0.0080219619, 0.008019493, 0.0080169309, 0.0080144545, 0.0080117043, 0.0080092354, 0.0080066752, 0.0080041969, 0.0080014374, 0.0079989666, 0.0079964055, 0.0079941098, 0.007991706, 0.0079893693, 0.0079867486, 0.0079843961, 0.007981942, 0.0079795606, 0.0079768961, 0.0079745008, 0.007972002, 0.0079695787, 0.0079668881, 0.0079644714, 0.0079619568, 0.0079595232, 0.007956815, 0.0079543758, 0.0079518436, 0.0079493867, 0.0079466645, 0.00794404, 0.0079413364, 0.007938901, 0.0079361964, 0.0079335831, 0.0079309037, 0.0079284925, 0.0079258112, 0.0079232128, 0.0079205427, 0.0079181427, 0.0079154707, 0.0079128873, 0.0079102302, 0.0079078376, 0.007905351, 0.0079029314, 0.0079002455, 0.0078978222, 0.0078953113, 0.0078928676, 0.0078901593, 0.0078877211, 0.0078851962, 0.0078827394, 0.0078800237, 0.0078775734, 0.007875043, 0.0078725806, 0.0078698555, 0.0078673894, 0.007864845, 0.0078623742, 0.007859827, 0.0078575257, 0.0078549478, 0.0078524426, 0.0078498637, 0.007847352, 0.0078445878, 0.0078420946, 0.0078395288, 0.007837031, 0.0078342808, 0.0078317896, 0.0078292182, 0.0078267204, 0.0078241508, 0.0078218253, 0.0078192353, 0.007816718, 0.0078141317, 0.0078117857, 0.0078091719, 0.0078066266, 0.0078040184, 0.0078014834, 0.0077987001, 0.0077961748, 0.0077935834, 0.0077910605, 0.0077884733, 0.0077861301, 0.0077835228, 0.0077809845, 0.0077783847, 0.0077760289, 0.0077734152, 0.0077708722, 0.0077682636, 0.0077658943, 0.007763451, 0.0077610523, 0.0077583995, 0.0077558178, 0.0077531766, 0.0077507729, 0.0077481205, 0.0077455449, 0.007742913, 0.007740519, 0.0077380491, 0.0077356268, 0.0077329576, 0.0077303629, 0.007727717, 0.0077253054, 0.0077226455, 0.0077200504, 0.0077174036, 0.0077150003, 0.0077125332, 0.0077101043, 0.0077074291, 0.0077048168, 0.007702155, 0.0076997401, 0.00769726, 0.0076948232, 0.0076921452, 0.0076897065, 0.0076872059, 0.0076847523, 0.0076820576, 0.007679434, 0.0076767653, 0.0076743253, 0.0076718233, 0.007669372, 0.0076666865, 0.0076642418, 0.0076617347, 0.0076592672, 0.0076567451, 0.0076542734, 0.007651567, 0.0076490985, 0.0076465718, 0.0076440908, 0.0076413825, 0.007638908, 0.0076363762, 0.0076338933, 0.0076313624, 0.0076288763, 0.0076261619, 0.0076236883, 0.0076211602, 0.0076186731, 0.007616132, 0.0076136277, 0.0076108989, 0.0076084109, 0.0076058777, 0.0076033827, 0.007600843, 0.0075985161, 0.007595947, 0.0075934264, 0.0075908634, 0.00758834, 0.00758577, 0.0075834249, 0.0075808442, 0.007578304, 0.0075757229, 0.007573185, 0.0075706071, 0.0075682462, 0.0075656525, 0.0075631058, 0.0075605181, 0.0075579737, 0.0075553884, 0.0075530158, 0.0075504128, 0.0075478465, 0.00754525, 0.0075426949, 0.007540103, 0.007537724, 0.0075351209, 0.0075325668, 0.0075299754, 0.0075275884, 0.0075251516, 0.0075227437, 0.0075201178, 0.007517532, 0.0075149201, 0.0075125266, 0.0075100791, 0.0075076544, 0.0075050103, 0.0075024054, 0.0074997754, 0.0074973595, 0.0074949069, 0.0074924757, 0.0074898279, 0.0074872193, 0.0074845892, 0.0074821683, 0.0074796975, 0.007477249, 0.0074747675, 0.0074723097, 0.0074696424, 0.0074671903, 0.0074647004, 0.0074622314, 0.0074597318, 0.0074572559, 0.0074545727, 0.0074519292, 0.0074492707, 0.0074468246, 0.0074443417, 0.0074418737, 0.0074392026, 0.0074365772, 0.0074339365, 0.007431502, 0.0074290321, 0.0074265804, 0.0074240956, 0.0074216295, 0.0074189557, 0.0074164919, 0.0074140024, 0.0074115274, 0.0074090278, 0.0074065486, 0.007404035, 0.0074017118, 0.0073991804, 0.0073966733, 0.0073941397, 0.0073916237, 0.0073890924, 0.0073865741, 0.0073838583, 0.007381354, 0.0073788296, 0.0073763258, 0.0073737986, 0.0073712883, 0.0073687606, 0.0073664212, 0.0073638787, 0.0073613548, 0.0073588109, 0.0073562837, 0.0073537421, 0.0073513887, 0.0073490008, 0.0073466185, 0.0073440326, 0.0073414673, 0.0073388922, 0.0073363343, 0.0073337676, 0.0073313969, 0.007328996, 0.0073265913, 0.0073239845, 0.0073213987, 0.0073188092, 0.0073162359, 0.0073136562, 0.0073112659, 0.0073086796, 0.0073061092, 0.0073035313, 0.0073009678, 0.0072984002, 0.0072960197, 0.007293622, 0.0072912271, 0.0072888061, 0.0072863786, 0.0072837654, 0.0072811632, 0.0072785611, 0.0072761523, 0.0072737271, 0.0072712959, 0.007268854, 0.0072664148, 0.0072637899, 0.0072611724, 0.007258561, 0.0072561335, 0.0072536967, 0.0072512566, 0.0072487951, 0.0072463378, 0.0072437036, 0.007241081, 0.0072384654, 0.0072360327, 0.007233589, 0.0072311405, 0.0072286837, 0.0072262273, 0.0072235879, 0.0072209639, 0.0072183521, 0.0072159227, 0.0072134887, 0.007211044, 0.0072085881, 0.0072061275, 0.0072036674, 0.0072012004, 0.0071985614, 0.0071961065, 0.0071936427, 0.0071911709, 0.0071887006, 0.0071862312, 0.0071837567, 0.0071812738, 0.0071787941, 0.0071764775, 0.0071739797, 0.0071714679, 0.0071689584, 0.0071664518, 0.007163953, 0.0071614468, 0.007158943, 0.007156434, 0.0071539297, 0.0071515832, 0.0071490668, 0.0071465508, 0.0071440381, 0.0071415142, 0.0071390024, 0.0071364893, 0.0071339896, 0.0071316487, 0.0071292957, 0.0071269143, 0.007124362, 0.0071218116, 0.007119278, 0.0071167373, 0.0071142092, 0.0071116672, 0.0071091475, 0.0071067922, 0.0071044317, 0.0071020494, 0.0070994981, 0.0070969393, 0.0070944014, 0.0070918486, 0.0070893154, 0.0070867748, 0.0070842565, 0.0070818961, 0.0070795338, 0.0070771393, 0.0070745796, 0.0070720157, 0.0070694759, 0.0070669288, 0.0070644012, 0.0070620244, 0.0070596491, 0.0070572551, 0.0070548696, 0.0070524556, 0.0070500518, 0.0070476211, 0.0070450315, 0.0070424378, 0.0070398697, 0.0070372932, 0.0070347521, 0.0070323562, 0.0070299683, 0.007027566, 0.0070251743, 0.0070227487, 0.0070203366, 0.007017897, 0.0070153121, 0.0070127151, 0.0070101474, 0.0070077335, 0.0070053372, 0.0070029106, 0.0070004952, 0.0069980491, 0.0069956314, 0.0069931862, 0.0069907624, 0.0069883084, 0.0069858781, 0.0069835871, 0.0069811279, 0.0069786417, 0.0069761858, 0.0069737029, 0.0069712494, 0.0069687734, 0.0069663208, 0.0069638337, 0.0069613778, 0.0069588977, 0.0069564432, 0.0069541251, 0.0069516515, 0.0069491458, 0.0069466741, 0.0069441739, 0.0069417097, 0.0069392142, 0.006936748, 0.0069342563, 0.0069318018, 0.0069293133, 0.0069268541, 0.0069245324, 0.006922225, 0.0069198697, 0.0069173672, 0.0069148317, 0.0069123376, 0.0069098216, 0.0069073448, 0.0069048433, 0.0069023734, 0.0068998691, 0.0068974048, 0.0068949051, 0.0068924506, 0.0068901288, 0.0068878285, 0.006885475, 0.006883136, 0.006880756, 0.0068782424, 0.0068756957, 0.0068731899, 0.0068706525, 0.0068681692, 0.0068656523, 0.006863181, 0.0068606716, 0.0068582017, 0.0068558659, 0.0068535577, 0.0068511995, 0.0068488698, 0.0068464847, 0.0068441336, 0.0068417364, 0.0068393676, 0.0068369536, 0.0068344106, 0.0068318313, 0.0068293139, 0.0068267677, 0.0068242676, 0.0068218978, 0.0068195597, 0.0068171704, 0.0068148156, 0.0068124072, 0.0068100388, 0.0068076202, 0.00680525, 0.0068028262, 0.0068004429, 0.0067980103, 0.006795621, 0.0067931875, 0.006790631, 0.0067880363, 0.0067855041, 0.0067831031, 0.0067807459, 0.0067783287, 0.0067759538, 0.0067735305, 0.0067711552, 0.0067687188, 0.0067663323, 0.0067639016, 0.0067615183, 0.0067590815, 0.0067566964, 0.0067542591, 0.0067518763, 0.0067494386, 0.0067470456, 0.0067447606, 0.0067425151, 0.0067402087, 0.006737778, 0.0067352918, 0.006732862, 0.0067303791, 0.0067279479, 0.0067254645, 0.0067230463, 0.006720576, 0.0067181587, 0.0067156903, 0.00671328, 0.0067108204, 0.0067084194, 0.0067059617, 0.0067035612, 0.0067010983, 0.0066986918, 0.0066963942, 0.0066941399, 0.0066918177, 0.0066895466, 0.0066872034, 0.0066849128, 0.0066825491, 0.0066800732, 0.0066775475, 0.0066750878, 0.0066725756, 0.0066701313, 0.0066676307, 0.0066652037, 0.0066627194, 0.006660297, 0.0066578202, 0.0066554081, 0.0066529382, 0.0066505303, 0.0066482252, 0.0066459756, 0.0066436492, 0.0066413782, 0.0066390275, 0.0066367295, 0.0066343648, 0.0066320603, 0.0066296807, 0.0066273645, 0.0066249785, 0.0066226465, 0.0066202446, 0.006617907, 0.0066155023, 0.0066131623, 0.0066107484, 0.0066084005, 0.0066059842, 0.0066036363, 0.0066012242, 0.0065987161, 0.0065961513, 0.0065936656, 0.0065911235, 0.0065886667, 0.0065863095, 0.0065840171, 0.0065816496, 0.0065793507, 0.0065769712, 0.0065746545, 0.0065722661, 0.0065699471, 0.0065675485, 0.0065652179, 0.0065628192, 0.0065604942, 0.0065580928, 0.0065557589, 0.0065533523, 0.0065510208, 0.0065486124, 0.0065462794, 0.0065438696, 0.0065415348, 0.0065391236, 0.0065367846, 0.0065343697, 0.0065320306, 0.0065296185, 0.0065272837, 0.0065248655, 0.0065225284, 0.0065201153, 0.006517773, 0.0065155202, 0.0065133357, 0.0065110512, 0.0065088305, 0.0065065236, 0.0065042856, 0.0065019559, 0.0064996993, 0.0064973584, 0.0064950907, 0.0064927372, 0.006490455, 0.0064880853, 0.0064857965, 0.0064834217, 0.0064811269, 0.0064787483, 0.0064764488, 0.0064740605, 0.006471592, 0.0064690532, 0.0064666108, 0.0064640963, 0.0064616776, 0.0064591863, 0.0064567877, 0.0064543104, 0.0064519262, 0.0064494619, 0.0064470912, 0.00644464, 0.0064422823, 0.0064398418, 0.0064374935, 0.0064350665, 0.0064327237, 0.006430299, 0.0064279647, 0.0064255381, 0.0064232093, 0.0064207898, 0.0064184642, 0.0064160563, 0.0064137364, 0.0064113322, 0.0064090234, 0.0064066187, 0.0064043049, 0.006402066, 0.0063999007, 0.0063976278, 0.0063954396, 0.0063931542, 0.0063909502, 0.0063886419, 0.0063864207, 0.0063841059, 0.0063818749, 0.006379535, 0.0063772821, 0.0063749366, 0.0063726823, 0.0063703284, 0.0063680722, 0.0063657193, 0.0063634561, 0.0063610966, 0.0063588354, 0.0063564745, 0.0063542053, 0.0063518407, 0.0063495724, 0.0063472004, 0.006344927, 0.0063425582, 0.0063402834, 0.0063379034, 0.0063356236, 0.0063332482, 0.0063309777, 0.0063286028, 0.0063263308, 0.0063239592, 0.0063216868, 0.0063193124, 0.0063170362, 0.0063146567, 0.0063123847, 0.0063100113, 0.0063077402, 0.0063053649, 0.006303092, 0.0063007195, 0.0062984522, 0.0062960857, 0.0062938184, 0.0062914435, 0.006289178, 0.0062868088, 0.0062845428, 0.0062821722, 0.0062799118, 0.0062775491, 0.0062754513, 0.0062732301, 0.0062710987, 0.0062688496, 0.0062666968, 0.0062644277, 0.0062622577, 0.0062599699, 0.0062577846, 0.00625548, 0.0062532779, 0.0062509649, 0.0062487558, 0.0062464345, 0.0062442217, 0.0062418976, 0.006239681, 0.0062373471, 0.0062351171, 0.0062327771, 0.0062305457, 0.0062282006, 0.0062259673, 0.0062236222, 0.0062213899, 0.0062190453, 0.0062168129, 0.0062144692, 0.0062122419, 0.0062098992, 0.0062076682, 0.006205325, 0.0062030856, 0.0062007317, 0.0061984966, 0.0061961422, 0.0061939009, 0.0061915508, 0.0061893212, 0.0061869766, 0.0061847488, 0.0061824028, 0.0061801756, 0.0061778273, 0.0061755963, 0.0061732521, 0.0061710221, 0.0061686751, 0.0061664423, 0.0061640977, 0.0061618714, 0.0061595263, 0.0061573079, 0.0061549698, 0.00615275, 0.0061504091, 0.006148343, 0.0061461441, 0.0061440556, 0.0061418321, 0.0061397185, 0.0061374782, 0.006135351, 0.0061329328, 0.006130646, 0.0061282464, 0.0061259717, 0.0061235847, 0.0061213239, 0.0061189458, 0.0061166962, 0.006114325, 0.0061120819, 0.0061097187, 0.0061074882, 0.0061051352, 0.0061029093, 0.0061005647, 0.0060983454, 0.0060960022, 0.0060937908, 0.0060914527, 0.0060892422, 0.0060869064, 0.006084701, 0.0060823732, 0.0060801734, 0.0060778474, 0.0060756463, 0.0060733175, 0.0060711256, 0.0060687978, 0.0060667503, 0.0060645635, 0.0060624992, 0.0060602953, 0.0060582072, 0.0060559786, 0.0060538729, 0.0060516307, 0.0060495166, 0.0060472637, 0.0060451305, 0.006042867, 0.0060407333, 0.0060384646, 0.0060363272, 0.0060340515, 0.006031909, 0.0060296259, 0.006027468, 0.0060251779, 0.0060230196, 0.0060207299, 0.0060185753, 0.0060161292, 0.0060138269, 0.0060114008, 0.0060091261, 0.0060067317, 0.006004638, 0.0060023936, 0.0060002855, 0.005998034, 0.0059959074, 0.005993647, 0.0059915246, 0.0059892596, 0.0059871287, 0.0059848563, 0.0059827249, 0.0059804521, 0.0059783193, 0.0059760464, 0.0059739072, 0.0059716227, 0.0059694834, 0.0059672003, 0.0059650564, 0.0059627718, 0.0059606307, 0.0059583476, 0.0059562069, 0.005953921, 0.0059517813, 0.0059494986, 0.0059475126, 0.0059453682, 0.0059433556, 0.0059410376, 0.0059388648, 0.0059365463, 0.005934373, 0.0059320629, 0.0059299017, 0.0059276004, 0.0059254481, 0.0059231552, 0.0059210053, 0.0059187091, 0.0059165666, 0.0059142788, 0.0059121428, 0.0059098597, 0.00590772, 0.0059054331, 0.0059032952, 0.0059010126, 0.0058990326, 0.0058968891, 0.0058948835, 0.0058927191, 0.0058906898, 0.0058885044, 0.0058864648, 0.0058842688, 0.0058822124, 0.0058798459, 0.0058776443, 0.005875296, 0.0058731087, 0.0058707804, 0.0058686058, 0.0058662863, 0.0058641271, 0.0058618202, 0.0058596698, 0.0058573727, 0.0058553875, 0.0058532394, 0.005851232, 0.0058490597, 0.0058470368, 0.0058448492, 0.0058428114, 0.0058406144, 0.0058385669, 0.0058363583, 0.0058342968, 0.0058320765, 0.005830016, 0.0058277939, 0.005825724, 0.0058233459, 0.0058211354, 0.0058187745, 0.0058167391, 0.0058145435, 0.0058125039, 0.0058103013, 0.0058082491, 0.0058060293, 0.0058039674, 0.0058017494, 0.0057996851, 0.0057974611, 0.0057953973, 0.0057931682, 0.0057910956, 0.005788865, 0.0057867952, 0.0057845633, 0.0057824939, 0.0057802643, 0.0057783453, 0.0057760901, 0.0057740011, 0.0057717524, 0.0057696695, 0.0057674288, 0.0057653491, 0.0057631042, 0.0057610311, 0.0057587931, 0.0057567181, 0.0057544755, 0.0057524014, 0.0057501658, 0.0057480973, 0.0057458626, 0.0057437937, 0.0057415576, 0.0057396418, 0.0057375478, 0.0057356087, 0.0057333317, 0.0057312264, 0.0057289661, 0.0057268762, 0.0057246233, 0.0057225423, 0.0057202973, 0.0057182238, 0.0057159825, 0.0057139145, 0.0057116789, 0.0057096146, 0.0057073776, 0.0057054642, 0.0057033673, 0.0057014306, 0.0056993137, 0.0056973598, 0.0056952271, 0.0056932583, 0.0056909593, 0.0056888405, 0.0056865583, 0.0056844582, 0.0056821899, 0.0056800987, 0.005677843, 0.0056757648, 0.0056735175, 0.0056715994, 0.0056694956, 0.0056675579, 0.0056654345, 0.0056634787, 0.0056613437, 0.0056593763, 0.0056572231, 0.0056552403, 0.0056529278, 0.0056508058, 0.0056485189, 0.005646416, 0.0056441454, 0.0056422157, 0.005640097, 0.0056381454, 0.0056360061, 0.0056340373, 0.0056318925, 0.0056299213, 0.0056277635, 0.0056257849, 0.0056236247, 0.0056216349, 0.0056194663, 0.0056174803, 0.0056151613, 0.005613185, 0.0056110215, 0.0056090313, 0.0056068599, 0.0056048729, 0.0056027067, 0.0056007202, 0.0055985493, 0.005596559, 0.0055943835, 0.0055923942, 0.0055902191, 0.0055882283, 0.0055860518, 0.0055842088, 0.0055820146, 0.0055800038, 0.0055778092, 0.005575804, 0.0055736164, 0.0055716187, 0.005569438, 0.0055674384, 0.0055652549, 0.005563261, 0.0055610784, 0.0055590859, 0.0055569098, 0.0055550658, 0.0055530248, 0.0055511626, 0.005548947, 0.0055469214, 0.0055447109, 0.0055426918, 0.005540492, 0.0055384878, 0.0055362978, 0.0055343024, 0.0055321176, 0.0055301231, 0.0055279434, 0.0055261012, 0.0055240556, 0.0055221915, 0.0055201268, 0.005518239, 0.0055160043, 0.0055139717, 0.0055117491, 0.0055097225, 0.0055075139, 0.0055055069, 0.005503309, 0.0055014533, 0.0054993932, 0.0054975203, 0.0054954467, 0.0054935645, 0.0054914774, 0.0054895729, 0.0054873172, 0.0054852734, 0.0054830462, 0.0054810219, 0.0054788101, 0.0054769507, 0.0054748775, 0.0054729958, 0.0054709134, 0.0054690214, 0.0054669254, 0.0054650242, 0.0054629212, 0.0054610083, 0.0054588942, 0.0054569799, 0.0054547181, 0.0054526702, 0.0054504289, 0.0054485425, 0.0054464485, 0.0054445518, 0.0054424484, 0.0054405457, 0.0054384433, 0.0054365369, 0.0054344232, 0.0054325131, 0.005430399, 0.0054284832, 0.0054262159, 0.0054243151, 0.0054222085, 0.0054202969, 0.0054181851, 0.0054162769, 0.0054141604, 0.0054122498, 0.0054101353, 0.0054082219, 0.0054061036, 0.0054041953, 0.0054019336, 0.0054000355, 0.0053979321, 0.0053960318, 0.0053939195, 0.0053920145, 0.0053899037, 0.0053880028, 0.0053858953, 0.0053839902, 0.0053818803, 0.0053801239, 0.0053781443, 0.0053763613, 0.0053742058, 0.0053722616, 0.0053701135, 0.0053681764, 0.0053660357, 0.0053641112, 0.005361978, 0.0053600511, 0.0053579207, 0.005356153, 0.005354153, 0.005352356, 0.0053503383, 0.0053485227, 0.0053463434, 0.0053443834, 0.005342219, 0.0053402698, 0.0053381086, 0.0053361719, 0.0053340299, 0.0053322515, 0.005330252, 0.0053284504, 0.0053264285, 0.0053246161, 0.0053224326, 0.005320474, 0.0053183101, 0.0053163641, 0.0053142044, 0.0053124153, 0.0053104074, 0.0053086048, 0.005306575, 0.005304758, 0.0053027198, 0.0053008916, 0.005298696, 0.0052967309, 0.0052945586, 0.0052926075, 0.0052904435, 0.0052886521, 0.0052866349, 0.0052848333, 0.0052828109, 0.0052809999, 0.0052789622, 0.005277134, 0.0052750879, 0.0052732625, 0.005271066, 0.0052692476, 0.0052672024, 0.0052653719, 0.0052633164, 0.0052614841, 0.0052594254, 0.0052575786, 0.0052555129, 0.0052536712, 0.0052516107, 0.0052497708, 0.0052475608, 0.0052457284, 0.0052436669, 0.0052418276, 0.005239767, 0.0052379314, 0.0052358694, 0.0052340315, 0.0052319737, 0.0052301358, 0.0052280691, 0.0052263737, 0.0052242978, 0.0052224486, 0.0052203727, 0.0052185263, 0.005216449, 0.005214598, 0.0052125282, 0.0052106841, 0.0052086138, 0.0052069179, 0.0052049817, 0.0052032606, 0.005201153, 0.0051992801, 0.0051971842, 0.0051953206, 0.0051932326, 0.005191376, 0.0051892935, 0.0051875846, 0.0051856325, 0.0051839054, 0.005181795, 0.005179917, 0.0051778131, 0.0051759495, 0.0051738615, 0.005172004, 0.0051699188, 0.005168071, 0.0051659928, 0.0051642922, 0.0051623466, 0.0051606251, 0.0051585189, 0.0051566549, 0.0051545682, 0.0051527168, 0.0051506343, 0.0051487926, 0.0051467218, 0.005145032, 0.0051430953, 0.0051413812, 0.0051394231, 0.0051376894, 0.0051355683, 0.0051336922, 0.0051315916, 0.0051297341, 0.0051276437, 0.0051259366, 0.0051239878, 0.0051222695, 0.0051203081, 0.0051185777, 0.0051164608, 0.005114587, 0.0051124808, 0.0051106228, 0.0051085339, 0.0051068333, 0.0051048887, 0.0051031751, 0.0051012142, 0.0050994861, 0.0050975122, 0.0050957729, 0.0050936434, 0.0050917636, 0.0050896574, 0.0050879396, 0.0050859768, 0.0050842576, 0.0050822855, 0.0050805435, 0.0050785574, 0.0050768163, 0.0050746854, 0.0050729481, 0.0050709676, 0.0050692298, 0.0050672418, 0.0050654928, 0.0050634989, 0.0050617517, 0.0050597587, 0.0050580078, 0.0050560096, 0.0050543989, 0.0050523896, 0.005050621, 0.0050486089, 0.0050468422, 0.0050448319, 0.0050430722, 0.0050410605, 0.0050392994, 0.0050372905, 0.0050356705, 0.0050336481, 0.0050318707, 0.0050298511, 0.0050280844, 0.0050260676, 0.0050243, 0.0050222841, 0.0050205183, 0.0050185053, 0.005016888, 0.0050148703, 0.0050131031, 0.005011085, 0.0050093192, 0.0050073084, 0.0050055487, 0.0050035361, 0.0050017792, 0.0049997792, 0.0049981694, 0.0049962956, 0.0049946653, 0.0049926294, 0.0049908515, 0.0049888222, 0.0049870433, 0.00498502, 0.0049833949, 0.0049815057, 0.0049798628, 0.0049779578, 0.0049762987, 0.0049742376, 0.004972443, 0.0049704006, 0.0049686148, 0.0049665803, 0.0049649463, 0.0049630501, 0.0049614012, 0.0049594869, 0.0049578268, 0.0049557611, 0.0049539637, 0.0049519152, 0.0049501299, 0.0049480973, 0.0049464675, 0.0049445736, 0.0049429322, 0.0049410276, 0.0049393736, 0.0049373107, 0.0049355114, 0.0049334639, 0.0049318229, 0.0049299165, 0.0049282685, 0.0049263556, 0.0049246959, 0.0049227709, 0.0049211057, 0.004919033, 0.0049172314, 0.0049151811, 0.0049135424, 0.0049116365, 0.0049099843, 0.0049080686, 0.004906415, 0.0049044904, 0.0049028187, 0.0049007428, 0.0048989435, 0.0048968955, 0.0048952606, 0.0048933546, 0.0048917099, 0.0048897988, 0.0048881462, 0.0048862221, 0.0048845601, 0.0048826355, 0.0048811133, 0.0048791692, 0.0048774839, 0.0048755351, 0.0048738546, 0.0048719086, 0.0048702299, 0.0048682843, 0.0048666056, 0.0048646606, 0.0048631225, 0.0048611672, 0.004859481, 0.0048575276, 0.0048558391, 0.0048538828, 0.004852199, 0.0048502479, 0.0048487079, 0.0048468872, 0.004845323, 0.0048433398, 0.0048416317, 0.0048396592, 0.0048379558, 0.0048359837, 0.0048342906, 0.0048323316, 0.0048307832, 0.0048288144, 0.0048271208, 0.0048251599, 0.0048234761, 0.004821517, 0.0048198341, 0.0048178821, 0.0048163398, 0.0048145172, 0.0048129559, 0.0048109754, 0.0048092762, 0.0048073069, 0.0048056147, 0.0048036552, 0.0048019751, 0.0048000207, 0.0047984826, 0.0047966577, 0.0047950996, 0.0047931187, 0.0047914204, 0.0047894558, 0.004787771, 0.0047858153, 0.0047842772, 0.004782455, 0.0047808983, 0.0047790571, 0.0047774874, 0.0047754948, 0.0047737854, 0.0047718082, 0.004770115, 0.0047681495, 0.0047666039, 0.004764773, 0.0047632158, 0.0047613708, 0.0047597969, 0.0047578015, 0.0047560968, 0.0047541168, 0.0047525619, 0.0047507253, 0.0047491654, 0.0047473195, 0.0047457456, 0.0047438839, 0.0047423001, 0.0047402955, 0.0047387183, 0.004736858, 0.0047352798, 0.0047334149, 0.0047318246, 0.0047299471, 0.0047283527, 0.0047264779, 0.0047248816, 0.0047228602, 0.0047212737, 0.0047194026, 0.0047178138, 0.0047159391, 0.0047143498, 0.0047124717, 0.0047108708, 0.0047088461, 0.0047072633, 0.0047053937, 0.0047038053, 0.0047019292, 0.0047003371, 0.0046984628, 0.0046968777, 0.0046950029, 0.0046935491, 0.0046916585, 0.0046900511, 0.0046881544, 0.0046865498, 0.0046846606, 0.0046830606, 0.004681176, 0.0046795849, 0.0046777022, 0.0046762428, 0.0046743467, 0.0046727401, 0.0046708458, 0.0046692421, 0.0046673524, 0.0046657543, 0.0046638665, 0.0046624104, 0.0046606483, 0.004659167, 0.0046572499, 0.0046556261, 0.0046537137, 0.0046520969, 0.0046501914, 0.0046487171, 0.0046469471, 0.0046454621, 0.0046435357, 0.0046419092, 0.0046399976, 0.004638385, 0.0046364842, 0.0046348781, 0.0046329824, 0.0046315202, 0.0046297526, 0.0046282713, 0.0046263495, 0.0046247281, 0.004622818, 0.0046212091, 0.0046193101, 0.004617847, 0.0046160799, 0.004614599, 0.0046128128, 0.0046113129, 0.0046093725, 0.0046077394, 0.0046058199, 0.0046043396, 0.0046025519, 0.0046010618, 0.0045992672, 0.0045977645, 0.0045958278, 0.0045941933, 0.0045922687, 0.0045907875, 0.0045890003, 0.0045875078, 0.004585708, 0.0045842058, 0.004582399, 0.0045808842, 0.004578935, 0.0045773024, 0.004575375, 0.0045738905, 0.0045721028, 0.004570615, 0.0045688166, 0.004567313, 0.0045655016, 0.0045639905, 0.0045620417, 0.0045605423, 0.0045587393, 0.0045572361, 0.0045554275, 0.0045539173, 0.0045521054, 0.0045505962, 0.0045486493, 0.0045471461, 0.0045453366, 0.0045438339, 0.0045420188, 0.0045405077, 0.0045386907, 0.0045371777, 0.0045353551, 0.0045339684, 0.0045321323, 0.0045306077, 0.0045287777, 0.0045272545, 0.0045254235, 0.0045239022, 0.0045220731, 0.0045205532, 0.0045185909, 0.0045170817, 0.004515267, 0.004513761, 0.0045119431, 0.0045104339, 0.0045086197, 0.0045071179, 0.0045053046, 0.0045039332, 0.0045021037, 0.0045005837, 0.0044987607, 0.0044972487, 0.004495427, 0.0044939155, 0.0044920929, 0.0044907155, 0.0044890163, 0.0044876197, 0.0044857711, 0.0044842372, 0.0044823936, 0.004480863, 0.004479026, 0.0044776378, 0.0044759279, 0.0044745193, 0.0044726538, 0.004471106, 0.0044692531, 0.0044677239, 0.0044658817, 0.0044643553, 0.0044625234, 0.004461145, 0.0044594393, 0.0044580363, 0.0044561769, 0.0044546369, 0.0044527887, 0.0044512623, 0.0044494243, 0.0044480427, 0.0044463356, 0.0044449358, 0.0044430769, 0.0044415398, 0.0044396906, 0.0044381656, 0.0044363323, 0.004434953, 0.0044332463, 0.0044318484, 0.0044301283, 0.0044287173, 0.0044268472, 0.0044253045, 0.0044234511, 0.004422056, 0.0044203349, 0.0044189291, 0.0044171996, 0.0044157826, 0.0044140401, 0.0044126157, 0.0044107311, 0.0044093062, 0.0044075549, 0.0044061295, 0.0044043818, 0.0044029499, 0.0044011953, 0.0043997611, 0.0043978682, 0.0043963119, 0.0043944428, 0.0043930365, 0.0043913024, 0.0043898863, 0.0043881428, 0.0043867198, 0.0043849749, 0.0043835524, 0.0043816678, 0.0043802536, 0.0043785144, 0.0043770913, 0.0043753418, 0.0043739155, 0.0043721618, 0.0043707341, 0.0043688514, 0.0043674372, 0.0043656947, 0.0043642768, 0.0043625338, 0.0043611135, 0.0043593612, 0.0043579335, 0.0043561831, 0.0043548928, 0.0043531265, 0.0043516844, 0.0043499125, 0.0043484736, 0.004346706, 0.004345268, 0.004343505, 0.0043422068, 0.0043404344, 0.0043389918, 0.0043372218, 0.0043357867, 0.0043340223, 0.0043325843, 0.0043308162, 0.00432951, 0.0043278639, 0.0043265419, 0.0043247482, 0.0043232893, 0.0043215011, 0.0043200497, 0.0043182722, 0.0043168291, 0.0043150559, 0.0043137493, 0.0043119695, 0.0043105222, 0.0043087457, 0.0043073054, 0.0043055345, 0.004304104, 0.0043023415, 0.0043010428, 0.0042994041, 0.0042980858, 0.0042962916, 0.0042948364, 0.0042930515, 0.0042916047, 0.0042898282, 0.0042885216, 0.0042868704, 0.0042855465, 0.004283749, 0.0042822999, 0.0042805197, 0.0042790766, 0.0042773029, 0.004275999, 0.0042743534, 0.0042730356, 0.004271369, 0.0042700348, 0.0042682309, 0.0042667696, 0.0042649778, 0.0042636613, 0.0042620013, 0.0042606737, 0.0042590001, 0.0042576571, 0.0042559714, 0.0042546238, 0.0042528026, 0.0042513297, 0.0042495267, 0.0042482018, 0.0042465315, 0.0042451993, 0.0042435187, 0.0042421785, 0.0042403638, 0.0042388947, 0.0042370912, 0.0042357715, 0.0042341072, 0.0042327782, 0.0042311037, 0.0042297654, 0.0042280802, 0.0042267335, 0.0042249104, 0.0042235749, 0.0042218962, 0.0042205551, 0.004218867, 0.0042175199, 0.0042158216, 0.0042144652, 0.004212637, 0.0042112977, 0.0042096134, 0.0042082705, 0.004206582, 0.0042052367, 0.004203544, 0.0042021964, 0.0042005042, 0.0041992837, 0.0041975728, 0.0041962075, 0.0041944971, 0.0041931355, 0.0041914298, 0.0041900706, 0.0041883676, 0.0041870107, 0.0041851732, 0.0041838246, 0.0041821352, 0.0041807909, 0.0041791, 0.0041777575, 0.0041760663, 0.0041747224, 0.0041730278, 0.0041718143, 0.0041701091, 0.0041687503, 0.0041670455, 0.0041656941, 0.0041639949, 0.0041626468, 0.0041609472, 0.0041597276, 0.0041580163, 0.0041566556, 0.0041549485, 0.0041535953, 0.0041518928, 0.0041505438, 0.004148847, 0.004147632, 0.0041460516, 0.0041448129, 0.0041430872, 0.0041417177, 0.0041399985, 0.0041386378, 0.0041369298, 0.0041355719, 0.0041338634, 0.0041326419, 0.0041310559, 0.0041298149, 0.0041280789, 0.0041267062, 0.004124986, 0.0041236244, 0.0041219145, 0.004120688, 0.0041190996, 0.0041178609, 0.0041161268, 0.0041147522, 0.0041130297, 0.0041116728, 0.0041099656, 0.0041087419, 0.0041071489, 0.0041059046, 0.0041043027, 0.0041030501, 0.0041013053, 0.0040999274, 0.004098196, 0.0040969541, 0.0040953499, 0.0040940992, 0.0040924838, 0.0040912256, 0.0040894751, 0.0040880879, 0.0040863501, 0.0040849815, 0.0040832595, 0.0040820288, 0.0040804311, 0.004079191, 0.0040775845, 0.0040763356, 0.0040745926, 0.0040732166, 0.0040714885, 0.0040702564, 0.0040686578, 0.0040674191, 0.0040658135, 0.0040645623, 0.0040629464, 0.0040616896, 0.0040599369, 0.0040586819, 0.0040570623, 0.004055806, 0.0040541822, 0.0040529175, 0.0040512881, 0.0040500192, 0.0040482553, 0.0040469985, 0.0040453784, 0.0040441169, 0.0040424853, 0.0040412205, 0.0040395916, 0.0040383227, 0.0040366892, 0.0040354216, 0.0040336582, 0.004032399, 0.0040307743, 0.0040295133, 0.0040278854, 0.0040266239, 0.0040249941, 0.0040237266, 0.0040220963, 0.0040209582, 0.004019307, 0.0040180259, 0.0040163826, 0.0040151076, 0.0040134653, 0.0040121879, 0.0040105446, 0.0040093991, 0.0040077521, 0.0040064747, 0.0040048263, 0.0040035485, 0.0040019043, 0.004000633, 0.0039989902, 0.0039977184, 0.0039960789, 0.0039949403, 0.0039932923, 0.0039920146, 0.0039903671, 0.0039890935, 0.0039874488, 0.0039861756, 0.003984536, 0.003983397, 0.0039818794, 0.0039807237, 0.0039790589, 0.0039777705, 0.0039761108, 0.0039748265, 0.0039731748, 0.0039720256, 0.0039704903, 0.003969322, 0.0039676474, 0.0039663506, 0.0039646877, 0.0039634053, 0.0039617522, 0.0039604777, 0.0039588311, 0.0039576846, 0.0039561596, 0.0039550071, 0.0039533391, 0.0039520492, 0.003950391, 0.0039491118, 0.0039474582, 0.0039463141, 0.0039447895, 0.0039436291, 0.0039420826, 0.0039409045, 0.0039392211, 0.0039379229, 0.0039362549, 0.003935094, 0.0039335471, 0.0039323741, 0.0039308215, 0.0039296425, 0.0039280825, 0.0039268946, 0.0039251982, 0.0039238925, 0.0039222124, 0.0039210422, 0.0039194906, 0.0039183134, 0.003916753, 0.003915566, 0.0039138747, 0.0039125732, 0.0039108978, 0.0039097331, 0.003908183, 0.0039070053, 0.0039054407, 0.0039042609, 0.0039026958, 0.0039015082, 0.0038998171, 0.0038985168, 0.0038968427, 0.0038956858, 0.0038941377, 0.0038929696, 0.0038914194, 0.0038902478, 0.0038886897, 0.0038875097, 0.0038858198, 0.0038846463, 0.0038830838, 0.0038819055, 0.0038803427, 0.0038791629, 0.0038775993, 0.0038764169, 0.0038748449, 0.0038737811, 0.0038721953, 0.0038709946, 0.0038694085, 0.0038682083, 0.0038666227, 0.0038654238, 0.0038638383, 0.0038626408, 0.0038610564, 0.0038599875, 0.0038583938, 0.003857187, 0.0038555963, 0.0038543954, 0.0038528107, 0.0038516112, 0.0038500212, 0.0038489464, 0.0038473473, 0.0038461399, 0.0038445478, 0.0038433464, 0.0038417571, 0.0038405587, 0.0038389738, 0.0038377782, 0.0038361952, 0.0038351303, 0.0038335405, 0.0038323421, 0.0038307519, 0.003829553, 0.0038279712, 0.0038267802, 0.0038251968, 0.0038241346, 0.0038226747, 0.0038215946, 0.0038199839, 0.0038187648, 0.0038171608, 0.0038159562, 0.0038143604, 0.0038131613, 0.0038115778, 0.0038105103, 0.0038090409, 0.0038079591, 0.0038063505, 0.0038051361, 0.003803537, 0.0038023377, 0.0038007456, 0.0037995528, 0.0037979712, 0.003796905, 0.0037954343, 0.0037943511, 0.0037927432, 0.0037915374, 0.0037899411, 0.0037887408, 0.003787152, 0.0037860915, 0.0037846218, 0.003783538, 0.00378205, 0.0037809541, 0.0037793352, 0.0037781191, 0.0037765133, 0.0037753084, 0.0037737135, 0.0037726436, 0.0037711665, 0.0037700823, 0.0037685914, 0.003767495, 0.0037658773, 0.0037646645, 0.0037630573, 0.003761976, 0.0037604936, 0.0037594058, 0.0037579127, 0.0037568153, 0.0037553101, 0.0037542023, 0.0037525699, 0.0037513445, 0.0037497294, 0.0037486444, 0.0037471538, 0.0037460634, 0.003744571, 0.0037434737, 0.0037419691, 0.0037408653, 0.0037392303, 0.0037380059, 0.0037363926, 0.0037353088, 0.0037338203, 0.0037327318, 0.0037312359, 0.003730139, 0.0037286356, 0.0037275311, 0.0037259001, 0.0037248055, 0.0037233038, 0.0037222032, 0.0037206989, 0.0037195936, 0.0037180833, 0.0037169771, 0.0037154632, 0.0037143554, 0.0037127207, 0.0037116227, 0.0037101172, 0.003709014, 0.0037075083, 0.0037064059, 0.0037048969, 0.0037037937, 0.0037022824, 0.0037011756, 0.0036995395, 0.0036984433, 0.0036969387, 0.0036958419, 0.0036943362, 0.0036932358, 0.0036917294, 0.0036906295, 0.0036891189, 0.0036880155, 0.0036865044, 0.0036855221, 0.0036840006, 0.0036828881, 0.0036813691, 0.0036802595, 0.0036787414, 0.0036776306, 0.0036761113, 0.0036751239, 0.0036737167, 0.0036727102, 0.0036711628, 0.0036700293, 0.0036684899, 0.0036673627, 0.0036658316, 0.0036647115, 0.0036631809, 0.0036621862, 0.0036607734, 0.0036597608, 0.0036582088, 0.0036570723, 0.003655528, 0.0036544011, 0.0036528616, 0.0036517365, 0.003650208, 0.0036492187, 0.0036478071, 0.0036467996, 0.0036452473, 0.0036441106, 0.0036425656, 0.0036414387, 0.0036399048, 0.0036387888, 0.003637264, 0.0036362787, 0.0036348668, 0.0036338603, 0.0036324356, 0.0036314169, 0.0036298533, 0.0036287126, 0.0036271622, 0.0036260334, 0.0036244981, 0.0036234993, 0.0036220755, 0.0036210648, 0.0036196313, 0.0036186094, 0.0036170506, 0.0036159153, 0.0036143649, 0.0036132406, 0.0036117092, 0.0036107157, 0.0036092962, 0.0036082913, 0.0036068589, 0.0036058372, 0.0036042747, 0.0036031359, 0.0036015874, 0.0036004647, 0.0035989329, 0.0035979424, 0.0035965233, 0.003595517, 0.0035940874, 0.0035930723, 0.0035916339, 0.0035906129, 0.0035890483, 0.0035879128, 0.003586364, 0.0035853609, 0.0035839353, 0.0035829255, 0.0035814869, 0.0035804678, 0.0035790261, 0.0035780042, 0.0035764368, 0.003575298, 0.0035737476, 0.003572748, 0.0035713231, 0.0035703152, 0.0035688835, 0.0035678693, 0.0035664262, 0.0035654034, 0.0035639526, 0.0035629221, 0.0035613503, 0.003560333, 0.0035588883, 0.0035578669, 0.003556418, 0.0035553912, 0.0035539372, 0.0035529074, 0.0035514575, 0.0035504301, 0.0035488524, 0.0035478296, 0.0035463846, 0.0035453644, 0.0035439145, 0.0035428915, 0.00354144, 0.0035404142, 0.0035389604, 0.0035379303, 0.0035364768, 0.0035355669, 0.003534097, 0.0035330576, 0.0035315915, 0.0035305554, 0.0035290951, 0.0035280581, 0.0035265947, 0.0035255621, 0.0035240981, 0.0035230671, 0.0035216105, 0.0035207001, 0.003519234, 0.0035181984, 0.0035167318, 0.0035156964, 0.0035142333, 0.003513203, 0.0035117452, 0.0035107166, 0.0035092556, 0.0035083452, 0.0035068789, 0.0035058442, 0.003504382, 0.0035033503, 0.0035018919, 0.0035008641, 0.0034994045, 0.0034983782, 0.0034969228, 0.0034960201, 0.0034946739, 0.0034937514, 0.0034922692, 0.0034912222, 0.0034897462, 0.003488705, 0.0034872352, 0.003486203, 0.0034847402, 0.0034838289, 0.0034824773, 0.0034815527, 0.0034801855, 0.0034792458, 0.0034777478, 0.0034766882, 0.003475196, 0.0034741485, 0.0034726763, 0.0034716383, 0.003470168, 0.0034692555, 0.0034679004, 0.0034669703, 0.0034655966, 0.0034646513, 0.0034631477, 0.003462089, 0.0034606033, 0.0034595612, 0.0034580871, 0.0034571688, 0.0034558049, 0.0034548733, 0.0034535006, 0.0034525602, 0.0034511765, 0.0034502258, 0.0034487161, 0.0034476507, 0.0034461578, 0.0034451105, 0.0034436302, 0.0034427117, 0.0034413489, 0.0034404162, 0.0034390388, 0.003438096, 0.0034367086, 0.0034357591, 0.0034342536, 0.0034331945, 0.0034317006, 0.0034307728, 0.0034294017, 0.0034284624, 0.0034270792, 0.0034261358, 0.0034247492, 0.0034237991, 0.0034224065, 0.0034214524, 0.0034199364, 0.0034188712, 0.0034173722, 0.0034164407, 0.0034150656, 0.0034141247, 0.0034127391, 0.0034117943, 0.0034104066, 0.0034094576, 0.0034080634, 0.0034071128, 0.0034056022, 0.003404543, 0.0034030485, 0.0034021228, 0.0034007498, 0.0033998191, 0.0033984408, 0.0033975046, 0.0033961246, 0.0033951828, 0.0033937967, 0.0033928554, 0.0033914649, 0.0033906372, 0.0033892342, 0.0033882759, 0.0033868707, 0.003385907, 0.0033844993, 0.0033835415, 0.003382134, 0.0033811696, 0.0033797643, 0.003378808, 0.0033774045, 0.0033765642, 0.0033751468, 0.0033741791, 0.0033727679, 0.0033718031, 0.0033703938, 0.0033694361, 0.0033680324, 0.003367079, 0.0033656766, 0.0033647206, 0.0033633146, 0.003362474, 0.0033610619, 0.0033600987, 0.003358684, 0.0033577238, 0.0033563166, 0.0033553566, 0.0033539508, 0.003352995, 0.0033515904, 0.0033506399, 0.0033492427, 0.0033484148, 0.0033471258, 0.003346276, 0.0033448513, 0.0033438813, 0.0033424636, 0.0033414993, 0.003340085, 0.003339126, 0.0033377197, 0.0033367656, 0.0033353604, 0.0033345253, 0.0033332275, 0.0033323728, 0.0033310573, 0.0033301895, 0.0033287485, 0.0033277655, 0.0033263327, 0.0033253604, 0.0033239413, 0.0033229797, 0.0033215655, 0.0033207212, 0.0033194176, 0.0033185612, 0.0033172448, 0.0033163764, 0.0033149314, 0.0033139479, 0.0033125195, 0.0033115512, 0.0033101288, 0.0033091651, 0.0033077544, 0.0033069171, 0.0033056105, 0.0033047521, 0.0033034352, 0.0033025695, 0.0033012456, 0.0033003741, 0.003298925, 0.0032979418, 0.0032965068, 0.0032955371, 0.0032941154, 0.0032931524, 0.0032917417, 0.0032909107, 0.0032896115, 0.0032887596, 0.0032874478, 0.003286588, 0.0032852611, 0.0032843908, 0.0032829444, 0.0032819635, 0.0032805328, 0.0032795682, 0.0032781516, 0.0032773125, 0.0032760089, 0.003275159, 0.0032738445, 0.0032729835, 0.0032716601, 0.0032707909, 0.0032694589, 0.003268586, 0.0032671376, 0.0032661569, 0.0032647217, 0.0032637524, 0.0032623305, 0.0032614947, 0.0032601927, 0.0032593445, 0.003258029, 0.0032571738, 0.0032558537, 0.0032549903, 0.0032536578, 0.0032527875, 0.0032514574, 0.0032505856, 0.0032491335, 0.0032482683, 0.0032469393, 0.003246072, 0.0032447381, 0.0032438629, 0.0032425255, 0.0032416533, 0.003240318, 0.0032394435, 0.003238102, 0.0032372244, 0.0032358828, 0.0032350032, 0.003233545, 0.00323268, 0.0032313436, 0.0032304653, 0.0032291282, 0.003228256, 0.0032269147, 0.0032260404, 0.0032246998, 0.0032238257, 0.0032224865, 0.0032216155, 0.0032202774, 0.0032194061, 0.0032180673, 0.0032173088, 0.0032159588, 0.003215072, 0.0032137216, 0.0032128433, 0.0032114964, 0.0032106144, 0.0032092656, 0.0032083853, 0.0032070384, 0.0032061588, 0.003204813, 0.0032039392, 0.003202599, 0.0032018381, 0.0032005941, 0.0031998109, 0.0031984407, 0.0031975447, 0.0031961799, 0.003195287, 0.0031939284, 0.0031930376, 0.0031916809, 0.0031907982, 0.0031894485, 0.0031885726, 0.0031872282, 0.0031864673, 0.0031852259, 0.0031844475, 0.0031831919, 0.0031823996, 0.0031810121, 0.0031801034, 0.0031787299, 0.0031778312, 0.0031764654, 0.0031755769, 0.0031742193, 0.0031733362, 0.0031719857, 0.0031712246, 0.0031699815, 0.0031692004, 0.0031679373, 0.0031671426, 0.0031658718, 0.0031650683, 0.0031636739, 0.0031627608, 0.0031613789, 0.0031604741, 0.0031591046, 0.0031582152, 0.0031568545, 0.003155973, 0.0031546205, 0.0031538564, 0.0031526105, 0.0031518328, 0.003150573, 0.0031497849, 0.0031485134, 0.0031477129, 0.0031463231, 0.0031454167, 0.0031440409, 0.0031431452, 0.0031417804, 0.0031408966, 0.0031395426, 0.0031387797, 0.0031375333, 0.0031367585, 0.0031355005, 0.0031347128, 0.0031334432, 0.0031326469, 0.0031313682, 0.0031305631, 0.0031292785, 0.0031284678, 0.0031270657, 0.0031261547, 0.0031247712, 0.0031238706, 0.0031225034, 0.0031217346, 0.0031204817, 0.0031197018, 0.0031184352, 0.0031176468, 0.0031163751, 0.0031155788, 0.0031142992, 0.0031134957, 0.0031122097, 0.0031114023, 0.0031101117, 0.003109301, 0.0031079003, 0.0031069915, 0.0031056073, 0.0031048215, 0.0031035533, 0.0031027643, 0.0031014909, 0.0031006946, 0.0030994127, 0.0030986099, 0.0030973251, 0.0030965228, 0.0030952389, 0.0030944347, 0.0030931435, 0.0030923362, 0.003091048, 0.0030902389, 0.0030888338, 0.0030879257, 0.0030865448, 0.0030857667, 0.0030845045, 0.0030837199, 0.00308245, 0.0030816649, 0.0030803964, 0.0030796034, 0.0030783226, 0.0030775273, 0.0030762437, 0.0030754446, 0.0030741596, 0.0030733612, 0.0030720788, 0.0030712774, 0.003069994, 0.0030693104, 0.0030680166, 0.003067205, 0.0030659086, 0.0030651004, 0.0030638059, 0.0030629979, 0.0030617062, 0.0030609004, 0.003059611, 0.0030588103, 0.0030575204, 0.0030567183, 0.0030554328, 0.0030546347, 0.0030533476, 0.0030525497, 0.0030512651, 0.0030505783, 0.0030493913, 0.003048684, 0.0030473706, 0.0030465468, 0.0030452388, 0.003044422, 0.0030431177, 0.0030423019, 0.0030410027, 0.0030401957, 0.0030389035, 0.0030381025, 0.0030368108, 0.0030360101, 0.0030347221, 0.0030339241, 0.0030326382, 0.0030319539, 0.0030307712, 0.0030300682, 0.003028865, 0.0030281467, 0.0030268242, 0.0030259979, 0.0030246808, 0.0030238577, 0.0030225513, 0.0030217394, 0.0030204391, 0.0030196325, 0.0030183373, 0.0030175387, 0.0030162483, 0.0030154523, 0.0030141685, 0.0030133787, 0.0030120986, 0.0030114199, 0.0030102376, 0.0030095407, 0.0030083451, 0.0030076376, 0.0030064301, 0.0030057104, 0.0030044899, 0.0030037581, 0.0030024198, 0.0030015835, 0.0030002589, 0.0029994342, 0.0029981192, 0.0029973034, 0.0029959981, 0.0029951916, 0.0029938959, 0.0029931003, 0.0029918128, 0.002991135, 0.0029899513, 0.0029892516, 0.0029880516, 0.0029873454, 0.0029861389, 0.0029854225, 0.0029842046, 0.002983476, 0.0029822479, 0.002981513, 0.0029801701, 0.0029793347, 0.0029780089, 0.0029771877, 0.0029758764, 0.0029750671, 0.002973767, 0.0029729693, 0.002971678, 0.0029709982, 0.0029698133, 0.0029691199, 0.0029679243, 0.0029672198, 0.0029660105, 0.0029652952, 0.0029640787, 0.002963359, 0.0029621343, 0.002961406, 0.0029601792, 0.0029594481, 0.0029582139, 0.0029574789, 0.0029562416, 0.0029555017, 0.0029541566, 0.002953324, 0.0029519978, 0.0029511773, 0.0029498655, 0.0029491701, 0.0029479708, 0.0029472669, 0.0029460562, 0.0029453423, 0.0029441258, 0.0029434075, 0.0029421865, 0.0029414631, 0.0029402385, 0.0029395181, 0.0029382932, 0.0029375667, 0.0029363378, 0.0029356105, 0.0029343781, 0.0029336461, 0.0029324105, 0.0029316787, 0.0029304428, 0.0029297087, 0.0029284733, 0.002927741, 0.0029263971, 0.0029256763, 0.00292445, 0.0029237261, 0.0029224963, 0.0029217703, 0.0029205419, 0.0029198148, 0.0029185796, 0.0029178516, 0.0029166213, 0.0029158979, 0.0029146697, 0.0029139419, 0.0029127081, 0.0029119807, 0.0029107493, 0.0029100233, 0.0029087889, 0.0029080608, 0.0029068305, 0.0029061083, 0.0029048782, 0.0029041516, 0.0029029213, 0.0029021981, 0.0029009671, 0.0029003515, 0.0028992235, 0.0028985925, 0.0028973334, 0.0028965834, 0.0028953294, 0.0028945857, 0.0028933373, 0.0028925999, 0.0028913578, 0.0028906257, 0.0028893854, 0.0028886541, 0.0028874157, 0.002886689, 0.0028854576, 0.0028847344, 0.0028835016, 0.0028827798, 0.002881553, 0.002880834, 0.0028796066, 0.002878888, 0.0028776606, 0.0028769451, 0.0028757176, 0.0028750005, 0.0028737786, 0.0028731728, 0.0028720465, 0.0028714209, 0.0028702763, 0.0028696349, 0.0028684773, 0.002867827, 0.0028666607, 0.0028660006, 0.0028647184, 0.0028639527, 0.0028626777, 0.0028619205, 0.0028606595, 0.0028599168, 0.0028586648, 0.0028579284, 0.002856683, 0.0028559535, 0.0028547165, 0.0028539933, 0.0028527584, 0.002852038, 0.0028508073, 0.0028500932, 0.0028488683, 0.0028481572, 0.0028469341, 0.0028462263, 0.0028450089, 0.0028444135, 0.0028432943, 0.0028426799, 0.0028415429, 0.0028409171, 0.0028397727, 0.0028391336, 0.0028379732, 0.0028373236, 0.0028361541, 0.0028354947, 0.0028343177, 0.0028336537, 0.002832474, 0.002831809, 0.002830622, 0.0028299482, 0.0028287608, 0.0028280881, 0.0028268923, 0.0028262115, 0.0028249105, 0.0028241368, 0.0028228564, 0.0028221007, 0.0028208331, 0.0028200881, 0.0028188331, 0.0028181006, 0.0028168552, 0.0028161332, 0.0028148973, 0.0028141805, 0.0028129502, 0.0028122424, 0.002811024, 0.0028104323, 0.0028093122, 0.0028087017, 0.0028075667, 0.0028069438, 0.0028058011, 0.0028051729, 0.0028040195, 0.0028033841, 0.0028022251, 0.0028015792, 0.0028004094, 0.0027997582, 0.0027985866, 0.0027979333, 0.0027967587, 0.0027960995, 0.0027949167, 0.0027942576, 0.0027930764, 0.0027924115, 0.002791228, 0.0027905677, 0.0027893824, 0.0027887158, 0.0027875332, 0.0027868699, 0.002785685, 0.0027850217, 0.0027838347, 0.0027831681, 0.0027819818, 0.0027813201, 0.0027801364, 0.0027794722, 0.0027782852, 0.0027776212, 0.0027764328, 0.0027757664, 0.0027745815, 0.0027739208, 0.0027726311, 0.0027718751, 0.0027706055, 0.0027699717, 0.0027688132, 0.002768175, 0.002767008, 0.0027663661, 0.0027651994, 0.0027645538, 0.002763384, 0.0027627386, 0.0027615689, 0.0027609246, 0.0027597544, 0.0027591055, 0.0027579321, 0.0027572818, 0.0027561055, 0.0027554573, 0.0027542843, 0.0027536352, 0.0027524584, 0.0027518077, 0.0027506356, 0.0027499895, 0.0027488156, 0.0027481655, 0.00274699, 0.0027463438, 0.0027451701, 0.0027445238, 0.0027433501, 0.0027427024, 0.0027415296, 0.0027408833, 0.0027397084, 0.00273906, 0.002737886, 0.0027372425, 0.0027360711, 0.0027354266, 0.0027342557, 0.0027336129, 0.0027324436, 0.0027318026, 0.0027306341, 0.0027299919, 0.0027288212, 0.0027281791, 0.002727008, 0.0027263667, 0.0027251998, 0.0027245621, 0.0027233954, 0.0027227579, 0.0027215923, 0.0027209576, 0.0027197951, 0.0027191613, 0.0027179962, 0.0027173604, 0.0027161958, 0.0027155622, 0.0027143995, 0.0027138707, 0.0027128004, 0.0027122537, 0.0027111687, 0.0027106064, 0.0027095056, 0.0027089305, 0.0027078209, 0.0027072362, 0.0027061179, 0.0027055272, 0.0027043996, 0.0027037987, 0.002702662, 0.0027020548, 0.0027009179, 0.0027003111, 0.0026991686, 0.0026985561, 0.0026974108, 0.0026967952, 0.002695645, 0.0026950294, 0.0026938776, 0.0026932573, 0.0026921066, 0.0026914887, 0.0026903339, 0.0026897127, 0.0026885611, 0.0026879425, 0.00268679, 0.0026861706, 0.0026850146, 0.0026843923, 0.0026832391, 0.0026826204, 0.0026814658, 0.0026808451, 0.0026796896, 0.0026790679, 0.0026779098, 0.0026772884, 0.0026761342, 0.0026755158, 0.0026743643, 0.0026737463, 0.002672591, 0.0026719705, 0.0026708175, 0.0026702012, 0.0026690483, 0.0026684313, 0.0026672778, 0.0026666608, 0.0026655085, 0.002664892, 0.0026637379, 0.0026631251, 0.0026619744, 0.0026613574, 0.0026602056, 0.00265959, 0.0026584382, 0.0026578263, 0.0026566805, 0.0026560719, 0.0026549241, 0.0026543131, 0.0026531657, 0.0026525562, 0.0026514074, 0.0026508013, 0.0026496567, 0.0026490502, 0.0026479051, 0.0026472986, 0.0026461533, 0.0026455459, 0.0026444006, 0.0026437973, 0.0026426571, 0.0026420543, 0.0026409118, 0.0026403095, 0.0026391679, 0.0026385675, 0.0026374268, 0.0026368264, 0.0026356876, 0.0026350887, 0.0026339516, 0.0026333525, 0.0026322119, 0.002631614, 0.0026304752, 0.0026298745, 0.0026287336, 0.0026281378, 0.002627003, 0.0026264109, 0.0026252784, 0.0026246856, 0.0026235529, 0.0026229613, 0.0026218286, 0.0026212374, 0.0026201068, 0.002619521, 0.002618389, 0.0026177985, 0.0026166695, 0.0026160819, 0.0026149505, 0.0026143631, 0.0026132343, 0.0026126478, 0.0026115188, 0.0026109337, 0.002609805, 0.0026092178, 0.0026080899, 0.0026075069, 0.0026063803, 0.0026057959, 0.0026046692, 0.002604088, 0.0026029649, 0.0026023888, 0.0026012689, 0.0026006906, 0.0025995653, 0.0025989856, 0.0025978596, 0.0025972778, 0.0025961513, 0.0025955702, 0.0025944479, 0.002593874, 0.0025927578, 0.0025921869, 0.0025910677, 0.0025904942, 0.0025893741, 0.0025888006, 0.002587683, 0.0025871082, 0.0025859866, 0.0025854148, 0.0025842986, 0.0025837282, 0.0025826111, 0.0025820406, 0.0025809256, 0.0025803572, 0.0025793414, 0.0025788648, 0.0025778327, 0.0025773384, 0.0025762902, 0.0025757835, 0.0025747253, 0.0025742101, 0.0025731414, 0.0025726189, 0.0025715437, 0.0025710112, 0.0025699257, 0.0025693872, 0.0025682985, 0.0025677537, 0.0025666594, 0.0025661129, 0.0025650128, 0.0025643592, 0.0025631671, 0.002562532, 0.002561355, 0.0025607352, 0.0025595725, 0.002558965, 0.002557813, 0.0025572153, 0.0025560707, 0.0025554786, 0.0025543391, 0.0025537554, 0.0025526246, 0.002552046, 0.0025509188, 0.0025503438, 0.002549222, 0.0025486548, 0.0025475377, 0.0025469703, 0.0025458559, 0.0025452944, 0.0025441837, 0.0025436252, 0.0025425162, 0.0025419586, 0.0025408494, 0.0025402948, 0.0025391902, 0.0025386356, 0.0025375301, 0.0025369793, 0.0025359781, 0.0025355185, 0.0025344978, 0.0025340212, 0.0025329869, 0.0025325012, 0.0025314572, 0.0025309606, 0.0025299059, 0.0025294018, 0.0025283389, 0.0025278237, 0.0025267559, 0.002526239, 0.0025251633, 0.0025246413, 0.0025235643, 0.0025230371, 0.0025219554, 0.002521426, 0.0025203414, 0.0025198127, 0.0025187267, 0.0025181908, 0.0025170988, 0.002516564, 0.0025154739, 0.0025148375, 0.0025136562, 0.0025130396, 0.002511878, 0.0025112776, 0.0025101292, 0.0025095425, 0.0025084035, 0.0025078231, 0.0025066903, 0.002506119, 0.0025049967, 0.0025044333, 0.0025034188, 0.0025029555, 0.0025019308, 0.0025014568, 0.0025004183, 0.0024999308, 0.0024988838, 0.0024983913, 0.0024973364, 0.0024968334, 0.002495771, 0.0024952653, 0.0024942001, 0.0024936937, 0.0024926253, 0.0024921114, 0.0024910388, 0.0024905219, 0.0024894478, 0.0024889312, 0.0024878548, 0.0024873374, 0.0024862611, 0.0024857407, 0.0024846613, 0.0024841425, 0.0024830645, 0.0024825437, 0.0024814636, 0.0024808445, 0.0024796724, 0.0024790689, 0.0024780147, 0.0024775174, 0.0024764594, 0.0024759599, 0.0024748992, 0.002474396, 0.0024733311, 0.0024728249, 0.0024717574, 0.0024712486, 0.0024701813, 0.0024696742, 0.0024686053, 0.0024680959, 0.0024670255, 0.0024665154, 0.0024654428, 0.0024649315, 0.0024638604, 0.0024633508, 0.0024622795, 0.0024617692, 0.0024606956, 0.0024601838, 0.0024591119, 0.0024586008, 0.0024575286, 0.0024570189, 0.0024559458, 0.0024554352, 0.002454462, 0.002453943, 0.0024528622, 0.0024523442, 0.0024512631, 0.002450746, 0.0024496692, 0.0024491551, 0.0024480775, 0.0024475632, 0.0024464889, 0.0024459807, 0.002444909, 0.0024444014, 0.0024433283, 0.0024428167, 0.0024417439, 0.0024412363, 0.0024401662, 0.002439663, 0.002438596, 0.0024380917, 0.0024370216, 0.0024365166, 0.002435545, 0.0024351308, 0.0024341447, 0.0024337147, 0.0024327128, 0.002432174, 0.0024310737, 0.002430544, 0.002429452, 0.0024289244, 0.0024278336, 0.0024273123, 0.0024262271, 0.0024257093, 0.0024246264, 0.0024241125, 0.0024230357, 0.0024225269, 0.0024214501, 0.0024209425, 0.0024198757, 0.0024193747, 0.0024183046, 0.0024178028, 0.0024168338, 0.0024164242, 0.0024154396, 0.0024150149, 0.0024140161, 0.0024135797, 0.0024125704, 0.0024120251, 0.0024109173, 0.0024103816, 0.0024092831, 0.0024087559, 0.0024076661, 0.0024071471, 0.0024060614, 0.0024055475, 0.0024044679, 0.0024039596, 0.002402887, 0.0024023852, 0.0024013137, 0.0024008136, 0.0023998453, 0.0023994376, 0.0023984523, 0.0023980287, 0.0023970299, 0.0023965954, 0.0023955922, 0.0023951542, 0.0023941391, 0.0023935912, 0.0023924788, 0.0023919428, 0.0023908436, 0.0023903197, 0.0023892326, 0.0023887195, 0.0023876373, 0.0023871306, 0.0023860575, 0.0023855539, 0.002384579, 0.0023841676, 0.0023831772, 0.0023827555, 0.0023817585, 0.002381325, 0.0023803159, 0.0023798761, 0.0023788605, 0.0023784139, 0.0023773948, 0.0023768474, 0.002375735, 0.0023752023, 0.0023741019, 0.0023735806, 0.0023724916, 0.0023719782, 0.0023708984, 0.0023703945, 0.0023694192, 0.0023690108, 0.0023680225, 0.0023676022, 0.0023666054, 0.0023661782, 0.0023651717, 0.002364737, 0.002363727, 0.0023632857, 0.0023622694, 0.002361726, 0.0023606156, 0.0023600876, 0.0023589921, 0.0023584769, 0.0023573916, 0.0023568845, 0.0023559073, 0.0023554966, 0.0023545052, 0.002354084, 0.0023530838, 0.0023526563, 0.0023516496, 0.0023512135, 0.0023502028, 0.0023497657, 0.0023487497, 0.0023483052, 0.0023472868, 0.0023467457, 0.002345637, 0.0023451105, 0.002344016, 0.0023435026, 0.0023425152, 0.0023420989, 0.0023411016, 0.0023406779, 0.0023396763, 0.0023392485, 0.0023382429, 0.0023378104, 0.0023367973, 0.0023363598, 0.0023353437, 0.002334903, 0.002333886, 0.0023333454, 0.0023322371, 0.0023317153, 0.0023307188, 0.002330296, 0.0023292948, 0.0023288669, 0.002327858, 0.0023274249, 0.0023264124, 0.0023259795, 0.0023249669, 0.0023245283, 0.0023235118, 0.0023230745, 0.0023220547, 0.0023216114, 0.0023205909, 0.0023200517, 0.0023190414, 0.0023186079, 0.0023175953, 0.0023171599, 0.0023161406, 0.002315701, 0.002314684, 0.0023142439, 0.0023132246, 0.0023127871, 0.0023117699, 0.0023113315, 0.0023103133, 0.0023098732, 0.0023088523, 0.0023083144, 0.0023073014, 0.0023068697, 0.002305859, 0.0023054257, 0.0023044099, 0.0023039761, 0.0023029631, 0.0023025291, 0.002301513, 0.0023010778, 0.0023000583, 0.0022996175, 0.0022985979, 0.0022981623, 0.0022972415, 0.0022967979, 0.0022957756, 0.0022953337, 0.002294312, 0.0022938717, 0.0022928496, 0.0022924086, 0.0022913856, 0.002290946, 0.0022899245, 0.0022894868, 0.0022884684, 0.0022880333, 0.0022871117, 0.0022867629, 0.0022858214, 0.0022853597, 0.0022843201, 0.0022838658, 0.0022828309, 0.0022823815, 0.0022813494, 0.0022809021, 0.0022798746, 0.0022794311, 0.0022784024, 0.0022779596, 0.0022770327, 0.0022766837, 0.0022757442, 0.0022752846, 0.0022742441, 0.0022737901, 0.0022727549, 0.0022723088, 0.0022712799, 0.0022708336, 0.0022698056, 0.0022693633, 0.002268339, 0.002267902, 0.0022669777, 0.0022666305, 0.002265688, 0.0022652296, 0.0022641928, 0.0022637458, 0.0022627169, 0.0022622729, 0.0022612449, 0.0022608065, 0.0022597844, 0.0022593476, 0.0022584216, 0.0022580756, 0.0022571359, 0.0022567753, 0.0022558253, 0.002255362, 0.002254317, 0.0022538614, 0.0022528234, 0.0022523745, 0.002251344, 0.0022509007, 0.00224987, 0.0022494302, 0.0022485047, 0.0022481584, 0.0022472176, 0.0022468597, 0.0022459105, 0.0022454481, 0.0022444027, 0.0022439477, 0.0022429081, 0.0022424618, 0.0022414324, 0.0022409919, 0.0022400594, 0.0022397102, 0.0022387686, 0.0022384091, 0.002237455, 0.0022370853, 0.0022361253, 0.0022356557, 0.0022346019, 0.0022341416, 0.0022330978, 0.0022326475, 0.0022317092, 0.0022313539, 0.0022304046, 0.0022300407, 0.0022290822, 0.0022287075, 0.002227742, 0.0022272705, 0.0022262139, 0.0022257518, 0.0022247059, 0.0022242554, 0.0022233147, 0.002222959, 0.0022220113, 0.0022216495, 0.0022206926, 0.0022203221, 0.0022193587, 0.0022188872, 0.0022178332, 0.0022173764, 0.0022163345, 0.0022158865, 0.0022149449, 0.0022145906, 0.0022136408, 0.0022132779, 0.0022123219, 0.0022119549, 0.0022109931, 0.0022105249, 0.0022094722, 0.002209018, 0.0022079789, 0.0022075376, 0.0022066028, 0.0022062538, 0.0022053127, 0.0022049593, 0.0022040068, 0.0022036419, 0.002202682, 0.0022022182, 0.0022011695, 0.0022007183, 0.0021997753, 0.0021994214, 0.0021984689, 0.0021981066, 0.0021971504, 0.0021967865, 0.0021958256, 0.0021954535, 0.002194488, 0.0021940195, 0.0021929669, 0.0021925156, 0.0021915704, 0.0021912127, 0.0021902591, 0.0021898989, 0.0021889419, 0.0021885762, 0.0021876164, 0.0021872488, 0.0021862856, 0.0021858204, 0.0021848611, 0.0021844949, 0.0021835302, 0.0021831573, 0.0021821894, 0.0021818148, 0.0021808462, 0.0021804732, 0.0021795055, 0.0021790364, 0.0021779812, 0.0021775295, 0.0021765826, 0.0021762273, 0.0021752741, 0.0021749141, 0.0021739565, 0.0021735912, 0.0021726291, 0.002172261, 0.0021712969, 0.0021708354, 0.0021698778, 0.0021695162, 0.0021685597, 0.0021681963, 0.0021672333, 0.0021668652, 0.0021659008, 0.0021655315, 0.0021645664, 0.0021641043, 0.0021631469, 0.0021627822, 0.0021618209, 0.0021614572, 0.0021604956, 0.0021601301, 0.0021591668, 0.0021588001, 0.0021578341, 0.0021574656, 0.0021565915, 0.0021562139, 0.0021552416, 0.0021548662, 0.0021538949, 0.0021535207, 0.0021525482, 0.0021521742, 0.0021512031, 0.0021508313, 0.0021499551, 0.0021495759, 0.002148598, 0.0021482198, 0.0021472441, 0.0021468645, 0.0021458871, 0.0021455123, 0.0021445388, 0.0021441621, 0.0021432827, 0.0021429015, 0.0021419215, 0.0021415439, 0.0021405683, 0.0021401923, 0.0021392184, 0.0021388452, 0.0021378715, 0.0021374973, 0.0021366177, 0.0021362375, 0.002135261, 0.0021348859, 0.0021339105, 0.0021335369, 0.0021325669, 0.0021321976, 0.0021313184, 0.0021310309, 0.0021301366, 0.002129744, 0.0021287536, 0.0021283661, 0.0021273822, 0.0021270013, 0.0021260225, 0.0021256453, 0.0021247624, 0.0021244735, 0.0021235773, 0.0021231847, 0.002122191, 0.0021218006, 0.0021208129, 0.0021204306, 0.002119449, 0.0021190709, 0.0021181891, 0.0021178103, 0.0021168306, 0.0021164548, 0.0021154794, 0.0021151088, 0.0021141381, 0.0021137712, 0.0021128941, 0.0021126098, 0.002111715, 0.002111326, 0.0021103402, 0.0021099607, 0.0021089816, 0.0021086081, 0.0021076354, 0.0021072668, 0.0021063858, 0.0021060996, 0.0021052053, 0.0021048172, 0.0021038312, 0.0021034505, 0.0021024686, 0.0021020952, 0.0021012144, 0.0021009308, 0.0021000365, 0.0020996477, 0.0020986591, 0.0020982774, 0.0020972961, 0.0020969235, 0.0020960413, 0.0020957554, 0.0020948565, 0.0020945575, 0.002093653, 0.0020932571, 0.0020922602, 0.0020918709, 0.0020908846, 0.0020905081, 0.0020896208, 0.0020893321, 0.002088432, 0.0020880403, 0.0020870471, 0.0020866636, 0.0020856804, 0.0020853062, 0.0020844224, 0.0020841372, 0.0020832422, 0.0020829486, 0.0020820452, 0.002081651, 0.0020806547, 0.0020802701, 0.0020793783, 0.0020790887, 0.0020781851, 0.0020778838, 0.0020769737, 0.0020765748, 0.0020755746, 0.0020751867, 0.0020742901, 0.0020739958, 0.0020730908, 0.0020727874, 0.0020718754, 0.0020714756, 0.0020704768, 0.0020700903, 0.0020690996, 0.0020687205, 0.0020678318, 0.002067545, 0.0020666479, 0.0020663536, 0.0020654474, 0.0020650555, 0.0020640614, 0.0020636802, 0.0020627892, 0.0020625016, 0.002061602, 0.0020613063, 0.0020603992, 0.0020600052, 0.0020590094, 0.0020586289, 0.0020577367, 0.0020574457, 0.0020565444, 0.0020562494, 0.0020553421, 0.0020549484, 0.0020539535, 0.0020535733, 0.0020526797, 0.0020523884, 0.0020514866, 0.0020511912, 0.0020502848, 0.0020498948, 0.0020489006, 0.0020485227, 0.0020476328, 0.0020473474, 0.0020464493, 0.0020461588, 0.0020452542, 0.0020448652, 0.0020438745, 0.0020435008, 0.0020426142, 0.0020423334, 0.0020414377, 0.0020411469, 0.0020402446, 0.0020398593, 0.0020389582, 0.0020386642, 0.0020377587, 0.0020374605, 0.0020365492, 0.0020362481, 0.0020353347, 0.0020349384, 0.0020340292, 0.0020337298, 0.002032819, 0.0020325179, 0.0020316038, 0.0020312993, 0.0020303829, 0.0020299875, 0.0020290788, 0.0020287796, 0.0020278664, 0.0020275626, 0.0020266466, 0.0020263409, 0.002025425, 0.0020250294, 0.0020241204, 0.0020238224, 0.0020229092, 0.002022607, 0.0020216918, 0.0020213875, 0.0020204703, 0.0020200734, 0.0020191632, 0.0020188645, 0.0020179527, 0.0020176515, 0.0020167376, 0.0020164342, 0.0020156058, 0.0020152943, 0.0020143704, 0.0020140591, 0.0020131371, 0.0020128293, 0.0020119068, 0.0020115068, 0.0020105925, 0.0020102917, 0.0020093773, 0.0020090758, 0.0020081589, 0.0020078551, 0.0020069384, 0.0020065466, 0.0020056388, 0.0020053433, 0.0020044334, 0.0020041363, 0.0020032241, 0.0020029254, 0.0020021026, 0.0020017962, 0.0020008741, 0.002000568, 0.0019996497, 0.0019993442, 0.0019984215, 0.0019981144, 0.0019972865, 0.0019969754, 0.0019960487, 0.0019957367, 0.0019948119, 0.0019945062, 0.0019936743, 0.0019933577, 0.0019924287, 0.0019921171, 0.0019911893, 0.001990879, 0.0019899539, 0.0019896447, 0.0019888126, 0.0019884987, 0.0019875704, 0.0019872598, 0.0019863348, 0.0019860251, 0.0019851895, 0.0019848733, 0.0019839427, 0.0019836314, 0.0019827071, 0.0019823972, 0.0019814726, 0.0019811669, 0.0019803357, 0.0019800237, 0.001979097, 0.0019787906, 0.0019778693, 0.0019775641, 0.0019767315, 0.0019764195, 0.0019754921, 0.001975182, 0.0019742574, 0.0019739517, 0.0019730295, 0.0019727275, 0.0019718998, 0.0019715934, 0.0019706707, 0.0019703659, 0.0019694453, 0.0019691442, 0.001968317, 0.0019680103, 0.0019670876, 0.0019667852, 0.0019658667, 0.0019655661, 0.0019647374, 0.0019645195, 0.0019636776, 0.0019633586, 0.0019624238, 0.0019621109, 0.001961184, 0.001960875, 0.0019600384, 0.0019597269, 0.0019587982, 0.0019584915, 0.0019575683, 0.0019572657, 0.0019564384, 0.0019562216, 0.0019553781, 0.0019550589, 0.0019541259, 0.0019538158, 0.0019529777, 0.0019527519, 0.0019518986, 0.0019515718, 0.0019506295, 0.001950311, 0.0019494658, 0.0019492365, 0.001948384, 0.0019480567, 0.0019471134, 0.0019467939, 0.0019458578, 0.0019455455, 0.0019447056, 0.0019444802, 0.0019436275, 0.0019433022, 0.0019423621, 0.0019420455, 0.0019412061, 0.0019409813, 0.0019401262, 0.0019397987, 0.0019388581, 0.0019385434, 0.0019376992, 0.0019374703, 0.0019366173, 0.0019362927, 0.00193535, 0.0019350343, 0.0019341914, 0.0019339644, 0.001933111, 0.0019327867, 0.0019318464, 0.0019315317, 0.0019306872, 0.0019304608, 0.0019296077, 0.0019293708, 0.0019285105, 0.0019281798, 0.0019272324, 0.0019269126, 0.0019260672, 0.0019258376, 0.0019249821, 0.0019246578, 0.0019237159, 0.0019234016, 0.0019225574, 0.0019223302, 0.0019214781, 0.0019211532, 0.0019202117, 0.0019198987, 0.0019190562, 0.0019188323, 0.0019179815, 0.0019176605, 0.0019167239, 0.0019164149, 0.0019155729, 0.0019153499, 0.0019145019, 0.001914185, 0.0019132498, 0.0019129426, 0.0019121026, 0.0019118823, 0.0019110357, 0.0019107205, 0.0019097885, 0.001909484, 0.0019086471, 0.0019084271, 0.001907581, 0.0019073557, 0.001906501, 0.0019061832, 0.001905335, 0.0019051051, 0.0019042486, 0.0019040119, 0.0019031481, 0.00190282, 0.0019019627, 0.0019017271, 0.0019008655, 0.0019006258, 0.0018997609, 0.0018994316, 0.0018985715, 0.0018983319, 0.0018974653, 0.0018972219, 0.0018963536, 0.001896022, 0.0018951604, 0.001894923, 0.0018940575, 0.001893813, 0.0018929429, 0.0018926096, 0.0018917456, 0.0018915071, 0.001890643, 0.0018904017, 0.0018895327, 0.0018892006, 0.0018883387, 0.0018881015, 0.0018872365, 0.0018869956, 0.00188613, 0.001885801, 0.0018849391, 0.0018847007, 0.0018838349, 0.001883594, 0.0018827262, 0.0018823975, 0.001881537, 0.0018812995, 0.0018804368, 0.0018801984, 0.0018794183, 0.0018791693, 0.001878294, 0.001878045, 0.0018771689, 0.001876918, 0.0018761273, 0.0018758695, 0.0018749851, 0.0018747264, 0.0018738429, 0.0018735013, 0.0018726301, 0.001872385, 0.0018715137, 0.0018712671, 0.0018703935, 0.0018700607, 0.0018691963, 0.0018689593, 0.0018680935, 0.0018678555, 0.001866991, 0.0018666657, 0.0018658078, 0.0018655761, 0.0018647138, 0.001864478, 0.0018636152, 0.0018632943, 0.0018624376, 0.0018622067, 0.0018613458, 0.0018611111, 0.0018603337, 0.0018600898, 0.0018592197, 0.0018589782, 0.0018581074, 0.0018578662, 0.001857082, 0.0018568329, 0.0018559565, 0.0018557088, 0.0018548343, 0.0018545885, 0.0018538003, 0.0018535474, 0.0018526689, 0.0018524202, 0.0018515429, 0.0018512098, 0.0018503444, 0.0018501052, 0.0018492365, 0.0018489995, 0.0018482207, 0.001847978, 0.0018471052, 0.0018468603, 0.0018459882, 0.0018457465, 0.0018449611, 0.0018447122, 0.0018438345, 0.0018435875, 0.0018427117, 0.0018424657, 0.0018416798, 0.0018414314, 0.0018405542, 0.0018403068, 0.0018394308, 0.0018391, 0.0018382359, 0.0018380005, 0.0018371349, 0.0018369012, 0.0018361224, 0.0018358807, 0.00183501, 0.0018347693, 0.0018339007, 0.0018336643, 0.0018328844, 0.0018326428, 0.0018317706, 0.0018315302, 0.0018306595, 0.0018304221, 0.0018296383, 0.0018293916, 0.0018285157, 0.0018282742, 0.0018274899, 0.0018272422, 0.0018263642, 0.0018261207, 0.0018252493, 0.0018250103, 0.0018242287, 0.0018239858, 0.0018231096, 0.0018228659, 0.00182208, 0.0018219184, 0.0018211216, 0.0018208647, 0.0018199765, 0.0018197219, 0.0018189253, 0.001818671, 0.0018177868, 0.0018175365, 0.0018166584, 0.0018164145, 0.0018156274, 0.0018153801, 0.0018145022, 0.0018142591, 0.0018134699, 0.0018133078, 0.0018125096, 0.0018122545, 0.0018113694, 0.0018111174, 0.0018103216, 0.0018100686, 0.0018091878, 0.001808941, 0.0018081475, 0.0018079793, 0.0018071744, 0.0018069141, 0.0018060268, 0.0018057764, 0.0018049782, 0.0018047232, 0.0018038386, 0.0018035896, 0.0018027967, 0.0018026326, 0.0018018279, 0.001801567, 0.0018006801, 0.00180043, 0.001799635, 0.0017993827, 0.0017985002, 0.0017982549, 0.0017974639, 0.0017972996, 0.0017964964, 0.0017962379, 0.0017953503, 0.001795101, 0.0017943046, 0.0017941367, 0.0017933302, 0.0017930695, 0.0017922677, 0.0017920926, 0.0017912784, 0.0017910122, 0.0017901178, 0.0017898646, 0.0017890651, 0.0017888949, 0.0017880847, 0.0017878198, 0.0017870096, 0.0017868314, 0.0017860167, 0.0017857497, 0.0017848541, 0.0017845979, 0.0017837951, 0.0017836227, 0.0017828112, 0.0017825479, 0.0017817395, 0.0017815615, 0.0017807463, 0.0017804793, 0.0017795825, 0.0017793267, 0.0017785244, 0.0017783544, 0.0017775464, 0.0017772837, 0.0017764742, 0.0017762968, 0.001775482, 0.001775217, 0.0017743243, 0.0017740717, 0.0017732705, 0.0017731008, 0.0017722931, 0.0017720334, 0.0017712287, 0.0017710569, 0.0017702446, 0.0017699812, 0.0017691742, 0.0017690012, 0.0017681879, 0.0017679221, 0.0017670263, 0.0017667745, 0.001765976, 0.0017658095, 0.0017650052, 0.0017647498, 0.0017639458, 0.0017637762, 0.0017629659, 0.001762705, 0.0017618139, 0.0017615641, 0.0017607664, 0.0017606007, 0.0017597952, 0.0017595402, 0.0017587374, 0.0017585702, 0.0017577623, 0.001757504, 0.0017566988, 0.0017565284, 0.0017557178, 0.0017554568, 0.0017545645, 0.001754317, 0.001753522, 0.00175336, 0.0017525573, 0.0017523051, 0.0017515065, 0.001751344, 0.0017505402, 0.0017502871, 0.0017494853, 0.0017493173, 0.001748509, 0.0017483371, 0.0017475253, 0.0017472649, 0.0017464559, 0.0017462828, 0.0017454711, 0.0017452115, 0.0017444046, 0.0017442353, 0.001743427, 0.0017431703, 0.0017423632, 0.0017421913, 0.001741379, 0.0017412046, 0.0017403921, 0.0017401322, 0.0017393223, 0.0017391503, 0.0017383387, 0.0017380797, 0.0017372727, 0.0017371019, 0.0017362897, 0.0017360308, 0.0017352247, 0.0017350558, 0.0017342466, 0.0017340756, 0.0017333479, 0.001733166, 0.0017323442, 0.0017321606, 0.0017313372, 0.0017310693, 0.0017302519, 0.0017300735, 0.0017292564, 0.0017289949, 0.0017281829, 0.0017280086, 0.0017271953, 0.0017269381, 0.0017261341, 0.0017259669, 0.0017251554, 0.001724983, 0.0017241696, 0.001723911, 0.0017231046, 0.0017229364, 0.0017221265, 0.0017218729, 0.0017210707, 0.0017209048, 0.0017200963, 0.0017198449, 0.0017190428, 0.00171888, 0.0017180766, 0.001717912, 0.0017171889, 0.0017170117, 0.0017161946, 0.0017160187, 0.0017152836, 0.0017150965, 0.0017142716, 0.0017140884, 0.0017132639, 0.0017129984, 0.0017121816, 0.0017120054, 0.00171119, 0.0017109324, 0.0017101254, 0.0017099577, 0.0017091472, 0.0017088946, 0.0017080909, 0.0017079273, 0.001707121, 0.0017069546, 0.0017062291, 0.0017060533, 0.0017052358, 0.0017050598, 0.0017043264, 0.0017041431, 0.0017033195, 0.0017031378, 0.0017023145, 0.0017020523, 0.0017012387, 0.0017010651, 0.0017002502, 0.0016999941, 0.0016991869, 0.0016990225, 0.0016982189, 0.0016979715, 0.00169717, 0.00169701, 0.0016962072, 0.0016960446, 0.0016953205, 0.0016951497, 0.0016943378, 0.0016941673, 0.0016934375, 0.0016932588, 0.0016924406, 0.0016922659, 0.0016915303, 0.0016913475, 0.0016905211, 0.0016903373, 0.0016895967, 0.0016894081, 0.0016885789, 0.0016883948, 0.0016875712, 0.0016873085, 0.0016864936, 0.0016863232, 0.0016855107, 0.0016852568, 0.0016844503, 0.0016842871, 0.0016834827, 0.0016833213, 0.0016825969, 0.0016824261, 0.0016816129, 0.0016814431, 0.0016807129, 0.0016805368, 0.0016797186, 0.0016795429, 0.0016788066, 0.0016786237, 0.0016777987, 0.0016776202, 0.0016768833, 0.0016767015, 0.0016758775, 0.0016756967, 0.0016749563, 0.0016747736, 0.001673949, 0.0016737685, 0.0016730285, 0.0016728423, 0.0016720147, 0.0016718344, 0.0016710944, 0.0016709102, 0.0016700831, 0.0016699017, 0.0016691622, 0.0016689793, 0.0016681548, 0.0016679737, 0.0016672323, 0.0016670485, 0.001666223, 0.0016660445, 0.001665225, 0.0016650509, 0.0016643136, 0.0016641316, 0.0016633084, 0.0016631321, 0.0016623947, 0.0016622134, 0.0016613891, 0.0016612121, 0.0016604745, 0.0016602945, 0.0016594712, 0.0016592937, 0.0016585554, 0.001658374, 0.00165755, 0.0016573716, 0.0016566328, 0.001656453, 0.0016556316, 0.001655457, 0.0016547204, 0.0016545416, 0.0016537198, 0.0016535451, 0.0016528104, 0.001652633, 0.0016518119, 0.0016516378, 0.0016509021, 0.0016507241, 0.0016499014, 0.0016497258, 0.0016489913, 0.001648816, 0.0016479972, 0.0016478254, 0.0016470893, 0.0016469109, 0.0016460925, 0.0016459217, 0.0016451855, 0.001645009, 0.001644192, 0.0016440216, 0.00164329, 0.001643116, 0.0016422998, 0.0016421319, 0.0016413986, 0.0016412251, 0.0016404105, 0.0016402433, 0.001639512, 0.0016393395, 0.0016385235, 0.001638355, 0.0016376234, 0.0016374534, 0.0016366389, 0.0016364707, 0.0016357405, 0.0016355687, 0.0016347525, 0.0016345859, 0.001633857, 0.0016336866, 0.0016328727, 0.0016327078, 0.0016319769, 0.0016318059, 0.0016309922, 0.0016308279, 0.0016300998, 0.0016299317, 0.0016291206, 0.0016289564, 0.0016282287, 0.0016280628, 0.0016272545, 0.0016270946, 0.0016263677, 0.0016262006, 0.0016254709, 0.001625382, 0.001624641, 0.0016244617, 0.0016237202, 0.0016236211, 0.0016228688, 0.0016226806, 0.001621931, 0.0016218245, 0.0016210675, 0.0016208738, 0.0016201179, 0.0016200064, 0.0016192445, 0.0016190457, 0.0016182867, 0.0016181734, 0.0016174105, 0.0016172103, 0.001616447, 0.0016163301, 0.0016155649, 0.0016153636, 0.0016145993, 0.0016144813, 0.0016137157, 0.0016135145, 0.001612752, 0.0016126342, 0.0016118665, 0.0016116643, 0.0016109011, 0.0016107034, 0.0016098636, 0.0016096762, 0.0016089259, 0.0016087409, 0.0016079121, 0.0016077344, 0.0016069944, 0.00160682, 0.0016060006, 0.0016058319, 0.0016050995, 0.0016049304, 0.001604195, 0.0016041034, 0.0016033604, 0.0016031821, 0.001602439, 0.0016023397, 0.0016015894, 0.0016014033, 0.0016006554, 0.0016005522, 0.0015997973, 0.0015996095, 0.0015988578, 0.0015987518, 0.0015979961, 0.0015978073, 0.0015970542, 0.001596946, 0.0015961848, 0.0015959899, 0.0015952354, 0.0015951276, 0.0015943681, 0.0015941748, 0.0015934181, 0.0015932289, 0.0015924772, 0.0015923713, 0.0015916144, 0.001591426, 0.0015906735, 0.0015905683, 0.0015898113, 0.0015896208, 0.0015888673, 0.001588761, 0.0015880032, 0.0015878112, 0.0015870566, 0.00158695, 0.0015861926, 0.0015860028, 0.0015852489, 0.0015851421, 0.0015843848, 0.0015841956, 0.0015834413, 0.0015833355, 0.0015825786, 0.0015823899, 0.0015816368, 0.001581452, 0.0015807027, 0.0015806018, 0.0015798477, 0.0015796612, 0.0015789105, 0.0015788069, 0.0015780521, 0.0015778659, 0.0015771172, 0.0015770149, 0.0015762598, 0.0015760736, 0.0015753247, 0.0015752239, 0.0015744687, 0.0015742831, 0.0015735332, 0.0015734298, 0.0015727548, 0.0015726431, 0.0015718803, 0.001571688, 0.0015709308, 0.001570823, 0.0015700642, 0.0015698734, 0.0015691179, 0.0015690118, 0.0015682547, 0.0015680676, 0.0015673151, 0.0015672104, 0.0015664548, 0.0015662691, 0.001565519, 0.0015654179, 0.0015647429, 0.0015646297, 0.0015638671, 0.0015636779, 0.0015629241, 0.0015628181, 0.0015620582, 0.001561868, 0.001561114, 0.0015610115, 0.0015602569, 0.0015600721, 0.0015593224, 0.0015592218, 0.0015584702, 0.0015582895, 0.0015575429, 0.0015574453, 0.0015567723, 0.0015566626, 0.0015559014, 0.0015557124, 0.0015549578, 0.0015548524, 0.0015540951, 0.0015539103, 0.0015531604, 0.0015530597, 0.0015523056, 0.0015521231, 0.0015513756, 0.0015512782, 0.0015506066, 0.0015504985, 0.0015497403, 0.0015496338, 0.0015489531, 0.0015488367, 0.0015480671, 0.0015478705, 0.0015471105, 0.0015470023, 0.0015462413, 0.0015460547, 0.0015453037, 0.0015452012, 0.0015445229, 0.0015444111, 0.0015436494, 0.0015435381, 0.001542852, 0.0015427327, 0.0015419631, 0.0015417685, 0.0015410078, 0.0015408989, 0.0015402185, 0.0015401023, 0.0015393352, 0.0015392217, 0.0015385352, 0.0015384145, 0.0015376429, 0.0015375245, 0.0015368331, 0.0015367089, 0.0015359333, 0.0015357318, 0.0015349664, 0.0015348541, 0.0015341678, 0.0015340482, 0.0015332773, 0.0015331592, 0.001532471, 0.0015323503, 0.0015315776, 0.0015313805, 0.0015306181, 0.0015305087, 0.0015298262, 0.0015297105, 0.0015289425, 0.0015288291, 0.0015281426, 0.0015280234, 0.0015272538, 0.0015271374, 0.0015264482, 0.0015263271, 0.001525555, 0.0015253589, 0.0015245974, 0.0015244889, 0.0015238051, 0.0015236896, 0.0015229237, 0.0015228123, 0.0015221263, 0.001522008, 0.0015212384, 0.0015210469, 0.0015202897, 0.001520184, 0.0015195025, 0.001519389, 0.0015186238, 0.0015185135, 0.0015178283, 0.001517712, 0.001516945, 0.0015167546, 0.0015159976, 0.0015158931, 0.0015152144, 0.0015151063, 0.0015143451, 0.0015142387, 0.0015135591, 0.001513447, 0.0015126816, 0.0015125707, 0.0015118849, 0.0015117681, 0.0015110773, 0.0015109574, 0.0015101876, 0.0015100733, 0.001509384, 0.0015092648, 0.001508495, 0.0015083806, 0.0015076911, 0.0015075722, 0.001506881, 0.0015067592, 0.001505985, 0.0015058671, 0.0015051762, 0.0015050556, 0.0015042832, 0.0015041661, 0.0015034735, 0.001503352, 0.0015026587, 0.0015025368, 0.0015017646, 0.0015016492, 0.0015009586, 0.0015008374, 0.0015000668, 0.0014998754, 0.0014991153, 0.0014990111, 0.0014983315, 0.0014982222, 0.0014974622, 0.001497359, 0.0014966793, 0.0014965665, 0.0014958795, 0.0014957648, 0.0014949983, 0.0014948883, 0.0014942049, 0.0014940923, 0.0014933263, 0.0014932168, 0.0014925314, 0.0014924174, 0.0014917302, 0.0014916139, 0.0014908463, 0.0014907358, 0.0014900513, 0.0014899382, 0.0014891716, 0.0014890619, 0.0014883776, 0.001488265, 0.0014875778, 0.0014874634, 0.001486696, 0.0014865848, 0.0014858986, 0.0014857829, 0.0014850926, 0.001484976, 0.0014842069, 0.0014840958, 0.0014834111, 0.001483298, 0.0014825342, 0.0014824282, 0.0014817443, 0.0014816325, 0.001480946, 0.0014808333, 0.0014800676, 0.0014799581, 0.0014792752, 0.0014791636, 0.0014784775, 0.0014783655, 0.0014775979, 0.0014774875, 0.001476804, 0.001476693, 0.0014760065, 0.0014759704, 0.0014752755, 0.0014751533, 0.001474456, 0.0014743342, 0.0014735601, 0.0014734445, 0.0014727553, 0.0014726399, 0.0014719466, 0.0014718268, 0.0014710574, 0.0014709466, 0.0014702606, 0.0014701486, 0.0014694608, 0.0014694222, 0.0014687257, 0.0014686043, 0.001467908, 0.0014677865, 0.0014670136, 0.0014669006, 0.0014662121, 0.0014660968, 0.0014654059, 0.0014652904, 0.001464522, 0.0014644118, 0.0014637269, 0.0014636171, 0.0014629308, 0.0014628952, 0.0014621988, 0.0014620771, 0.0014613821, 0.0014612636, 0.0014605705, 0.0014605292, 0.001459828, 0.0014597022, 0.0014590019, 0.0014588782, 0.0014581787, 0.0014581318, 0.0014574252, 0.0014572963, 0.001456593, 0.0014564665, 0.0014556906, 0.0014555752, 0.0014548849, 0.0014547695, 0.0014540773, 0.0014539605, 0.0014531919, 0.0014530817, 0.0014523965, 0.0014522868, 0.0014516007, 0.0014515666, 0.0014508726, 0.0014507566, 0.0014500648, 0.001449949, 0.0014492581, 0.0014492188, 0.0014485207, 0.0014483996, 0.0014477024, 0.0014475808, 0.001446883, 0.0014468387, 0.0014461366, 0.0014460108, 0.0014453119, 0.0014451904, 0.0014444946, 0.0014444521, 0.0014437494, 0.0014436239, 0.0014429234, 0.0014428023, 0.001442105, 0.0014420592, 0.0014413542, 0.0014412287, 0.0014405289, 0.0014404082, 0.0014397127, 0.0014396694, 0.001438967, 0.001438841, 0.0014381408, 0.00143802, 0.0014373228, 0.001437279, 0.0014365769, 0.0014364535, 0.0014357539, 0.0014356331, 0.0014349362, 0.0014348932, 0.0014341919, 0.0014340692, 0.0014333713, 0.0014332528, 0.0014325574, 0.0014325147, 0.0014318126, 0.0014316898, 0.0014309927, 0.0014308738, 0.0014301775, 0.001430136, 0.0014294371, 0.0014293154, 0.0014286189, 0.001428502, 0.001427808, 0.0014277685, 0.0014270705, 0.0014269506, 0.0014262543, 0.0014261369, 0.0014254434, 0.0014254033, 0.0014247021, 0.0014245815, 0.001423887, 0.0014237703, 0.0014230768, 0.0014230375, 0.0014223394, 0.0014222211, 0.0014215269, 0.001421412, 0.0014207208, 0.001420684, 0.0014199876, 0.0014198711, 0.0014191781, 0.0014190635, 0.0014183728, 0.0014183372, 0.0014176412, 0.0014175245, 0.0014168322, 0.0014167187, 0.0014160292, 0.0014159949, 0.0014153009, 0.0014151868, 0.0014144952, 0.0014143836, 0.0014136973, 0.0014136644, 0.0014129715, 0.0014128572, 0.0014121664, 0.0014120556, 0.0014113677, 0.001411335, 0.0014106431, 0.0014105309, 0.001409841, 0.0014097319, 0.0014090446, 0.0014090122, 0.0014083958, 0.0014083517, 0.00140765, 0.0014075292, 0.0014068305, 0.0014067888, 0.0014061652, 0.0014061137, 0.0014054042, 0.0014052768, 0.0014045731, 0.0014045256, 0.001403895, 0.0014038397, 0.0014031265, 0.0014029953, 0.0014022894, 0.0014021643, 0.0014014626, 0.0014014185, 0.0014007163, 0.0014005958, 0.0013998994, 0.001399782, 0.0013990883, 0.0013990526, 0.0013984329, 0.0013983877, 0.0013976829, 0.0013975587, 0.0013968588, 0.0013968174, 0.0013961918, 0.0013961414, 0.0013954316, 0.0013953046, 0.0013946031, 0.0013945578, 0.0013939296, 0.0013938762, 0.0013931644, 0.0013930374, 0.0013923339, 0.0013922115, 0.0013915127, 0.001391471, 0.0013908467, 0.001390798, 0.0013900893, 0.0013899648, 0.0013892635, 0.0013892191, 0.0013885916, 0.0013885391, 0.0013878293, 0.001387702, 0.0013869973, 0.0013869501, 0.0013863181, 0.0013862643, 0.0013855548, 0.0013854284, 0.0013847254, 0.0013846057, 0.0013839096, 0.0013838713, 0.0013832488, 0.0013832006, 0.0013824936, 0.0013823706, 0.0013816732, 0.0013816322, 0.0013810055, 0.001380956, 0.0013802473, 0.0013801227, 0.0013794217, 0.0013793057, 0.0013786125, 0.0013785762, 0.0013779558, 0.0013779104, 0.0013772058, 0.0013770848, 0.0013763866, 0.001376346, 0.0013757214, 0.0013756736, 0.0013749696, 0.0013748489, 0.00137415, 0.0013741088, 0.0013734839, 0.001373437, 0.0013728075, 0.0013727545, 0.0013720423, 0.0013719157, 0.0013712129, 0.0013711685, 0.0013705393, 0.0013704874, 0.0013697795, 0.0013696562, 0.001368957, 0.0013688419, 0.001368147, 0.0013681111, 0.0013674914, 0.0013674479, 0.0013667465, 0.0013666291, 0.0013659344, 0.0013658983, 0.0013652771, 0.0013652317, 0.0013646041, 0.0013645546, 0.0013638452, 0.001363723, 0.001363025, 0.0013629843, 0.0013623611, 0.0013623143, 0.0013616071, 0.0013614857, 0.001360788, 0.0013607492, 0.0013601251, 0.0013600779, 0.0013594474, 0.0013593946, 0.0013586854, 0.0013585627, 0.0013578633, 0.0013578224, 0.0013571949, 0.0013571455, 0.0013565139, 0.0013564624, 0.0013557537, 0.0013556292, 0.0013549286, 0.0013548881, 0.0013542612, 0.0013542135, 0.0013535818, 0.0013535279, 0.0013528188, 0.0013527698, 0.001352136, 0.0013520812, 0.001351441, 0.0013513815, 0.0013506657, 0.0013505375, 0.0013498343, 0.0013497907, 0.0013491635, 0.0013491141, 0.0013484799, 0.0013484258, 0.0013477128, 0.0013475881, 0.001346888, 0.0013468465, 0.0013462187, 0.0013461687, 0.0013455362, 0.0013454841, 0.0013447742, 0.0013446523, 0.0013439534, 0.0013439144, 0.0013432903, 0.0013432442, 0.0013426151, 0.0013425671, 0.0013418604, 0.0013417398, 0.0013410428, 0.0013410052, 0.001340384, 0.0013403418, 0.0013397139, 0.0013396646, 0.0013389583, 0.0013388398, 0.0013381438, 0.0013381081, 0.0013374876, 0.0013374459, 0.0013368182, 0.0013367698, 0.0013360648, 0.0013359488, 0.0013352556, 0.0013352202, 0.0013345998, 0.0013345581, 0.0013339319, 0.0013338849, 0.0013331805, 0.0013330643, 0.0013323702, 0.0013323367, 0.0013317189, 0.0013316792, 0.0013310543, 0.0013310097, 0.0013303073, 0.0013301919, 0.0013294982, 0.0013294657, 0.0013288484, 0.0013288099, 0.0013281866, 0.0013281424, 0.0013274412, 0.0013273279, 0.0013266366, 0.001326604, 0.0013259858, 0.0013259485, 0.0013253281, 0.0013252877, 0.0013246607, 0.0013246138, 0.00132391, 0.0013238677, 0.0013232426, 0.0013231968, 0.0013225651, 0.0013225141, 0.0013218797, 0.0013218272, 0.0013211183, 0.0013210709, 0.0013204406, 0.0013203913, 0.0013197568, 0.0013197038, 0.0013190678, 0.0013190131, 0.0013183029, 0.0013182547, 0.001317621, 0.001317571, 0.0013169361, 0.001316883, 0.0013162481, 0.0013161937, 0.001315554, 0.0013154978, 0.001314785, 0.0013147328, 0.0013140978, 0.0013140441, 0.0013134062, 0.0013133521, 0.0013127156, 0.0013126603, 0.0013119493, 0.0013119, 0.0013112667, 0.0013112159, 0.0013105804, 0.0013105264, 0.0013098891, 0.0013098352, 0.0013091264, 0.00130908, 0.001308448, 0.0013083973, 0.0013077619, 0.0013077108, 0.0013070753, 0.0013070219, 0.0013063855, 0.0013063324, 0.0013056232, 0.001305575, 0.0013049428, 0.0013048938, 0.0013042606, 0.0013042081, 0.0013035721, 0.0013035198, 0.0013028833, 0.0013029024, 0.001302258, 0.0013021984, 0.001301554, 0.0013014929, 0.0013008504, 0.0013007909, 0.0013001494, 0.0013000927, 0.0012993776, 0.0012993242, 0.0012986878, 0.0012986352, 0.0012979994, 0.001297948, 0.0012973127, 0.0012972597, 0.0012966233, 0.0012965708, 0.0012958623, 0.0012958164, 0.0012951873, 0.0012951393, 0.001294506, 0.001294457, 0.0012938231, 0.0012937719, 0.0012931379, 0.0012931593, 0.001292518, 0.0012924613, 0.0012918201, 0.001291762, 0.0012911202, 0.0012910637, 0.0012904255, 0.0012903718, 0.0012897348, 0.0012897536, 0.0012891083, 0.0012890479, 0.0012884064, 0.0012883487, 0.0012877054, 0.0012876465, 0.0012870057, 0.0012869507, 0.0012863112, 0.0012863275, 0.0012856828, 0.0012856229, 0.0012849792, 0.0012849199, 0.0012842787, 0.0012842226, 0.0012835816, 0.001283525, 0.001282887, 0.0012829048, 0.0012822606, 0.0012822011, 0.0012815569, 0.0012814972, 0.0012808556, 0.0012807996, 0.0012801603, 0.0012801051, 0.0012794656, 0.0012794832, 0.0012788386, 0.0012787795, 0.0012781372, 0.001278081, 0.0012774415, 0.0012773859, 0.0012767466, 0.0012766931, 0.001276057, 0.0012760763, 0.0012754331, 0.0012753747, 0.0012747329, 0.0012746768, 0.0012740368, 0.0012739826, 0.001273345, 0.0012732926, 0.0012726586, 0.0012726797, 0.0012720373, 0.001271982, 0.001271343, 0.001271288, 0.0012706495, 0.0012705969, 0.0012699609, 0.0012699089, 0.0012692752, 0.0012692983, 0.0012687305, 0.0012687404, 0.0012680897, 0.0012680258, 0.0012673774, 0.0012673159, 0.0012666733, 0.001266616, 0.0012659739, 0.0012659164, 0.001265277, 0.0012652943, 0.0012646514, 0.0012645955, 0.0012639555, 0.0012639009, 0.0012632632, 0.001263211, 0.0012625755, 0.001262525, 0.0012618897, 0.0012619101, 0.0012613414, 0.0012613514, 0.0012607016, 0.0012606394, 0.0012599931, 0.001259933, 0.0012592912, 0.0012592349, 0.0012585964, 0.0012585454, 0.0012579098, 0.00125793, 0.0012572892, 0.0012572345, 0.0012565961, 0.0012565436, 0.0012559082, 0.0012558593, 0.0012552273, 0.0012551806, 0.0012545511, 0.0012545057, 0.0012538738, 0.0012538999, 0.0012532647, 0.0012532148, 0.0012525811, 0.0012525339, 0.0012519032, 0.0012518576, 0.0012512304, 0.0012511887, 0.0012505605, 0.0012505885, 0.001250027, 0.0012500451, 0.0012494022, 0.0012493451, 0.001248705, 0.0012486515, 0.001248016, 0.0012479665, 0.0012473323, 0.0012472849, 0.0012466549, 0.0012466798, 0.0012461159, 0.0012461311, 0.0012455565, 0.0012455626, 0.0012449084, 0.0012448428, 0.0012441946, 0.0012441333, 0.00124349, 0.0012434344, 0.0012427957, 0.0012427445, 0.00124211, 0.0012421322, 0.0012415637, 0.0012415752, 0.0012409263, 0.0012408663, 0.0012402236, 0.001240168, 0.0012395299, 0.0012394782, 0.0012388435, 0.0012387956, 0.0012381639, 0.0012381888, 0.001237624, 0.0012376376, 0.0012369904, 0.0012369318, 0.0012362904, 0.0012362367, 0.0012356004, 0.0012355512, 0.0012349199, 0.0012348738, 0.001234245, 0.0012342735, 0.0012337114, 0.0012337278, 0.001233154, 0.0012331619, 0.001232511, 0.0012324482, 0.0012318038, 0.0012317476, 0.0012311089, 0.0012310573, 0.0012304224, 0.0012303754, 0.0012297438, 0.001229769, 0.0012292054, 0.0012292218, 0.001228648, 0.0012286549, 0.0012280031, 0.0012279394, 0.0012272941, 0.0012272376, 0.001226598, 0.0012265464, 0.0012259121, 0.0012258644, 0.0012252328, 0.0012252587, 0.0012246947, 0.0012247098, 0.0012241357, 0.0012241454, 0.001223495, 0.0012234325, 0.0012227892, 0.0012227342, 0.0012220965, 0.0012220464, 0.0012214142, 0.0012213689, 0.0012207396, 0.0012207677, 0.0012202042, 0.0012202221, 0.0012196507, 0.001219659, 0.0012190104, 0.0012189521, 0.0012183102, 0.0012182556, 0.0012176194, 0.0012175707, 0.0012169399, 0.0012168956, 0.0012162676, 0.0012162972, 0.0012157355, 0.0012157547, 0.0012151859, 0.0012151983, 0.0012146212, 0.0012146254, 0.0012139712, 0.0012139066, 0.001213261, 0.0012132055, 0.0012125666, 0.0012125158, 0.0012118834, 0.0012118377, 0.0012112091, 0.0012112376, 0.0012106765, 0.0012106959, 0.0012101247, 0.0012101359, 0.0012095589, 0.0012095644, 0.0012089113, 0.0012088475, 0.0012082026, 0.0012081469, 0.0012075107, 0.0012074625, 0.0012068299, 0.0012067851, 0.0012061581, 0.0012061881, 0.0012056273, 0.0012056468, 0.0012050767, 0.0012050896, 0.0012045137, 0.0012045194, 0.001203867, 0.001203805, 0.0012031627, 0.0012031097, 0.0012024739, 0.0012024256, 0.001201796, 0.0012017536, 0.0012011289, 0.001201161, 0.0012006027, 0.001200626, 0.0012000576, 0.0012000699, 0.0011994955, 0.0011995038, 0.0011989243, 0.0011989283, 0.001198274, 0.0011982092, 0.0011975651, 0.0011975112, 0.0011968742, 0.0011968247, 0.0011961935, 0.0011961508, 0.001195526, 0.0011955566, 0.0011949964, 0.0011950196, 0.0011944545, 0.00119447, 0.0011938963, 0.0011939051, 0.0011933254, 0.0011933285, 0.001192677, 0.0011926164, 0.0011919743, 0.0011919206, 0.0011912845, 0.0011912377, 0.0011906091, 0.001190568, 0.0011899433, 0.0011899757, 0.0011894178, 0.0011894412, 0.0011888759, 0.0011888933, 0.0011883231, 0.0011883347, 0.001187759, 0.0011877677, 0.0011871887, 0.0011871923, 0.001186538, 0.0011864741, 0.0011858303, 0.0011857762, 0.00118514, 0.0011850918, 0.0011844622, 0.0011844898, 0.0011839281, 0.0011839499, 0.0011833842, 0.001183399, 0.0011828239, 0.0011828322, 0.0011822536, 0.0011822578, 0.0011816752, 0.0011816776, 0.0011810921, 0.0011810904, 0.0011804329, 0.0011803671, 0.0011797206, 0.0011796656, 0.00117903, 0.001178982, 0.0011783506, 0.0011783082, 0.0011776842, 0.001177717, 0.0011771604, 0.0011771859, 0.0011766232, 0.0011766423, 0.001176073, 0.0011760878, 0.0011755135, 0.0011755221, 0.0011749426, 0.0011749469, 0.0011743652, 0.0011743681, 0.0011737148, 0.0011736529, 0.0011730109, 0.0011729578, 0.0011723235, 0.0011722783, 0.0011716514, 0.0011716135, 0.0011709938, 0.00117103, 0.0011704757, 0.0011705036, 0.0011699426, 0.0011699625, 0.0011693932, 0.0011694073, 0.0011688345, 0.001168846, 0.0011682701, 0.0011682776, 0.0011676982, 0.0011677028, 0.0011671201, 0.0011671232, 0.0011664703, 0.0011664078, 0.0011657659, 0.0011657157, 0.0011650835, 0.0011650393, 0.0011644145, 0.0011643788, 0.0011637607, 0.0011637978, 0.001163246, 0.0011632757, 0.001162717, 0.0011627406, 0.0011621746, 0.0011621916, 0.001161622, 0.0011616366, 0.0011610634, 0.0011610738, 0.0011604964, 0.0011605029, 0.0011599228, 0.0011599273, 0.0011593456, 0.0011593486, 0.0011586978, 0.0011586371, 0.0011579964, 0.001157946, 0.0011573142, 0.0011572713, 0.0011566487, 0.0011566152, 0.0011559983, 0.0011560371, 0.0011554869, 0.0011555183, 0.0011549613, 0.0011549866, 0.0011544228, 0.0011544424, 0.001153876, 0.0011538934, 0.0011533236, 0.0011533347, 0.0011527594, 0.0011527698, 0.0011521931, 0.001152201, 0.0011516229, 0.0011516289, 0.0011510493, 0.0011510538, 0.0011504715, 0.0011504735, 0.0011498885, 0.0011498891, 0.0011492366, 0.0011491762, 0.0011485358, 0.0011484852, 0.0011478553, 0.0011478149, 0.0011471923, 0.0011472256, 0.0011466712, 0.0011466998, 0.0011461403, 0.001146163, 0.0011455985, 0.0011456175, 0.0011450504, 0.0011450667, 0.0011444943, 0.0011445058, 0.0011439329, 0.0011439441, 0.0011433681, 0.0011433761, 0.0011427986, 0.0011428061, 0.0011422276, 0.0011422344, 0.0011416535, 0.0011416574, 0.0011410769, 0.001141081, 0.0011404989, 0.0011405022, 0.0011399215, 0.0011399252, 0.0011393422, 0.0011393455, 0.001138694, 0.0011386331, 0.0011379939, 0.0011379464, 0.0011373202, 0.001137282, 0.0011366602, 0.0011366956, 0.0011361438, 0.0011361737, 0.001135616, 0.0011356416, 0.0011350798, 0.0011351013, 0.0011345366, 0.0011345552, 0.0011339861, 0.0011340006, 0.0011334306, 0.0011334441, 0.0011328711, 0.0011328831, 0.0011323077, 0.0011323177, 0.0011317424, 0.0011317517, 0.0011311756, 0.001131183, 0.0011306052, 0.0011306137, 0.0011300364, 0.0011300439, 0.0011294649, 0.00112947, 0.0011288908, 0.0011288968, 0.0011283174, 0.0011283236, 0.0011277443, 0.0011277491, 0.0011271699, 0.0011271762, 0.0011265978, 0.0011266037, 0.0011260229, 0.0011260273, 0.0011254473, 0.0011254529, 0.0011248068, 0.0011247521, 0.0011241183, 0.0011240754, 0.0011234534, 0.0011234193, 0.001122804, 0.0011228442, 0.0011222968, 0.0011223324, 0.0011217804, 0.0011218105, 0.0011212534, 0.0011212791, 0.0011207178, 0.001120741, 0.0011201784, 0.0011201998, 0.0011196359, 0.0011196547, 0.0011190879, 0.0011191054, 0.001118538, 0.0011185549, 0.0011179836, 0.001117997, 0.0011174259, 0.0011174388, 0.001116868, 0.0011168822, 0.0011163095, 0.0011163206, 0.0011157466, 0.0011157586, 0.0011151845, 0.0011151944, 0.0011146212, 0.0011146332, 0.0011140584, 0.0011140674, 0.0011134922, 0.0011135031, 0.0011129299, 0.0011129411, 0.001112366, 0.001112376, 0.0011118028, 0.0011118142, 0.0011112404, 0.0011112506, 0.0011106759, 0.0011106859, 0.0011101105, 0.0011101213, 0.0011095474, 0.0011095578, 0.0011089852, 0.0011089968, 0.0011084232, 0.0011084336, 0.0011078597, 0.0011078719, 0.0011072988, 0.0011073092, 0.0011067351, 0.0011067463, 0.0011061728, 0.0011061842, 0.0011056113, 0.0011056227, 0.00110505, 0.0011050622, 0.0011044893, 0.001104502, 0.0011039311, 0.0011039439, 0.001103372, 0.0011033836, 0.0011028105, 0.0011028218, 0.0011022501, 0.0011022635, 0.0011016921, 0.0011017057, 0.001101134, 0.0011011467, 0.0011005753, 0.0011005892, 0.0011000196, 0.0011000341, 0.0010994644, 0.0010994794, 0.0010989101, 0.0010989241, 0.0010983549, 0.0010983699, 0.0010977992, 0.0010978135, 0.0010972435, 0.0010972586, 0.0010966883, 0.0010967029, 0.0010961335, 0.0010961476, 0.0010955781, 0.0010955944, 0.0010950257, 0.0010950413, 0.0010944731, 0.0010944888, 0.00109392, 0.001093937, 0.0010933698, 0.0010933855, 0.0010928171, 0.0010928321, 0.0010922636, 0.0010922804, 0.0010917137, 0.0010917305, 0.0010911633, 0.0010911814, 0.0010906145, 0.0010906315, 0.0010900653, 0.0010900841, 0.0010895181, 0.0010895353, 0.0010889691, 0.001088987, 0.00108842, 0.001088438, 0.0010878715, 0.0010878901, 0.0010873243, 0.0010873417, 0.0010867758, 0.0010867947, 0.0010862286, 0.0010862462, 0.0010856814, 0.0010856992, 0.0010851329, 0.0010851528, 0.0010845884, 0.0010846078, 0.0010840445, 0.0010840646, 0.0010835009, 0.0010835204, 0.0010829561, 0.0010829767, 0.0010824123, 0.001082432, 0.0010818697, 0.0010818908, 0.001081327, 0.0010813478, 0.0010807851, 0.0010808059, 0.0010802426, 0.0010802654, 0.0010797037, 0.001079725, 0.001079164, 0.0010791852, 0.0010786221, 0.0010786442, 0.0010780824] + + run2 =[0.22636308, 0.1480656, 0.091585644, 0.054444015, 0.031469688, 0.017834544, 0.0099654403, 0.0055099125, + 0.0030210195, 0.0016444945, 0.00088933978, 0.00047797523, 0.00025531437, 0.00013550936, 7.1445866e-05, + 3.7428672e-05, 1.9464656e-05, 1.0055257e-05, 5.1515703e-06, 2.6183798e-06, 1.319792e-06, 6.592943e-07, + 3.2646994e-07, 1.6009649e-07, 7.7748133e-08, 3.7353889e-08, 1.7769684e-08, 8.359363e-09, 3.8933528e-09, + 1.7812979e-09, 8.1072921e-10, 3.6597647e-10, 1.6102303e-10, 6.9051237e-11, 2.8351214e-11, 1.2824635e-11, + 5.1659588e-12, 2.1440391e-12, 8.3213124e-13, 4.8494271e-13, 2.0675214e-13, 1.5536533e-13, 9.358783e-14, + 8.320858e-14, 7.0565447e-14, 4.302883e-14, 4.1307703e-14, 3.5297445e-14, 3.2385566e-14, 2.5282634e-14, + 2.0100341e-14, 1.5569807e-14, 1.5051255e-14, 1.4095729e-14, 1.2330331e-14, 1.1466963e-14, 1.0634927e-14, + 8.4120231e-15, 4.7793042e-15, 4.7471661e-15, 3.7474317e-15, 3.7189799e-15, 3.6906365e-15, 3.4404246e-15, + 2.5981164e-15, 1.1543063e-15, 1.1543063e-15, 1.1543063e-15, 1.1543063e-15, 1.0312087e-15, 1.0312087e-15, + 9.1505001e-16, 9.1505001e-16, 9.1505001e-16, 9.1505001e-16, 9.0101806e-16, 8.8709454e-16, 8.7327943e-16, + 4.7820463e-16, 4.7820463e-16, 2.0785883e-16, 2.0785883e-16, 2.0785883e-16, 2.0785883e-16, 2.0785883e-16, + 4.8535319e-17, 4.8535319e-17, 4.8535319e-17, 4.8535319e-17, 4.8535319e-17, 4.8535319e-17, 4.8535319e-17, + 4.8535319e-17, 4.8535319e-17, 4.8535319e-17, 4.8535319e-17, 4.8535319e-17, 4.8535319e-17, 4.8535319e-17, + 4.8535319e-17, 4.8535319e-17, 4.8535319e-17, 4.8535319e-17, 4.8535319e-17, 4.8535319e-17, 4.8535319e-17, + 4.8535319e-17, 4.8535319e-17, 4.8535319e-17, 4.8535319e-17, 4.8535319e-17, 4.8535319e-17, 4.8535319e-17, + 4.8535319e-17, 4.8535319e-17, 4.8535319e-17, 4.8535319e-17, 4.8535319e-17, 2.6051676e-17, 2.6051676e-17, + 2.6051676e-17, 2.6051676e-17, 1.0506928e-17, 1.0506928e-17, 1.0506928e-17, 1.9010728e-18, 1.9010728e-18, + 1.9010728e-18, 1.9010728e-18, 1.9010728e-18, 1.9010728e-18, 1.9010728e-18, 1.9010728e-18, 1.9010728e-18, + 1.9010728e-18, 1.9010728e-18, 1.9010728e-18, 1.9010728e-18, 1.9010728e-18, 1.9010728e-18, 1.9010728e-18, + 1.9010728e-18, 1.9010728e-18, 1.9010728e-18, 1.9010728e-18, 1.9010728e-18, 1.9010728e-18, 1.9010728e-18, + 1.9010728e-18, 1.9010728e-18, 1.9010728e-18, 1.9010728e-18, 1.9010728e-18, 1.9010728e-18, 1.9010728e-18, + 1.9010728e-18, 1.9010728e-18, 1.9010728e-18, 1.9010728e-18, 1.9010728e-18, 1.9010728e-18, 1.9010728e-18, + 1.9010728e-18, 1.9010728e-18, 1.9010728e-18, 1.9010728e-18, 5.506045e-18, 1.0506928e-17, 6.6529276e-18, + 9.0517249e-18, 7.9082305e-18, 9.0517249e-18, 7.9082305e-18, 5.1363284e-19, 9.0517249e-18, 7.9082305e-18, + 9.0517249e-18, 7.9082305e-18, 9.0517249e-18, 7.9082305e-18, 5.1363284e-19, 9.0517249e-18, 7.9082305e-18, + 9.0517249e-18, 7.9082305e-18, 9.0517249e-18, 7.9082305e-18, 5.1363284e-19, 9.0517249e-18, 7.9082305e-18, + 9.0517249e-18, 7.9082305e-18, 9.0517249e-18, 7.9082305e-18, 9.0517249e-18, 7.9082305e-18, 9.0517249e-18, + 4.2738225e-17, 1.6397917e-15, 5.3383589e-13, 1.6264022e-10, 5.1782639e-08, 1.748654e-05, 0.0032503817, + 0.0027116593, 0.0028059362, 0.0029082955, 0.0030138281, 0.0031210245, 0.003229579, 0.0033391984, 0.0034498745, + 0.0035612814, 0.0036733851, 0.0037859094, 0.0038991347, 0.0040127616, 0.0041268277, 0.0042410535, 0.0043557934, + 0.0044707065, 0.0045860219, 0.0047012772, 0.0048167538, 0.0049322476, 0.0050480342, 0.0051637432, 0.0052795568, + 0.0053951046, 0.0055108983, 0.0056265192, 0.0057423515, 0.0058579599, 0.0059735756, 0.0060887747, 0.0062041618, + 0.0063192472, 0.0064344951, 0.0065494073, 0.0066643022, 0.0067786649, 0.0068932064, 0.0070073693, 0.0071216919, + 0.0072355992, 0.0073494771, 0.0074627679, 0.0075762649, 0.0076893251, 0.00780256, 0.0079153096, 0.0080280649, + 0.0081401551, 0.0082524791, 0.0083643179, 0.0084763663, 0.0085878745, 0.0086996052, 0.0088107847, 0.0089219958, + 0.0090324562, 0.0091431942, 0.0092533641, 0.0093638003, 0.0094736442, 0.0095837628, 0.0096930619, 0.0098024867, + 0.0099113062, 0.010020433, 0.010128931, 0.010237752, 0.010345909, 0.010454197, 0.010561624, 0.010669427, + 0.010776554, 0.010884079, 0.01099091, 0.011098122, 0.0112046, 0.011311472, 0.011417591, 0.011523889, 0.011629218, + 0.01173501, 0.011840047, 0.011945546, 0.012050272, 0.012155453, 0.012259813, 0.012364437, 0.012468015, 0.01257211, + 0.012675389, 0.012779194, 0.01288215, 0.012985635, 0.013088251, 0.01319141, 0.013293678, 0.013396248, 0.013497682, + 0.013599744, 0.013700888, 0.013802638, 0.013903455, 0.014004895, 0.014105368, 0.014206222, 0.014306115, + 0.014406661, 0.014505964, 0.014605941, 0.014704924, 0.014804599, 0.014903264, 0.015002636, 0.015100957, + 0.015199964, 0.01529789, 0.015396272, 0.015493325, 0.015591171, 0.015687931, 0.015785463, 0.015881885, 0.015979098, + 0.016075153, 0.016172003, 0.0162677, 0.016363926, 0.016458981, 0.016554873, 0.016649326, 0.016744634, 0.016838755, + 0.016933762, 0.017027544, 0.017122203, 0.017215598, 0.017309887, 0.017402908, 0.017496565, 0.017588956, + 0.017682282, 0.017774032, 0.017866753, 0.01795817, 0.018050559, 0.018141612, 0.018233633, 0.018324299, 0.018415963, + 0.018506242, 0.018597262, 0.018686887, 0.018777549, 0.018866528, 0.018956585, 0.019045234, 0.01913495, 0.019223228, + 0.019312583, 0.019400477, 0.019489482, 0.019576984, 0.01966529, 0.019752124, 0.01984009, 0.019926548, 0.020014174, + 0.020099955, 0.020186903, 0.020272311, 0.020358918, 0.020443955, 0.020530192, 0.020614836, 0.020700676, + 0.020784907, 0.020870058, 0.020953598, 0.021038402, 0.021121575, 0.02120601, 0.021288788, 0.021372832, 0.021454887, + 0.021538232, 0.02161991, 0.021702915, 0.021784192, 0.021866808, 0.021947697, 0.022029608, 0.022109788, 0.022191353, + 0.022271182, 0.022352388, 0.022431796, 0.022512587, 0.022591585, 0.022671986, 0.022750255, 0.022829942, + 0.022907812, 0.022987129, 0.0230646, 0.023143239, 0.023220034, 0.023298319, 0.023374727, 0.023452625, 0.023528649, + 0.023606198, 0.023681825, 0.023758963, 0.023834148, 0.023910858, 0.023985595, 0.024061896, 0.024135919, + 0.024211489, 0.024285082, 0.024359982, 0.024432929, 0.024507502, 0.024580067, 0.024654256, 0.024726443, 0.02480025, + 0.024872007, 0.02494544, 0.025016792, 0.025089791, 0.025160715, 0.025233308, 0.025303787, 0.025375916, 0.025445908, + 0.025517296, 0.025586268, 0.025657007, 0.02572567, 0.025796061, 0.025864316, 0.02593435, 0.026002239, 0.02607191, + 0.026139371, 0.026208622, 0.026275691, 0.026344562, 0.026411192, 0.026479615, 0.026545819, 0.026613852, + 0.026679626, 0.026746908, 0.026811942, 0.026878839, 0.026943481, 0.027010007, 0.027074223, 0.027140321, + 0.027203808, 0.027269242, 0.027332347, 0.027397383, 0.027460111, 0.027524814, 0.027587164, 0.027651433, + 0.027713345, 0.027777214, 0.027838718, 0.027901866, 0.027962642, 0.028025424, 0.02808582, 0.028148238, 0.028208235, + 0.028270256, 0.028329866, 0.028391505, 0.028450685, 0.02851191, 0.028570671, 0.02863151, 0.028689856, 0.028750259, + 0.028808184, 0.028868187, 0.028925693, 0.028984955, 0.029041363, 0.02909993, 0.029156012, 0.029214257, 0.029270006, + 0.029327931, 0.029383328, 0.029440889, 0.029495927, 0.02955313, 0.02960775, 0.02966455, 0.029718785, 0.029775238, + 0.029829094, 0.029885149, 0.029938562, 0.029994186, 0.030047176, 0.03010207, 0.030154379, 0.03020894, 0.030260853, + 0.030315043, 0.030366601, 0.030420423, 0.030471576, 0.030525038, 0.030575795, 0.030628864, 0.030679252, + 0.030731929, 0.030781891, 0.030834196, 0.030883789, 0.030935725, 0.030984901, 0.031036427, 0.031085212, 0.03113598, + 0.031183664, 0.031233801, 0.031281237, 0.031331085, 0.031378195, 0.031427756, 0.031474523, 0.031523723, + 0.031570178, 0.031619061, 0.031665161, 0.031713687, 0.031759396, 0.031807587, 0.031852972, 0.031900786, + 0.031945743, 0.031993195, 0.032037802, 0.03208489, 0.03212912, 0.032175463, 0.032218978, 0.032265034, 0.032308228, + 0.032353956, 0.032396823, 0.032442238, 0.032484766, 0.03252985, 0.032572016, 0.032616731, 0.032658555, 0.032702938, + 0.032744393, 0.032788407, 0.032829475, 0.032873139, 0.03291386, 0.032957204, 0.032997582, 0.03304017, 0.033079829, + 0.033122133, 0.033161487, 0.033203486, 0.03324252, 0.033284228, 0.033322956, 0.033364337, 0.033402704, 0.033443727, + 0.033481758, 0.033522468, 0.033560183, 0.033600606, 0.033638, 0.03367807, 0.033715118, 0.033754863, 0.03379155, + 0.033830941, 0.033867277, 0.033905942, 0.033941559, 0.033979949, 0.034015279, 0.034053378, 0.034088448, + 0.034126289, 0.034161024, 0.034198537, 0.034232989, 0.034270249, 0.034304403, 0.034341305, 0.034375079, + 0.034411665, 0.034445163, 0.034481473, 0.034514669, 0.034550656, 0.034583509, 0.034619175, 0.0346517, 0.034686681, + 0.034718558, 0.034753297, 0.034784939, 0.034819461, 0.034850787, 0.034884978, 0.034916025, 0.034949966, + 0.034980755, 0.035014432, 0.035044931, 0.035078309, 0.035108477, 0.035141565, 0.035171494, 0.03520431, 0.035233933, + 0.035266437, 0.035295729, 0.03532796, 0.035356965, 0.035388883, 0.035417568, 0.035448819, 0.035476886, 0.035507914, + 0.035535727, 0.035566509, 0.03559408, 0.035624634, 0.035651971, 0.035682261, 0.035709299, 0.035739351, 0.035766162, + 0.035795968, 0.035822496, 0.035852026, 0.035878312, 0.035907593, 0.035933558, 0.035962533, 0.035988245, + 0.036016967, 0.036042389, 0.03607047, 0.036095295, 0.036123186, 0.036147811, 0.036175467, 0.036199834, 0.036227297, + 0.036251463, 0.036278717, 0.036302671, 0.03632969, 0.036353372, 0.03638012, 0.03640357, 0.036430079, 0.036453243, + 0.036479525, 0.036502469, 0.036528539, 0.036551271, 0.036577079, 0.036599535, 0.036624681, 0.036646511, + 0.036671478, 0.036693122, 0.036717929, 0.036739394, 0.036763977, 0.036785211, 0.036809593, 0.036830619, 0.03685483, + 0.036875647, 0.036899623, 0.036920242, 0.036944028, 0.036964424, 0.036987957, 0.037008092, 0.03703139, 0.037051309, + 0.037074395, 0.037094094, 0.037116572, 0.037135649, 0.037157953, 0.037176903, 0.037199069, 0.037218235, + 0.037240557, 0.037259448, 0.037281524, 0.037300166, 0.037322003, 0.037340391, 0.037361972, 0.037380133, 0.03740152, + 0.037419423, 0.037440542, 0.037458237, 0.037479125, 0.037496556, 0.037517224, 0.037534442, 0.037554506, + 0.037571155, 0.037591081, 0.037607569, 0.037627336, 0.037643686, 0.037663307, 0.037679475, 0.037698891, + 0.037714843, 0.037734076, 0.037749864, 0.037768953, 0.037784558, 0.037803452, 0.037818905, 0.037837658, + 0.037852887, 0.037871409, 0.037886467, 0.037904825, 0.037919667, 0.037937406, 0.037951708, 0.037969373, + 0.037983555, 0.038001053, 0.038015082, 0.038032472, 0.038046781, 0.038064376, 0.038078416, 0.038095791, + 0.038109619, 0.038126748, 0.038140371, 0.038157318, 0.038170725, 0.038187474, 0.038200684, 0.038217228, + 0.038230222, 0.038246159, 0.038258608, 0.038274471, 0.038286835, 0.038302574, 0.038314819, 0.038330406, + 0.038342498, 0.038357992, 0.038369931, 0.038385231, 0.038396999, 0.038412143, 0.038423751, 0.038438763, + 0.038450249, 0.03846515, 0.038476508, 0.038491242, 0.038502429, 0.038516596, 0.038527623, 0.038542043, 0.038552891, + 0.038567167, 0.038577896, 0.038592011, 0.038602542, 0.038616486, 0.038626868, 0.03864067, 0.038650881, 0.038664553, + 0.038674649, 0.038688097, 0.038698003, 0.038711347, 0.038721088, 0.038734253, 0.038743846, 0.038756464, + 0.038765531, 0.03877807, 0.038787089, 0.038799595, 0.03880851, 0.038820866, 0.038829662, 0.038841929, 0.038850617, + 0.038862783, 0.03887172, 0.038884092, 0.038892854, 0.038905054, 0.038913649, 0.038925692, 0.038934093, 0.038945932, + 0.038954154, 0.038965426, 0.038973149, 0.038984396, 0.038992044, 0.039003149, 0.039010663, 0.039021682, + 0.039029106, 0.039040022, 0.039047342, 0.039058179, 0.039065417, 0.03907612, 0.039083213, 0.039093778, 0.039100703, + 0.039111156, 0.039118394, 0.039129101, 0.039136145, 0.039146252, 0.039152749, 0.039162792, 0.039169233, + 0.039179184, 0.039185498, 0.039195322, 0.039201509, 0.039211221, 0.039217312, 0.039226916, 0.039232906, + 0.039242405, 0.039248247, 0.039257605, 0.039263327, 0.03927261, 0.039278254, 0.03928702, 0.039292183, 0.039300933, + 0.03930648, 0.039315529, 0.039320931, 0.039329842, 0.039335083, 0.039343886, 0.039349046, 0.039357718, 0.039362747, + 0.039371308, 0.039376181, 0.039384585, 0.039389346, 0.039397676, 0.039402358, 0.03941017, 0.039414346, 0.03942211, + 0.039426267, 0.039434027, 0.03943814, 0.03944581, 0.039450258, 0.03945823, 0.039462503, 0.039470289, 0.039474394, + 0.039482087, 0.03948611, 0.039493691, 0.039497606, 0.039505072, 0.039508849, 0.039515801, 0.039519109, 0.039526012, + 0.039529294, 0.039536163, 0.039539363, 0.039546184, 0.039549332, 0.03955609, 0.039559182, 0.039565857, 0.039569277, + 0.039576225, 0.03957947, 0.039586298, 0.039589435, 0.039595734, 0.039598357, 0.039604578, 0.039607164, 0.039613348, + 0.039615877, 0.039621998, 0.039624453, 0.039630529, 0.039632939, 0.039638929, 0.039641242, 0.039647166, + 0.039649416, 0.039655272, 0.039657854, 0.039663997, 0.039666418, 0.039672028, 0.039673951, 0.03967949, 0.039681353, + 0.039686803, 0.039688587, 0.039693989, 0.039695717, 0.039701078, 0.039702754, 0.039708022, 0.039709583, + 0.039714813, 0.039716363, 0.039721496, 0.039723344, 0.039728362, 0.039729707, 0.039734665, 0.039735932, + 0.039740819, 0.039742015, 0.03974684, 0.039747972, 0.03975274, 0.039753813, 0.039758522, 0.039759532, 0.039764166, + 0.039765112, 0.039769676, 0.039770555, 0.039774626, 0.039775416, 0.039779868, 0.039780617, 0.039784994, + 0.039785683, 0.039790016, 0.039790653, 0.039794892, 0.039795425, 0.03979959, 0.03980004, 0.039804149, 0.039804529, + 0.039808542, 0.039808851, 0.039812397, 0.039812282, 0.039815843, 0.039816149, 0.039820086, 0.039820276, + 0.039824087, 0.039824195, 0.039827928, 0.039827984, 0.039831672, 0.039831642, 0.039835256, 0.039835174, 0.03983872, + 0.039838534, 0.039841592, 0.039840985, 0.039844047, 0.039843846, 0.039847285, 0.039846972, 0.039850306, + 0.039849952, 0.039853241, 0.039852783, 0.039855946, 0.039855395, 0.039858501, 0.039857917, 0.039860617, 0.03985963, + 0.039862271, 0.039861221, 0.039863884, 0.039863266, 0.039866246, 0.039865509, 0.039868437, 0.039867621, + 0.039870478, 0.039869621, 0.039872382, 0.039871413, 0.039874107, 0.039873071, 0.039875299, 0.039873865, + 0.039876096, 0.039874632, 0.039876875, 0.039875809, 0.039878376, 0.039877214, 0.039879732, 0.039878514, + 0.039880946, 0.03987965, 0.039881993, 0.039880618, 0.039882507, 0.039880689, 0.039882578, 0.039880767, 0.039882679, + 0.039881278, 0.039883513, 0.039882012, 0.039884161, 0.039882589, 0.039884683, 0.039883036, 0.039885048, + 0.039883334, 0.039884869, 0.039882701, 0.039884236, 0.039882109, 0.039883684, 0.039881572, 0.039883129, + 0.039881364, 0.039883245, 0.039881397, 0.039883219, 0.039881315, 0.039883077, 0.039881065, 0.039882313, + 0.039879844, 0.039881084, 0.039878659, 0.039879933, 0.039877493, 0.039878726, 0.039876662, 0.039878279, + 0.039876137, 0.039877631, 0.039875388, 0.039876424, 0.039873775, 0.039874814, 0.039872155, 0.039873205, + 0.039870527, 0.039871555, 0.039868876, 0.039869871, 0.03986755, 0.039868895, 0.039866485, 0.039867751, 0.039865281, + 0.039866075, 0.039863154, 0.039863925, 0.039861016, 0.039861813, 0.039858885, 0.039859653, 0.039857108, + 0.039858233, 0.039855573, 0.039856568, 0.0398538, 0.03985472, 0.03985193, 0.039852414, 0.039849177, 0.039849635, + 0.039846405, 0.039846886, 0.039843667, 0.039844152, 0.039841324, 0.039842173, 0.039839268, 0.039840039, 0.03983704, + 0.039837305, 0.039833888, 0.039834179, 0.039830774, 0.039831039, 0.039827585, 0.039827846, 0.039824832, + 0.039825495, 0.039822374, 0.039822929, 0.03981974, 0.039819807, 0.039816167, 0.03981626, 0.039812647, 0.03981274, + 0.039809089, 0.039809156, 0.03980552, 0.039805599, 0.039802365, 0.039802767, 0.039799426, 0.039799772, 0.039796378, + 0.039796248, 0.039792378, 0.03979221, 0.039788347, 0.039788216, 0.039784379, 0.039784249, 0.039780792, 0.039780986, + 0.03977742, 0.039777532, 0.039773937, 0.039773591, 0.039769523, 0.039769176, 0.039765112, 0.039764777, 0.039760772, + 0.039760478, 0.039756846, 0.039756857, 0.039753139, 0.039753102, 0.039749324, 0.039748818, 0.039744604, + 0.039744124, 0.039739918, 0.039739423, 0.039735217, 0.039734714, 0.039730921, 0.039730806, 0.039726924, + 0.039726675, 0.039722677, 0.039721988, 0.039717581, 0.03971687, 0.039712485, 0.039711833, 0.039707463, 0.039706774, + 0.039702788, 0.039702468, 0.039698381, 0.039697569, 0.03969305, 0.039692272, 0.039687801, 0.039687019, 0.039682522, + 0.039681729, 0.039677627, 0.03967721, 0.039673038, 0.039672531, 0.039668307, 0.039667346, 0.039662693, 0.039661761, + 0.03965712, 0.039656173, 0.039651517, 0.039650574, 0.039646316, 0.039645746, 0.039641418, 0.039640728, 0.039636306, + 0.039635167, 0.039630339, 0.039629225, 0.039624393, 0.039623279, 0.039618451, 0.039617348, 0.039612968, + 0.039612226, 0.039607733, 0.039606515, 0.039601613, 0.039600413, 0.039595507, 0.039594322, 0.039589401, + 0.039588172, 0.039583668, 0.039582826, 0.039578237, 0.039577316, 0.039572656, 0.039571244, 0.039566118, + 0.039564725, 0.039559674, 0.039558318, 0.039553642, 0.039552655, 0.03954792, 0.039546859, 0.039542053, 0.039540518, + 0.039535321, 0.039533839, 0.039528631, 0.039527141, 0.039521966, 0.039520513, 0.039515752, 0.039514601, + 0.039509721, 0.039508156, 0.039502908, 0.039501362, 0.03949612, 0.03949457, 0.03948931, 0.039487772, 0.039482936, + 0.039481755, 0.039476808, 0.039475132, 0.039469775, 0.039468128, 0.039462771, 0.039461102, 0.039455716, + 0.039454039, 0.039449085, 0.039447781, 0.039442752, 0.039441384, 0.03943627, 0.039434422, 0.039428886, 0.039427068, + 0.03942154, 0.039419707, 0.039414618, 0.039413203, 0.039408062, 0.03940659, 0.039401401, 0.039399449, 0.039393812, + 0.039391894, 0.039386269, 0.039384346, 0.039379131, 0.03937757, 0.039372284, 0.039370652, 0.039365299, 0.039363232, + 0.039357476, 0.039355442, 0.039349739, 0.039347742, 0.039342437, 0.03934079, 0.039335433, 0.03933372, 0.039328288, + 0.039326154, 0.039320316, 0.039318159, 0.039312337, 0.039310221, 0.039304826, 0.039303068, 0.039297584, + 0.039295387, 0.039289508, 0.03928734, 0.039281491, 0.039279312, 0.039273441, 0.039271276, 0.039265811, 0.039264005, + 0.039258506, 0.039256275, 0.039250348, 0.03924812, 0.039242215, 0.039239973, 0.03923443, 0.039232552, 0.039226957, + 0.039225034, 0.039219391, 0.039216984, 0.039210893, 0.039208524, 0.039202496, 0.039200176, 0.039194558, + 0.039192576, 0.039186887, 0.039184853, 0.039179109, 0.039176613, 0.039170444, 0.039167952, 0.039162204, + 0.039160121, 0.039154328, 0.039152194, 0.039146341, 0.039143756, 0.039137501, 0.039134938, 0.039128695, + 0.039126184, 0.039120417, 0.039118253, 0.039112378, 0.03911018, 0.039104261, 0.039101604, 0.039095286, 0.039092649, + 0.039086748, 0.039084516, 0.039078563, 0.039076269, 0.039070252, 0.039067492, 0.039061088, 0.039058361, + 0.039051957, 0.03904926, 0.039043285, 0.039040957, 0.039034899, 0.039032497, 0.039026413, 0.039023593, 0.039017126, + 0.039014369, 0.039008323, 0.039005909, 0.038999815, 0.038997352, 0.038991179, 0.038988274, 0.038981713, + 0.038978841, 0.038972326, 0.038969502, 0.038963363, 0.038960874, 0.03895472, 0.038952228, 0.038946033, 0.038943063, + 0.038936429, 0.038933519, 0.038927354, 0.03892481, 0.038918555, 0.038915936, 0.038909636, 0.038906589, 0.038899913, + 0.038896937, 0.038890686, 0.038888056, 0.038881745, 0.038879097, 0.038872756, 0.038869645, 0.038862903, + 0.038859852, 0.038853534, 0.038850836, 0.038844433, 0.03884168, 0.038835254, 0.038832068, 0.038825251, 0.038822114, + 0.038815733, 0.03881298, 0.03880652, 0.038803708, 0.038797233, 0.038794421, 0.038787901, 0.038784619, 0.0387781, + 0.038775232, 0.038768686, 0.038765777, 0.038759187, 0.038756248, 0.038749635, 0.038746268, 0.038739644, + 0.038736667, 0.038730014, 0.038727004, 0.038720313, 0.03871727, 0.038710579, 0.038707137, 0.03870045, 0.038697395, + 0.038690671, 0.038687609, 0.038680904, 0.038677815, 0.038671046, 0.03866753, 0.038660783, 0.038657684, 0.038650911, + 0.038647771, 0.038640969, 0.038637798, 0.038630992, 0.038627449, 0.038620662, 0.038617488, 0.038610641, + 0.038607433, 0.038600557, 0.03859733, 0.038590454, 0.038586807, 0.038579926, 0.03857667, 0.038569778, 0.038566511, + 0.038559575, 0.038556322, 0.038549423, 0.038545724, 0.038538799, 0.038535532, 0.038528588, 0.038525254, + 0.038518269, 0.038514931, 0.038507935, 0.038504157, 0.038497183, 0.038493842, 0.038486838, 0.038483452, + 0.038476415, 0.038472608, 0.038465578, 0.038462169, 0.038455114, 0.038451701, 0.038444612, 0.038441159, + 0.038434103, 0.038430274, 0.038423225, 0.038419791, 0.038412686, 0.0384092, 0.038402054, 0.038398515, 0.038391333, + 0.038387377, 0.038380194, 0.038376633, 0.038369421, 0.03836586, 0.038358692, 0.038355105, 0.038348246, 0.03834461, + 0.038337346, 0.038333688, 0.038326386, 0.038322728, 0.038315438, 0.038311366, 0.038304087, 0.038300395, + 0.038293086, 0.038289413, 0.038282052, 0.038278345, 0.038271446, 0.038267702, 0.038260311, 0.038256552, + 0.038249191, 0.038245436, 0.038238041, 0.03823426, 0.038227212, 0.038223345, 0.038215879, 0.03821202, 0.03820454, + 0.038200688, 0.038193606, 0.038189698, 0.038182192, 0.038178306, 0.03817077, 0.038166843, 0.038159296, 0.038155373, + 0.038148236, 0.038144279, 0.038136695, 0.03813272, 0.038125124, 0.038121127, 0.038113888, 0.038109846, 0.038102195, + 0.038098171, 0.038090549, 0.038086526, 0.038078882, 0.038074847, 0.038067594, 0.038063519, 0.038055815, + 0.038051751, 0.038044084, 0.038039993, 0.03803267, 0.038028512, 0.038020756, 0.038016606, 0.038008854, 0.038004681, + 0.037997309, 0.037993528, 0.037986092, 0.037981808, 0.037973925, 0.037969645, 0.037961785, 0.037957527, + 0.037950054, 0.037945766, 0.037937887, 0.037933599, 0.037925679, 0.037921369, 0.03791387, 0.037909944, 0.037902389, + 0.037898019, 0.037890058, 0.037885692, 0.037878126, 0.037874114, 0.037866458, 0.03786198, 0.037853938, 0.037849486, + 0.03784145, 0.03783701, 0.037829358, 0.037824865, 0.037816815, 0.037812352, 0.037804298, 0.037799835, 0.037792169, + 0.037787698, 0.037779622, 0.037775129, 0.037767049, 0.03776253, 0.037754811, 0.037750669, 0.037742924, 0.037738319, + 0.037730157, 0.037725579, 0.037717804, 0.037713569, 0.037705708, 0.037701011, 0.037692737, 0.03768805, 0.037680183, + 0.037675861, 0.03766793, 0.037663199, 0.037654888, 0.037650164, 0.037642274, 0.037637915, 0.037629955, 0.037625153, + 0.037616797, 0.03761204, 0.037604079, 0.037599616, 0.037591562, 0.037586708, 0.037578288, 0.037573449, 0.037565429, + 0.037560955, 0.037552897, 0.037548382, 0.03754025, 0.03753528, 0.037527155, 0.037522569, 0.037514426, 0.037509814, + 0.037501588, 0.037496515, 0.037488304, 0.037483618, 0.03747537, 0.037470706, 0.037462447, 0.037457332, 0.037449058, + 0.037444338, 0.037436049, 0.037431281, 0.03742294, 0.03741774, 0.037409339, 0.037404522, 0.03739617, 0.037391316, + 0.037382886, 0.037377633, 0.037369244, 0.037364405, 0.037355993, 0.03735112, 0.03734266, 0.03733734, 0.03732891, + 0.037324004, 0.03731551, 0.037310582, 0.037302103, 0.037296735, 0.037288241, 0.037283279, 0.037274733, 0.037269726, + 0.037261162, 0.03725573, 0.037247185, 0.037242152, 0.037233554, 0.03722848, 0.037219863, 0.037214383, 0.037205808, + 0.037200749, 0.037192114, 0.037186995, 0.037178725, 0.037173551, 0.037164815, 0.037159603, 0.037150852, + 0.037145246, 0.03713654, 0.037131373, 0.037122648, 0.037117407, 0.037108652, 0.037103061, 0.037094317, 0.037089061, + 0.037080254, 0.037074998, 0.037066225, 0.03706057, 0.037051763, 0.037046466, 0.037037645, 0.037032347, 0.037023481, + 0.037017751, 0.037008923, 0.037003603, 0.03699474, 0.03698938, 0.036980875, 0.036975447, 0.036966484, 0.036961041, + 0.036952052, 0.036946569, 0.036937967, 0.036932468, 0.036923461, 0.036917932, 0.036908846, 0.036902882, + 0.036893837, 0.036888324, 0.03687929, 0.036873747, 0.036865052, 0.036859412, 0.036850262, 0.036844641, 0.036835492, + 0.036829837, 0.036821067, 0.036815379, 0.036806177, 0.036800466, 0.036791235, 0.036785502, 0.036776647, 0.03677088, + 0.036761623, 0.036755864, 0.036746975, 0.036741152, 0.036731824, 0.036726024, 0.036716715, 0.036710873, + 0.036701936, 0.036696069, 0.036686677, 0.036680784, 0.036671802, 0.036666244, 0.036657158, 0.036651149, + 0.036641676, 0.036635701, 0.036626615, 0.036620598, 0.036611099, 0.036605094, 0.03659597, 0.036590286, 0.036581077, + 0.036574926, 0.036565322, 0.036559224, 0.036550026, 0.036543891, 0.036534268, 0.036528118, 0.036518876, + 0.036513094, 0.036503829, 0.036497608, 0.03648787, 0.036481626, 0.036472302, 0.036466423, 0.036457058, 0.036450759, + 0.036441363, 0.036435418, 0.036425982, 0.0364196, 0.036409758, 0.036403392, 0.036393948, 0.03638795, 0.03637844, + 0.036372002, 0.036362488, 0.036356434, 0.03634689, 0.036340371, 0.036330424, 0.036323953, 0.036314398, 0.036308281, + 0.036298674, 0.036292102, 0.03628248, 0.036276292, 0.036266617, 0.036259983, 0.03625029, 0.036244042, 0.036234312, + 0.03622802, 0.036218278, 0.036211584, 0.036201831, 0.036195498, 0.036185712, 0.036178976, 0.036169183, 0.036162801, + 0.036152963, 0.036146179, 0.036135938, 0.036129162, 0.036119349, 0.03611296, 0.036103092, 0.036096256, 0.03608638, + 0.036079939, 0.036070034, 0.036063168, 0.036053233, 0.036046728, 0.036036793, 0.036030259, 0.036020253, + 0.036013268, 0.036003266, 0.035996683, 0.035986647, 0.035979643, 0.035969604, 0.035962969, 0.035952903, + 0.035945866, 0.035935771, 0.035929084, 0.035918951, 0.035912212, 0.035902459, 0.035895709, 0.035885487, + 0.035878651, 0.035868399, 0.035861209, 0.035850972, 0.03584411, 0.035833821, 0.035826571, 0.035816327, 0.035809476, + 0.035799164, 0.035792254, 0.035782292, 0.035775311, 0.035764914, 0.035757896, 0.03574783, 0.035740767, 0.03573028, + 0.035723213, 0.035712738, 0.035705261, 0.035694793, 0.035687745, 0.035677273, 0.035670165, 0.035660025, + 0.035652887, 0.035642337, 0.035635184, 0.035624988, 0.035617743, 0.035607129, 0.035599921, 0.035589658, + 0.035582356, 0.035571683, 0.035564408, 0.035554089, 0.035546757, 0.035536002, 0.035528634, 0.035518263, + 0.035511244, 0.035500791, 0.035493314, 0.035482462, 0.03547499, 0.035464495, 0.035457, 0.035446122, 0.035438608, + 0.035428081, 0.035420511, 0.03540957, 0.035402033, 0.035391487, 0.035383906, 0.035372946, 0.03536538, 0.035354819, + 0.03534719, 0.035336178, 0.035328548, 0.03531792, 0.035310611, 0.035299901, 0.035292167, 0.035281442, 0.035274036, + 0.035263222, 0.035255395, 0.035244606, 0.035237141, 0.035226267, 0.035218369, 0.035207484, 0.035199907, + 0.035188954, 0.035180975, 0.03517003, 0.035162419, 0.0351514, 0.035143349, 0.035132345, 0.035124686, 0.035113648, + 0.035105553, 0.035094503, 0.035086811, 0.035075713, 0.035067577, 0.035056487, 0.035048731, 0.035037588, + 0.035029363, 0.035018183, 0.035010349, 0.034999166, 0.034990925, 0.034979738, 0.034971878, 0.03496065, 0.034952749, + 0.034941867, 0.034933861, 0.034922499, 0.034914464, 0.034903459, 0.034895375, 0.03488395, 0.034875821, 0.034864724, + 0.034856547, 0.034845028, 0.034836825, 0.034825668, 0.034817431, 0.034805842, 0.034797546, 0.034786306, + 0.034777999, 0.034766361, 0.034758024, 0.034746736, 0.034738369, 0.034726672, 0.034718283, 0.034706976, + 0.034698572, 0.034686837, 0.034678429, 0.034667078, 0.034658626, 0.03464685, 0.034638375, 0.034626968, 0.034618456, + 0.034606613, 0.034598071, 0.03458659, 0.03457801, 0.034566134, 0.034557581, 0.034546081, 0.034537461, 0.034525555, + 0.034516957, 0.034505423, 0.034496762, 0.034485165, 0.034476835, 0.034465183, 0.034456413, 0.034444727, + 0.034436285, 0.034424473, 0.034415573, 0.034403797, 0.034394894, 0.034382705, 0.034373816, 0.034362014, + 0.034353092, 0.034340892, 0.034331996, 0.034320202, 0.034311254, 0.034299031, 0.03429009, 0.034278255, 0.034269292, + 0.034257047, 0.034248061, 0.03423617, 0.034227163, 0.03421526, 0.034206573, 0.034194585, 0.034185488, 0.034173507, + 0.034164745, 0.034152675, 0.034143478, 0.034131397, 0.034122523, 0.034110367, 0.034101095, 0.034088943, + 0.034080029, 0.034067839, 0.034058504, 0.034046296, 0.034036931, 0.034024682, 0.034015656, 0.03400334, 0.033993911, + 0.033981655, 0.033972587, 0.033960238, 0.033950757, 0.033938419, 0.033929311, 0.033916939, 0.033907384, + 0.033895001, 0.033885814, 0.033873729, 0.033864472, 0.033851981, 0.033842705, 0.033830512, 0.033821151, + 0.033808544, 0.033798803, 0.03378623, 0.033776853, 0.033764221, 0.03375442, 0.033741806, 0.033732403, 0.033720132, + 0.033710677, 0.033697966, 0.033688448, 0.033676066, 0.033666495, 0.03365371, 0.033644117, 0.033631649, 0.033622015, + 0.033609174, 0.033599164, 0.033586327, 0.033576678, 0.033564191, 0.033554487, 0.033541553, 0.033531811, + 0.033519216, 0.033509415, 0.033496443, 0.033486653, 0.033474021, 0.03346419, 0.033451509, 0.033441972, 0.033429191, + 0.033419222, 0.033406436, 0.033396441, 0.03338325, 0.033373255, 0.03336044, 0.033350404, 0.033337545, 0.033327837, + 0.033314928, 0.033304807, 0.033291869, 0.033281706, 0.033268362, 0.033258222, 0.033245277, 0.033235095, + 0.033222109, 0.033212256, 0.033199191, 0.033188935, 0.033175893, 0.033165973, 0.033152845, 0.033142503, + 0.033129353, 0.033118971, 0.033105813, 0.033095762, 0.033082496, 0.033072047, 0.033058841, 0.03304876, 0.033035852, + 0.033025663, 0.033012286, 0.033001706, 0.032988362, 0.032978132, 0.032964729, 0.032954127, 0.032940764, + 0.032930497, 0.032917421, 0.03290708, 0.032893591, 0.032882866, 0.032869361, 0.032858998, 0.032845832, 0.032835372, + 0.032821793, 0.03281134, 0.032798078, 0.032787509, 0.032773815, 0.032762893, 0.032749213, 0.032738663, 0.032725357, + 0.032714754, 0.032700993, 0.03269035, 0.032676958, 0.032666307, 0.032652862, 0.032642126, 0.032628272, 0.032617524, + 0.03260402, 0.03259322, 0.032579679, 0.032568835, 0.032554876, 0.032544043, 0.032530472, 0.032519616, 0.032505643, + 0.032494757, 0.032481115, 0.032470193, 0.032456532, 0.032445543, 0.032431461, 0.032420486, 0.032406762, + 0.032395743, 0.032381985, 0.032371286, 0.032357465, 0.032346312, 0.032332424, 0.032321252, 0.032307386, + 0.032296579, 0.032282654, 0.032271411, 0.032257449, 0.032246199, 0.032232244, 0.032221321, 0.032207295, + 0.032195956, 0.032181926, 0.032170594, 0.032156564, 0.032145575, 0.032131493, 0.032120079, 0.032105934, + 0.032094818, 0.032081004, 0.032069836, 0.032055583, 0.032044038, 0.032029826, 0.032018632, 0.03200471, 0.03199343, + 0.031979091, 0.031967431, 0.031953093, 0.031941786, 0.031927746, 0.031916369, 0.031901941, 0.031890195, + 0.031875785, 0.031864386, 0.031850275, 0.031838827, 0.031824343, 0.031812523, 0.031798039, 0.03178658, 0.031772424, + 0.031760871, 0.031746645, 0.031735048, 0.03172043, 0.031708837, 0.031694558, 0.031682909, 0.031668589, 0.03165688, + 0.031642161, 0.031630471, 0.031616103, 0.031604342, 0.031589925, 0.031578138, 0.031563327, 0.031551529, + 0.031537086, 0.031525251, 0.03151077, 0.031498902, 0.031484377, 0.031472825, 0.031458218, 0.031446226, 0.031431593, + 0.031419575, 0.031404931, 0.031393256, 0.031378563, 0.031366486, 0.031351775, 0.031339679, 0.031324927, 0.03131314, + 0.031298362, 0.031286187, 0.031271383, 0.031259175, 0.031244367, 0.031232521, 0.031218002, 0.031206045, + 0.031191122, 0.031178795, 0.031163858, 0.03115188, 0.031137275, 0.031125227, 0.031110181, 0.031097746, 0.031082736, + 0.03107067, 0.031055983, 0.031043852, 0.031029103, 0.031016925, 0.031001763, 0.030989192, 0.030974044, 0.030961845, + 0.030947026, 0.030934749, 0.03091988, 0.030907571, 0.030892316, 0.030880008, 0.030865079, 0.030852692, 0.030837733, + 0.030825321, 0.030809965, 0.030797532, 0.030782502, 0.030770028, 0.030754974, 0.030742468, 0.0307274, 0.030714864, + 0.030699385, 0.030686853, 0.030671768, 0.030659195, 0.030644044, 0.03063143, 0.030616233, 0.030603921, 0.030588673, + 0.030575942, 0.030560674, 0.030547954, 0.030532673, 0.030519905, 0.030504616, 0.030492203, 0.030476836, + 0.030463997, 0.030448608, 0.03043578, 0.030420413, 0.030407907, 0.030392827, 0.030380245, 0.030364737, 0.030351751, + 0.030336244, 0.030323258, 0.030307759, 0.030295121, 0.030279934, 0.030267214, 0.0302516, 0.030238522, 0.030222921, + 0.030210203, 0.030194949, 0.030182175, 0.030166836, 0.030153949, 0.030138193, 0.030124975, 0.030109262, + 0.030096397, 0.030080998, 0.030068086, 0.030052647, 0.030039672, 0.030024188, 0.030011196, 0.029995348, + 0.029982338, 0.029966796, 0.029953714, 0.029938139, 0.029925022, 0.029909404, 0.029896261, 0.029880274, + 0.029867144, 0.029851515, 0.029838365, 0.029822713, 0.029809508, 0.029793827, 0.029780602, 0.029764881, + 0.029751973, 0.029736204, 0.029722895, 0.029707119, 0.02969381, 0.029678032, 0.029664678, 0.029648861, 0.029635843, + 0.029619988, 0.029606566, 0.029590672, 0.02957724, 0.029561339, 0.02954787, 0.02953195, 0.029518845, 0.029503262, + 0.029490091, 0.029474085, 0.029460518, 0.029444499, 0.029430918, 0.029414892, 0.029401654, 0.029385958, + 0.029372687, 0.029356947, 0.029343601, 0.029327441, 0.029313713, 0.029297572, 0.029284222, 0.029268395, + 0.029254951, 0.029239055, 0.029225573, 0.029209653, 0.029196115, 0.029179808, 0.029166289, 0.029150344, + 0.029136781, 0.029120779, 0.029107202, 0.029091198, 0.029077565, 0.029061489, 0.029047839, 0.029031446, + 0.029017797, 0.029001722, 0.02898803, 0.028971937, 0.028958233, 0.028942123, 0.028928399, 0.028912269, 0.028898861, + 0.028883016, 0.028869513, 0.028853215, 0.028839307, 0.028823027, 0.028809145, 0.02879288, 0.02877898, 0.028762698, + 0.028749153, 0.028733198, 0.02871957, 0.028703213, 0.02868923, 0.028672837, 0.028658798, 0.028642399, 0.028628731, + 0.028612668, 0.028598938, 0.028582817, 0.028569045, 0.028552882, 0.028539034, 0.028522464, 0.028508266, + 0.028491734, 0.028477916, 0.028461725, 0.028447865, 0.028431635, 0.028417733, 0.028401453, 0.028387511, 0.0283712, + 0.028357202, 0.028340532, 0.028326571, 0.028310237, 0.028296219, 0.028279858, 0.028265817, 0.0282494, 0.028235311, + 0.028218908, 0.028204847, 0.028188432, 0.028174648, 0.028158173, 0.028144017, 0.028127525, 0.028113367, 0.02809689, + 0.02808271, 0.02806621, 0.028052008, 0.02803549, 0.028021598, 0.028005376, 0.027991464, 0.027975207, 0.027961202, + 0.027944509, 0.027930133, 0.027913475, 0.027899142, 0.027882515, 0.027868183, 0.027851544, 0.027837526, + 0.027821189, 0.027807113, 0.027790725, 0.027776612, 0.02776018, 0.027746009, 0.027729219, 0.027714739, 0.027697986, + 0.027683828, 0.027667357, 0.027653161, 0.027636696, 0.027622478, 0.027605968, 0.027591713, 0.027575152, + 0.027560851, 0.027544269, 0.027529942, 0.027513014, 0.027498705, 0.027482107, 0.027467756, 0.027451148, + 0.027436791, 0.027420167, 0.027405808, 0.027389174, 0.027374785, 0.027358145, 0.02734373, 0.02732705, 0.027312942, + 0.027296538, 0.027282365, 0.02726559, 0.027251076, 0.027234321, 0.02721981, 0.027203046, 0.027188513, 0.027171738, + 0.027157184, 0.027140411, 0.027126199, 0.027109724, 0.027095446, 0.027078902, 0.027064569, 0.027047999, + 0.027033621, 0.027016664, 0.027001945, 0.026985044, 0.026970373, 0.026953485, 0.026939146, 0.026922576, + 0.026908197, 0.026891584, 0.026877172, 0.026860535, 0.026846064, 0.026829401, 0.026814934, 0.026798237, + 0.026783714, 0.026766988, 0.026752464, 0.026735421, 0.026720906, 0.026704179, 0.026689639, 0.026672903, + 0.026658338, 0.026641572, 0.026626986, 0.026610207, 0.026595598, 0.026578801, 0.026564198, 0.026547408, + 0.026533114, 0.026516616, 0.026502253, 0.026485672, 0.026471246, 0.026454311, 0.026439549, 0.026422624, + 0.026407875, 0.026390975, 0.026376231, 0.026359312, 0.026344581, 0.026327692, 0.026312964, 0.026296062, + 0.026281647, 0.026265079, 0.026250629, 0.026233997, 0.026219485, 0.026202805, 0.026188262, 0.026171563, + 0.026156975, 0.02614023, 0.02612563, 0.026108557, 0.026093623, 0.026076587, 0.026062023, 0.0260453, 0.02603071, + 0.02601398, 0.025999365, 0.025982607, 0.025967956, 0.025951175, 0.025936505, 0.025919709, 0.025905024, 0.025888219, + 0.025873538, 0.025856739, 0.02584203, 0.025825191, 0.025810797, 0.025794258, 0.025779771, 0.025762836, 0.025748027, + 0.02573113, 0.025716312, 0.025699386, 0.025684573, 0.025667669, 0.025652865, 0.025635989, 0.025621237, 0.025604391, + 0.025589604, 0.025572727, 0.025558274, 0.025541697, 0.025527185, 0.025510561, 0.025495987, 0.02547932, 0.025464723, + 0.025448043, 0.025433421, 0.025416689, 0.025401995, 0.02538524, 0.02537057, 0.025353806, 0.025339093, 0.025322, + 0.025306972, 0.025289899, 0.025275251, 0.025258537, 0.025243871, 0.02522712, 0.02521242, 0.025195668, 0.025180981, + 0.025164237, 0.025149532, 0.025132762, 0.025118023, 0.025101248, 0.025086505, 0.025069708, 0.02505496, 0.025038183, + 0.025023444, 0.025006657, 0.024992229, 0.024975725, 0.024961215, 0.024944648, 0.024930097, 0.024913518, + 0.024898959, 0.024882339, 0.024867717, 0.024850724, 0.024835769, 0.024818812, 0.024803912, 0.024787022, 0.02477216, + 0.024755286, 0.024740424, 0.024723552, 0.024708703, 0.02469187, 0.024677388, 0.024660869, 0.024646297, 0.02462971, + 0.024615118, 0.024598518, 0.024583895, 0.024567254, 0.024552602, 0.024535961, 0.024521306, 0.024504634, 0.02448995, + 0.024473261, 0.024458554, 0.024441876, 0.024427172, 0.024410473, 0.024395769, 0.024379099, 0.024364714, + 0.024348313, 0.024333881, 0.024317458, 0.024302971, 0.024286471, 0.024271913, 0.024255382, 0.02424081, 0.024223924, + 0.024209008, 0.024192169, 0.02417733, 0.024160538, 0.024145726, 0.024128964, 0.024114158, 0.024097413, 0.024082625, + 0.024065899, 0.024051145, 0.024034429, 0.024019966, 0.024003539, 0.023989042, 0.023972599, 0.023958104, + 0.023941647, 0.023927106, 0.023910601, 0.023896022, 0.023879508, 0.023864921, 0.023848405, 0.023833817, + 0.023817293, 0.023802711, 0.023786189, 0.023771584, 0.023755036, 0.023740409, 0.02372388, 0.02370928, 0.023692749, + 0.023678137, 0.023661608, 0.023646982, 0.023630455, 0.023616154, 0.023599917, 0.023585552, 0.023569256, + 0.023554841, 0.023538521, 0.023524074, 0.023507707, 0.023493247, 0.023476874, 0.023462379, 0.023445979, + 0.023431489, 0.023415091, 0.023400564, 0.023383835, 0.023369031, 0.023352355, 0.02333758, 0.023320951, 0.023306226, + 0.023289654, 0.02327498, 0.023258429, 0.023243772, 0.02322725, 0.023212614, 0.023196125, 0.023181811, 0.023165597, + 0.023151265, 0.023135062, 0.02312069, 0.023104448, 0.023090063, 0.023073789, 0.023059387, 0.02304312, 0.023028696, + 0.023012439, 0.022998039, 0.022981767, 0.022967352, 0.022951085, 0.022936666, 0.022920394, 0.022905972, + 0.022889696, 0.022875257, 0.022858974, 0.022844559, 0.0228283, 0.02281386, 0.022797586, 0.022783171, 0.022766922, + 0.022752494, 0.022736251, 0.022722157, 0.022706207, 0.022692049, 0.022676038, 0.022661833, 0.022645786, + 0.022631591, 0.022615556, 0.022601316, 0.022585247, 0.022570962, 0.022554863, 0.022540594, 0.022524506, 0.02251024, + 0.022494163, 0.022479894, 0.022463793, 0.022449484, 0.022433376, 0.022419086, 0.022402992, 0.022388689, 0.02237259, + 0.0223583, 0.022342212, 0.022327924, 0.022311861, 0.022297595, 0.02228155, 0.022267295, 0.022251261, 0.022237007, + 0.022220962, 0.022207011, 0.022191251, 0.022177264, 0.02216148, 0.022147454, 0.022131631, 0.022117579, 0.02210176, + 0.022087703, 0.022071846, 0.022057746, 0.022041872, 0.022027755, 0.022011871, 0.02199775, 0.021981871, 0.021967759, + 0.021951897, 0.021937788, 0.021921903, 0.021907793, 0.021891929, 0.021877818, 0.021861952, 0.021847839, + 0.021831987, 0.0218179, 0.021802051, 0.021787936, 0.021772088, 0.021757998, 0.02174218, 0.021728111, 0.02171232, + 0.021698276, 0.021682469, 0.021668412, 0.021652648, 0.021638611, 0.021622833, 0.021609075, 0.021593595, + 0.021579824, 0.02156429, 0.021550471, 0.021534912, 0.021521073, 0.02150551, 0.021491654, 0.021476064, 0.021462187, + 0.021446593, 0.021432729, 0.021417145, 0.021403246, 0.021387644, 0.021373756, 0.021358153, 0.021344265, 0.02132869, + 0.021314807, 0.021299221, 0.021285335, 0.021269759, 0.021255901, 0.021240344, 0.021226473, 0.021210924, + 0.021197066, 0.021181514, 0.021167675, 0.021152169, 0.021138353, 0.021122862, 0.02110905, 0.021093557, 0.021079756, + 0.021064289, 0.021050511, 0.021035051, 0.021021266, 0.021005824, 0.020992057, 0.020976614, 0.02096287, 0.020947468, + 0.020933736, 0.020918338, 0.020904878, 0.020889726, 0.020876233, 0.020861065, 0.020847552, 0.020832378, + 0.020818852, 0.020803662, 0.020790115, 0.020774927, 0.020761391, 0.020746175, 0.020732608, 0.020717394, + 0.020703824, 0.020688621, 0.020675069, 0.020659868, 0.020646308, 0.020631125, 0.02061758, 0.020602399, 0.020588864, + 0.020573694, 0.020560162, 0.020544995, 0.020531451, 0.020516278, 0.020502731, 0.02048758, 0.020474082, 0.02045895, + 0.020445447, 0.020430332, 0.020416822, 0.020401707, 0.020388246, 0.020373179, 0.020359719, 0.02034465, 0.020331211, + 0.02031618, 0.02030278, 0.020287784, 0.02027438, 0.020259358, 0.020245951, 0.020230955, 0.020217588, 0.020202614, + 0.020189235, 0.020174278, 0.020160941, 0.02014601, 0.020132668, 0.020117739, 0.020104408, 0.020089513, 0.020076238, + 0.020061372, 0.020048391, 0.020033792, 0.020020751, 0.020006118, 0.019993044, 0.019978378, 0.0199653, 0.019950641, + 0.019937543, 0.01992286, 0.019909745, 0.01989506, 0.019881958, 0.019867295, 0.019854195, 0.019839501, 0.019826353, + 0.019811668, 0.019798573, 0.019783907, 0.019770814, 0.019756168, 0.019743092, 0.01972845, 0.019715363, 0.019700725, + 0.019687658, 0.019673042, 0.01965999, 0.01964541, 0.019632369, 0.0196178, 0.019604785, 0.019590214, 0.019577175, + 0.019562609, 0.01954961, 0.019535067, 0.019522076, 0.019507566, 0.019494599, 0.019480096, 0.019467128, 0.019452654, + 0.019439703, 0.019425234, 0.019412322, 0.019397879, 0.019384967, 0.019370543, 0.019357646, 0.019343251, + 0.019330379, 0.019316269, 0.019303676, 0.019289542, 0.019276898, 0.019262737, 0.019250082, 0.019235887, + 0.019223202, 0.01920902, 0.019196341, 0.019182157, 0.019169483, 0.019155296, 0.019142602, 0.019128399, 0.019115714, + 0.01910153, 0.019088838, 0.019074664, 0.019061988, 0.019047804, 0.019035116, 0.019020958, 0.019008312, 0.018994169, + 0.018981516, 0.018967386, 0.018955026, 0.018941171, 0.018928796, 0.018914903, 0.018902484, 0.018888589, + 0.018876156, 0.018862242, 0.018849809, 0.01883588, 0.018823409, 0.018809458, 0.018796969, 0.018783014, 0.018770549, + 0.01875663, 0.018744174, 0.018730251, 0.018717794, 0.018703867, 0.018691393, 0.018677466, 0.018665012, 0.018651102, + 0.018638667, 0.01862479, 0.018612375, 0.018598493, 0.018586075, 0.018572226, 0.018559838, 0.018546002, 0.01853363, + 0.018519823, 0.018507458, 0.01849365, 0.018481288, 0.018467491, 0.018455153, 0.01844139, 0.01842908, 0.018415339, + 0.018403044, 0.018389309, 0.018377015, 0.018363306, 0.018351039, 0.018337345, 0.018325085, 0.018311415, + 0.018299177, 0.018285522, 0.018273301, 0.018259671, 0.018247474, 0.018233875, 0.018221699, 0.0182081, 0.018195929, + 0.01818236, 0.01817021, 0.018156642, 0.018144511, 0.01813099, 0.018118892, 0.018105665, 0.018093809, 0.018080531, + 0.018068658, 0.018055361, 0.018043453, 0.018030144, 0.018018235, 0.018004922, 0.017993016, 0.017979706, + 0.017967779, 0.017954459, 0.017942546, 0.017929234, 0.017917296, 0.017903987, 0.017892066, 0.017878758, + 0.017866848, 0.017853566, 0.017841686, 0.017828437, 0.017816557, 0.017803296, 0.017791424, 0.017778194, + 0.017766356, 0.017753152, 0.017741313, 0.0177281, 0.01771627, 0.017703071, 0.017691264, 0.017678093, 0.017666299, + 0.017653158, 0.01764138, 0.017628241, 0.017616471, 0.017603334, 0.017591568, 0.017578468, 0.017566733, 0.017553646, + 0.017542193, 0.017529367, 0.017517887, 0.017505046, 0.017493546, 0.01748067, 0.01746914, 0.017456269, 0.017444737, + 0.017431844, 0.017420301, 0.017407419, 0.01739588, 0.017382998, 0.017371459, 0.017358581, 0.01734704, 0.017334174, + 0.017322658, 0.017309805, 0.017298304, 0.017285485, 0.017273994, 0.017261175, 0.01724969, 0.017236866, 0.017225383, + 0.017212592, 0.017201114, 0.01718832, 0.017176874, 0.017164115, 0.01715268, 0.017139923, 0.017128497, 0.017116027, + 0.017104853, 0.017092353, 0.017081156, 0.017068647, 0.017057439, 0.017044909, 0.01703367, 0.017021108, 0.017009865, + 0.016997313, 0.016986076, 0.016973538, 0.016962294, 0.016949747, 0.0169385, 0.016925974, 0.016914763, 0.016902249, + 0.016891016, 0.01687848, 0.016867261, 0.016854757, 0.016843552, 0.016831065, 0.016819872, 0.016807398, 0.016796231, + 0.016783785, 0.01677262, 0.016760174, 0.016749037, 0.016736621, 0.016725488, 0.016713083, 0.016701981, 0.016689617, + 0.01667851, 0.016666124, 0.01665503, 0.016642686, 0.016631618, 0.016619276, 0.016608225, 0.01659593, 0.016584897, + 0.016572598, 0.016561581, 0.01654931, 0.016538301, 0.01652604, 0.016515054, 0.016502814, 0.016491856, 0.016479656, + 0.016468713, 0.016456507, 0.01644556, 0.016433375, 0.016422462, 0.016410302, 0.016399389, 0.016387234, 0.016376365, + 0.016364263, 0.016353399, 0.016341304, 0.016330471, 0.016318405, 0.016307572, 0.016295517, 0.016284715, + 0.016272673, 0.016261874, 0.01624985, 0.01623909, 0.016227098, 0.016216334, 0.016204597, 0.016194079, 0.01618233, + 0.016171806, 0.016160037, 0.016149487, 0.016137697, 0.016127136, 0.016115345, 0.016104763, 0.016092971, + 0.016082389, 0.016070597, 0.01606003, 0.016048249, 0.016037684, 0.016025918, 0.016015379, 0.016003629, 0.015993081, + 0.015981324, 0.015970778, 0.015959028, 0.015948508, 0.015936775, 0.015926508, 0.015915018, 0.01590471, 0.0158932, + 0.015882878, 0.015871333, 0.01586098, 0.015849426, 0.015839072, 0.015827533, 0.01581719, 0.015805645, 0.015795279, + 0.015783729, 0.015773375, 0.015761808, 0.015751442, 0.015739905, 0.015729561, 0.015718032, 0.015707692, + 0.015696162, 0.015685819, 0.015674321, 0.015664009, 0.015652515, 0.015642205, 0.015630718, 0.015620422, 0.01560895, + 0.015598644, 0.015587165, 0.015576884, 0.015565443, 0.015555173, 0.015543742, 0.015533477, 0.015522051, + 0.015511802, 0.015500415, 0.015490214, 0.015478839, 0.015468623, 0.015457265, 0.015447077, 0.015435749, + 0.015425593, 0.01541429, 0.015404135, 0.015392832, 0.015382693, 0.015371395, 0.015361263, 0.015349996, 0.015339901, + 0.015328669, 0.015318581, 0.015307362, 0.015297289, 0.015286089, 0.015276043, 0.015264848, 0.015254802, + 0.015243877, 0.015234088, 0.01522315, 0.015213341, 0.015202372, 0.015192537, 0.015181563, 0.015171703, 0.015160711, + 0.015150854, 0.015139866, 0.015129996, 0.015119008, 0.015109165, 0.015098196, 0.015088351, 0.015077379, + 0.015067531, 0.015056561, 0.015046714, 0.015035756, 0.015025918, 0.015014962, 0.015005129, 0.014994193, + 0.014984385, 0.014973474, 0.014963669, 0.014952754, 0.01494296, 0.014932065, 0.014922291, 0.014911411, 0.014901658, + 0.014890813, 0.014881077, 0.014870233, 0.01486048, 0.014849652, 0.014839939, 0.014829142, 0.014819457, 0.014808675, + 0.014799001, 0.014788229, 0.014778558, 0.014767813, 0.014758173, 0.014747441, 0.014737804, 0.014727086, + 0.014717444, 0.014706726, 0.014697121, 0.014686437, 0.014676854, 0.014666189, 0.014656613, 0.01464596, 0.014636402, + 0.014625776, 0.014616233, 0.014605618, 0.014596338, 0.014585967, 0.014576648, 0.014566247, 0.014556906, + 0.014546487, 0.01453714, 0.014526705, 0.014517337, 0.014506906, 0.014497546, 0.014487129, 0.014477783, 0.01446736, + 0.014458004, 0.014447578, 0.01443821, 0.014427803, 0.014418464, 0.014408065, 0.014398719, 0.014388318, 0.014378981, + 0.014368599, 0.014359269, 0.01434889, 0.01433959, 0.014329243, 0.014319943, 0.014309617, 0.014300335, 0.014290002, + 0.01428072, 0.014270407, 0.014261157, 0.014250874, 0.014241624, 0.014231334, 0.014222105, 0.014211828, 0.014202585, + 0.014192321, 0.0141831, 0.014172846, 0.014163648, 0.01415366, 0.014144699, 0.014134705, 0.014125734, 0.01411572, + 0.014106724, 0.014096691, 0.014087673, 0.014077615, 0.014068589, 0.014058541, 0.014049516, 0.014039459, + 0.014030418, 0.014020358, 0.014011336, 0.014001301, 0.013992291, 0.013982255, 0.013973221, 0.013963181, + 0.013954165, 0.013944147, 0.013935155, 0.01392516, 0.013916183, 0.013906204, 0.013897237, 0.013887251, 0.013878278, + 0.013868313, 0.013859347, 0.013849387, 0.013840448, 0.013830502, 0.01382156, 0.013811631, 0.01380272, 0.01379282, + 0.013783934, 0.013774052, 0.013765177, 0.013755323, 0.013746453, 0.013736594, 0.013727743, 0.013717912, + 0.013709072, 0.013699241, 0.013690402, 0.013680588, 0.013671772, 0.013661986, 0.013653185, 0.013643398, + 0.013634831, 0.01362527, 0.01361669, 0.013607125, 0.013598531, 0.013588941, 0.013580325, 0.013570731, 0.013562097, + 0.013552492, 0.013543856, 0.013534248, 0.013525621, 0.013516014, 0.013507377, 0.013497777, 0.013489138, + 0.013479538, 0.0134709, 0.013461295, 0.013452673, 0.013443106, 0.013434501, 0.013424939, 0.013416331, 0.013406778, + 0.0133982, 0.013388671, 0.013380103, 0.013370576, 0.013362011, 0.013352502, 0.013343953, 0.013334463, 0.013325913, + 0.013316411, 0.013307876, 0.013298396, 0.013289867, 0.013280408, 0.013271905, 0.013262465, 0.013253977, + 0.013244543, 0.013236063, 0.013226661, 0.013218205, 0.013208807, 0.013200353, 0.013190967, 0.013182526, + 0.013173161, 0.013164739, 0.013155389, 0.013146983, 0.013137643, 0.013129247, 0.013119931, 0.013111552, + 0.013102259, 0.01309389, 0.013084578, 0.013076203, 0.013066932, 0.0130586, 0.013049339, 0.013041013, 0.013031783, + 0.013023464, 0.01301423, 0.013005937, 0.012996727, 0.012988431, 0.012979227, 0.012970956, 0.012961788, 0.012953541, + 0.012944381, 0.012936367, 0.012927421, 0.012919381, 0.01291042, 0.01290236, 0.012893393, 0.012885323, 0.012876339, + 0.01286826, 0.012859261, 0.012851159, 0.012842161, 0.012834068, 0.012825067, 0.012816973, 0.012807971, 0.012799871, + 0.012790885, 0.012782801, 0.012773824, 0.012765743, 0.012756778, 0.012748696, 0.012739716, 0.012731649, + 0.012722696, 0.012714641, 0.012705702, 0.012697646, 0.012688711, 0.012680682, 0.012671776, 0.012663747, + 0.012654838, 0.012646821, 0.012637935, 0.012629934, 0.012621058, 0.012613076, 0.012604224, 0.012596244, + 0.012587382, 0.012579407, 0.012570571, 0.012562609, 0.012553791, 0.012545855, 0.012537049, 0.012529122, + 0.012520333, 0.012512411, 0.012503625, 0.01249572, 0.012486955, 0.012479065, 0.012470321, 0.012462446, 0.012453713, + 0.01244584, 0.012437119, 0.012429262, 0.01242055, 0.012412716, 0.012404026, 0.012396201, 0.012387525, 0.012379934, + 0.01237147, 0.012363848, 0.012355367, 0.012347727, 0.012339234, 0.012331577, 0.012323061, 0.012315399, 0.012306888, + 0.012299214, 0.012290689, 0.012283017, 0.012274498, 0.012266815, 0.012258293, 0.012250613, 0.012242104, + 0.012234446, 0.012225942, 0.012218273, 0.012209771, 0.012202112, 0.012193622, 0.012185957, 0.012177467, + 0.012169824, 0.012161346, 0.012153718, 0.012145269, 0.012137649, 0.012129207, 0.012121607, 0.012113182, + 0.012105577, 0.012097151, 0.012089554, 0.012081141, 0.012073567, 0.012065168, 0.012057599, 0.012049219, + 0.012041654, 0.012033267, 0.012025709, 0.012017348, 0.012009822, 0.012001482, 0.011993954, 0.011985622, + 0.011978109, 0.011969793, 0.011962291, 0.011953983, 0.011946491, 0.0119382, 0.01193073, 0.011922454, 0.011915189, + 0.011907114, 0.011899843, 0.011891751, 0.011884461, 0.011876362, 0.011869053, 0.011860939, 0.011853621, + 0.011845499, 0.011838178, 0.011830049, 0.011822701, 0.01181456, 0.011807224, 0.011799091, 0.011791747, 0.011783619, + 0.011776295, 0.011768184, 0.011760857, 0.01175274, 0.011745424, 0.011737325, 0.011730013, 0.011721921, 0.01171461, + 0.011706514, 0.011699216, 0.011691142, 0.011683849, 0.011675783, 0.011668507, 0.011660452, 0.011653193, + 0.011645163, 0.011637904, 0.011629874, 0.011622633, 0.011614625, 0.011607389, 0.011599382, 0.011592166, + 0.011584172, 0.01157695, 0.011568973, 0.011561758, 0.01155378, 0.011546598, 0.011538657, 0.011531691, 0.011523944, + 0.011516955, 0.011509188, 0.011502172, 0.011494387, 0.011487361, 0.011479567, 0.011472529, 0.011464726, + 0.011457677, 0.011449857, 0.011442788, 0.011434978, 0.011427935, 0.011420121, 0.01141306, 0.01140526, 0.011398215, + 0.011390413, 0.011383363, 0.01137558, 0.011368541, 0.011360755, 0.01135373, 0.011345964, 0.011338931, 0.011331152, + 0.011324126, 0.011316364, 0.011309346, 0.011301597, 0.011294594, 0.011286855, 0.011279866, 0.011272149, + 0.011265162, 0.011257441, 0.011250468, 0.011242772, 0.011235802, 0.0112279, 0.011220763, 0.011212919, 0.011206047, + 0.011198441, 0.01119156, 0.01118395, 0.011177063, 0.011169455, 0.011162579, 0.011154977, 0.011148103, 0.011140518, + 0.01113366, 0.011126081, 0.011119226, 0.011111649, 0.011104796, 0.011097234, 0.011090392, 0.011082844, 0.011076019, + 0.011068476, 0.011061654, 0.011054128, 0.011047318, 0.01103979, 0.011032972, 0.011025455, 0.011018659, 0.011011174, + 0.011004403, 0.010996925, 0.010990161, 0.010982704, 0.010975949, 0.010968495, 0.010961743, 0.010954279, + 0.010947534, 0.010940108, 0.010933369, 0.010925935, 0.010919217, 0.010911814, 0.010905321, 0.010898112, + 0.010891599, 0.010884369, 0.010877806, 0.010870562, 0.010864002, 0.010856739, 0.010850161, 0.010842892, + 0.010836314, 0.010829041, 0.010822453, 0.01081517, 0.010808569, 0.010801287, 0.010794699, 0.010787433, 0.010780841, + 0.010773577, 0.010767, 0.010759734, 0.010753144, 0.010745876, 0.010739297, 0.010732046, 0.010725478, 0.010718237, + 0.010711683, 0.010704457, 0.010697904, 0.010690686, 0.010684141, 0.010676933, 0.010670398, 0.010663197, + 0.010656672, 0.01064948, 0.01064316, 0.010636164, 0.01062982, 0.010622789, 0.010616419, 0.010609182, 0.010602613, + 0.0105954, 0.010588853, 0.010581654, 0.010575132, 0.010567963, 0.010561466, 0.010554317, 0.010547821, 0.010540685, + 0.010534217, 0.010527097, 0.010520643, 0.010513547, 0.010507104, 0.010500025, 0.010493603, 0.010486524, + 0.010480105, 0.010473056, 0.010466655, 0.010459613, 0.010453232, 0.0104462, 0.01043981, 0.010432797, 0.010426439, + 0.010419445, 0.010413088, 0.010406103, 0.010399963, 0.010393158, 0.01038698, 0.01038017, 0.010373984, 0.010367144, + 0.010360939, 0.010354106, 0.010347898, 0.01034104, 0.010334813, 0.010327964, 0.010321732, 0.010314861, 0.010308627, + 0.010301772, 0.01029554, 0.010288681, 0.010282448, 0.010275591, 0.010269366, 0.010262522, 0.010256302, 0.010249461, + 0.010243241, 0.010236401, 0.01023019, 0.01022336, 0.010217156, 0.010210343, 0.010204149, 0.010197337, 0.010191141, + 0.010184143, 0.010177976, 0.010171196, 0.010165043, 0.010158286, 0.010152142, 0.010145382, 0.010139226, + 0.010132464, 0.010126319, 0.010119577, 0.010113449, 0.010106719, 0.010100594, 0.010093868, 0.010087757, + 0.010081055, 0.010074956, 0.010068264, 0.010062172, 0.01005548, 0.010049385, 0.010042692, 0.010036604, 0.010029935, + 0.010023876, 0.010017219, 0.010011151, 0.010004495, 0.0099984435, 0.009991806, 0.0099857654, 0.0099791447, + 0.0099733053, 0.0099668633, 0.0099609941, 0.0099545214, 0.0099486364, 0.0099421572, 0.0099362461, 0.0099297417, + 0.0099238325, 0.0099173365, 0.0099114189, 0.0099049285, 0.009899009, 0.0098924926, 0.0098865628, 0.0098800529, + 0.0098741222, 0.0098676151, 0.0098616909, 0.0098549845, 0.0098488713, 0.0098422086, 0.0098361429, 0.0098295258, + 0.0098234816, 0.0098168738, 0.0098108631, 0.0098042889, 0.0097982986, 0.0097917616, 0.0097860098, 0.0097796796, + 0.0097739054, 0.0097675556, 0.0097617693, 0.0097554233, 0.0097496323, 0.0097432705, 0.0097374739, 0.0097311111, + 0.0097252922, 0.0097189099, 0.009713091, 0.009706717, 0.0097008981, 0.0096945306, 0.0096887294, 0.0096823713, + 0.009676571, 0.0096702147, 0.0096644079, 0.0096580517, 0.0096522486, 0.0096459081, 0.0096401237, 0.0096337907, + 0.0096280118, 0.0096216872, 0.0096161095, 0.0096099628, 0.009604346, 0.0095981723, 0.009592535, 0.009586147, + 0.009580316, 0.009573957, 0.0095681502, 0.0095618181, 0.0095560271, 0.0095496932, 0.0095439153, 0.009537613, + 0.0095318574, 0.0095255692, 0.0095198266, 0.0095135644, 0.0095078433, 0.0095015857, 0.00949586, 0.009489608, + 0.009483899, 0.0094776656, 0.0094719706, 0.009465755, 0.0094600767, 0.0094538722, 0.0094483886, 0.0094423685, + 0.0094368709, 0.0094308313, 0.0094253048, 0.0094192466, 0.0094137015, 0.0094076265, 0.0094020599, 0.0093959691, + 0.0093904091, 0.0093843332, 0.0093787741, 0.0093726898, 0.009367126, 0.0093610492, 0.0093554854, 0.0093492093, + 0.0093434555, 0.0093372138, 0.0093315151, 0.0093253087, 0.0093196305, 0.0093134567, 0.0093078073, 0.0093016559, + 0.0092962151, 0.0092902659, 0.009284813, 0.0092788478, 0.009273381, 0.0092674103, 0.0092619406, 0.0092559634, + 0.0092504863, 0.009244509, 0.0092390301, 0.00923305, 0.009227572, 0.0092216041, 0.0092161363, 0.0092101656, + 0.0092046885, 0.0091987159, 0.0091932518, 0.0091872839, 0.0091818059, 0.0091758482, 0.0091703888, 0.0091644386, + 0.0091591766, 0.0091534033, 0.0091481004, 0.0091421045, 0.0091366097, 0.0091306455, 0.0091251684, 0.009119207, + 0.0091137337, 0.0091077881, 0.0091023296, 0.0090963924, 0.0090909442, 0.0090850359, 0.0090796184, 0.009073711, + 0.009068287, 0.0090623936, 0.0090569928, 0.0090511125, 0.0090457108, 0.0090398416, 0.0090344539, 0.009028594, + 0.0090232072, 0.0090173585, 0.0090121841, 0.0090065254, 0.0090013249, 0.0089956382, 0.0089904182, 0.0089847222, + 0.0089794807, 0.0089737708, 0.0089685293, 0.0089628035, 0.0089575369, 0.0089516146, 0.0089461775, 0.0089402888, + 0.0089348704, 0.0089290077, 0.0089236293, 0.0089177974, 0.0089124311, 0.0089066168, 0.008901272, 0.0088954791, + 0.0088903336, 0.0088847214, 0.0088795759, 0.0088739628, 0.0088687865, 0.008863152, 0.0088579673, 0.0088523291, + 0.0088471388, 0.0088414941, 0.0088363085, 0.0088306665, 0.0088254707, 0.0088198213, 0.0088146124, 0.0088089639, + 0.0088037662, 0.0087981271, 0.0087929424, 0.0087873079, 0.0087821083, 0.0087762801, 0.0087709194, 0.0087651405, + 0.0087600127, 0.0087544331, 0.008749282, 0.0087437024, 0.0087385643, 0.0087329876, 0.0087278504, 0.0087222718, + 0.0087171262, 0.0087115522, 0.0087064179, 0.0087008504, 0.008695717, 0.008690143, 0.0086850105, 0.0086794579, + 0.0086743338, 0.0086687813, 0.0086636618, 0.0086581158, 0.0086530019, 0.0086474605, 0.0086425366, 0.0086371712, + 0.0086322129, 0.0086266352, 0.0086214934, 0.0086159352, 0.0086108055, 0.008605266, 0.008600153, 0.00859462, + 0.0085895164, 0.0085840076, 0.0085789161, 0.0085734073, 0.0085683195, 0.0085628247, 0.0085577536, 0.0085522737, + 0.0085472101, 0.0085417479, 0.0085368846, 0.0085315956, 0.0085267061, 0.0085213957, 0.0085164951, 0.0085111717, + 0.0085062366, 0.0085008945, 0.008495952, 0.0084905922, 0.0084856441, 0.0084801009, 0.0084749833, 0.008469482, + 0.0084643839, 0.0084589012, 0.0084538339, 0.0084483745, 0.0084433295, 0.0084378906, 0.0084328558, 0.0084274327, + 0.0084226066, 0.008417381, 0.0084125353, 0.0084072854, 0.0084024202, 0.0083971592, 0.0083922911, 0.0083870171, + 0.0083821323, 0.0083768545, 0.0083719688, 0.0083666956, 0.0083618173, 0.0083565516, 0.0083516706, 0.008346213, + 0.0083411699, 0.0083357561, 0.0083307298, 0.0083253281, 0.0083205132, 0.0083153136, 0.0083104959, 0.0083053047, + 0.008300486, 0.0082952753, 0.0082904389, 0.00828523, 0.0082804058, 0.0082752025, 0.008270368, 0.0082651554, + 0.0082603227, 0.0082551176, 0.0082502821, 0.0082450733, 0.008240249, 0.0082350485, 0.0082302196, 0.0082250247, + 0.0082203876, 0.0082151834, 0.0082103554, 0.0082051521, 0.0082003232, 0.0081951432, 0.0081903255, 0.0081851389, + 0.0081803193, 0.0081751337, 0.0081703244, 0.0081651602, 0.008160363, 0.0081552109, 0.0081504276, 0.008145282, + 0.0081404988, 0.0081353588, 0.0081307665, 0.0081258016, 0.0081211776, 0.0081161931, 0.0081115505, 0.0081065437, + 0.0081018787, 0.0080966726, 0.0080918381, 0.0080866544, 0.0080818348, 0.0080766808, 0.0080718957, 0.0080667576, + 0.008061978, 0.0080568641, 0.0080520967, 0.0080469865, 0.0080422405, 0.0080371611, 0.0080326125, 0.0080276988, + 0.0080231084, 0.0080181705, 0.0080135809, 0.0080086458, 0.0080040311, 0.0079990681, 0.0079944516, 0.0079893218, + 0.0079845423, 0.0079794247, 0.0079746572, 0.0079695685, 0.0079648308, 0.00795977, 0.0079550557, 0.00795002, + 0.0079455059, 0.0079406509, 0.0079361172, 0.0079312362, 0.0079266811, 0.0079217916, 0.0079172263, 0.0079123359, + 0.0079077734, 0.0079028737, 0.0078983102, 0.007893417, 0.0078888359, 0.0078837518, 0.0078790197, 0.0078739766, + 0.0078692678, 0.0078642508, 0.0078597413, 0.007854904, 0.0078503899, 0.0078455461, 0.007841018, 0.0078361742, + 0.0078316461, 0.0078267977, 0.0078222668, 0.0078174174, 0.0078128884, 0.0078080432, 0.0078035053, 0.0077986489, + 0.0077941096, 0.007789264, 0.0077847298, 0.0077797165, 0.0077752182, 0.0077704084, 0.007765905, 0.007761097, + 0.007756596, 0.007751782, 0.007747272, 0.0077424659, 0.0077379653, 0.0077331527, 0.0077286535, 0.0077238572, + 0.0077193617, 0.0077145654, 0.0077100745, 0.007705281, 0.007700969, 0.0076963445, 0.0076920041, 0.0076871794, + 0.0076826573, 0.0076778373, 0.0076733278, 0.0076685306, 0.0076640332, 0.007659249, 0.0076547647, 0.0076499912, + 0.0076455162, 0.0076407548, 0.007636284, 0.0076315319, 0.0076270751, 0.0076223314, 0.0076180594, 0.007613482, + 0.007609183, 0.0076045888, 0.0076002595, 0.0075956355, 0.0075912932, 0.0075864955, 0.0075819963, 0.0075772288, + 0.007572752, 0.007567999, 0.0075635375, 0.0075588017, 0.0075543546, 0.0075496491, 0.0075454079, 0.0075408719, + 0.0075365934, 0.0075320313, 0.0075277449, 0.0075231791, 0.0075188773, 0.0075142896, 0.0075099785, 0.0075052194, + 0.0075007351, 0.0074959961, 0.0074915458, 0.0074868361, 0.0074824039, 0.0074777142, 0.0074734832, 0.0074689765, + 0.0074647297, 0.0074602128, 0.0074559534, 0.0074514248, 0.0074471566, 0.0074426164, 0.0074383416, 0.0074338056, + 0.0074295304, 0.0074249892, 0.0074207145, 0.0074159978, 0.0074115493, 0.0074068676, 0.0074026361, 0.007398142, + 0.007393904, 0.0073894048, 0.0073851529, 0.0073806457, 0.0073763975, 0.0073718908, 0.0073676398, 0.007363141, + 0.0073588938, 0.0073543987, 0.007350157, 0.0073456583, 0.0073414058, 0.0073367376, 0.0073324996, 0.0073280176, + 0.0073237908, 0.0073193181, 0.0073150876, 0.0073106186, 0.0073063956, 0.0073019257, 0.0072977026, 0.0072932364, + 0.0072890199, 0.0072845612, 0.0072803474, 0.0072759041, 0.0072716977, 0.0072672497, 0.0072632055, 0.0072587398, + 0.0072545232, 0.0072500701, 0.0072458582, 0.0072414172, 0.0072372113, 0.0072327768, 0.0072285789, 0.0072241514, + 0.0072199577, 0.0072155367, 0.007211355, 0.0072069471, 0.0072029377, 0.0071986914, 0.0071946564, 0.0071903826, + 0.0071863323, 0.0071818735, 0.0071776528, 0.0071732146, 0.0071690087, 0.0071645859, 0.0071603968, 0.0071559893, + 0.0071518137, 0.0071474263, 0.0071432572, 0.0071388711, 0.0071348883, 0.0071306787, 0.0071266792, 0.0071224477, + 0.007118423, 0.0071141766, 0.0071101417, 0.007105717, 0.0071015144, 0.0070971153, 0.0070929406, 0.007088555, + 0.0070843929, 0.0070800292, 0.0070760502, 0.0070718527, 0.0070678582, 0.0070636384, 0.0070596277, 0.0070554116, + 0.0070513966, 0.0070471694, 0.007043147, 0.0070387493, 0.0070345756, 0.0070302086, 0.0070260549, 0.0070217112, + 0.0070175752, 0.0070132492, 0.0070093037, 0.007005149, 0.0070011909, 0.0069970298, 0.0069930591, 0.0069888779, + 0.0069848932, 0.0069807158, 0.0069767321, 0.0069723842, 0.0069682449, 0.0069639268, 0.0069598202, 0.0069555244, + 0.0069515994, 0.0069474825, 0.0069435472, 0.006939414, 0.0069354684, 0.0069313217, 0.0069273612, 0.0069232197, + 0.0069192774, 0.0069151367, 0.0069111721, 0.0069068568, 0.0069027445, 0.0068984665, 0.0068945549, 0.0068904492, + 0.0068865274, 0.0068824249, 0.0068785008, 0.0068743969, 0.0068704737, 0.0068663638, 0.0068624425, 0.0068583451, + 0.0068544177, 0.006850305, 0.0068463702, 0.0068421001, 0.0068381843, 0.006834087, 0.0068301675, 0.0068260785, + 0.0068221702, 0.0068180892, 0.0068141771, 0.0068100877, 0.0068061729, 0.0068020886, 0.0067981747, 0.0067940904, + 0.0067901826, 0.0067861089, 0.0067823729, 0.006778291, 0.006774378, 0.0067703067, 0.0067664045, 0.0067623332, + 0.0067584333, 0.0067543741, 0.0067504742, 0.0067464127, 0.0067425198, 0.0067384741, 0.0067347572, 0.0067308643, + 0.0067271213, 0.0067232074, 0.0067194449, 0.0067153545, 0.0067114234, 0.0067073405, 0.0067034345, 0.0066993763, + 0.0066954847, 0.0066914507, 0.0066875666, 0.0066835289, 0.0066798138, 0.006675933, 0.0066722007, 0.0066683097, + 0.0066645639, 0.006660495, 0.0066565857, 0.0066525382, 0.0066486434, 0.0066446126, 0.0066407421, 0.0066367304, + 0.0066328733, 0.0066288775, 0.0066251932, 0.0066213561, 0.0066176513, 0.0066137933, 0.0066100773, 0.0066062156, + 0.0066024885, 0.0065984461, 0.0065945596, 0.006590548, 0.0065866942, 0.0065827151, 0.006579034, 0.0065752054, + 0.0065715122, 0.0065676742, 0.0065639601, 0.0065601082, 0.0065563903, 0.006552537, 0.006548814, 0.0065447954, + 0.0065409238, 0.0065369271, 0.006533077, 0.0065291091, 0.0065254434, 0.0065216511, 0.0065179849, 0.0065141837, + 0.006510498, 0.0065066749, 0.0065029757, 0.0064991526, 0.0064954557, 0.0064914729, 0.006487634, 0.006483681, + 0.0064800219, 0.0064762346, 0.0064725643, 0.0064687729, 0.0064651049, 0.0064613135, 0.0064576389, 0.0064538391, + 0.0064501609, 0.0064463676, 0.0064426893, 0.0064387345, 0.0064350762, 0.0064312983, 0.0064276406, 0.0064238687, + 0.0064202002, 0.0064164205, 0.006412759, 0.0064089792, 0.006405314, 0.0064015435, 0.0063978801, 0.0063941074, + 0.0063904463, 0.0063865208, 0.0063828877, 0.0063791443, 0.0063755079, 0.0063717626, 0.0063681188, 0.0063643656, + 0.0063607246, 0.0063569862, 0.0063533513, 0.0063496069, 0.0063459789, 0.0063422546, 0.0063387849, 0.0063350392, + 0.0063314019, 0.0063276677, 0.0063240291, 0.0063202921, 0.0063166572, 0.0063129319, 0.0063093151, 0.0063055982, + 0.00630198, 0.0062982687, 0.0062948135, 0.0062912544, 0.0062877778, 0.0062840362, 0.0062803971, 0.0062766732, + 0.0062730433, 0.006269325, 0.0062656989, 0.0062619885, 0.0062583773, 0.0062546893, 0.006251256, 0.006247717, + 0.006244251, 0.0062405271, 0.0062369048, 0.0062332004, 0.0062295883, 0.0062259017, 0.0062223068, 0.0062186234, + 0.0062150201, 0.006211346, 0.006207929, 0.0062044202, 0.006200979, 0.0061974535, 0.0061939945, 0.0061902869, + 0.0061866683, 0.006182977, 0.006179377, 0.0061757108, 0.0061721317, 0.0061684912, 0.0061650896, 0.0061615943, + 0.0061581628, 0.0061546471, 0.0061511979, 0.006147516, 0.0061439238, 0.0061402707, 0.0061366935, 0.0061330497, + 0.0061296425, 0.0061261654, 0.0061227521, 0.0061192638, 0.0061158352, 0.0061123255, 0.0061088791, 0.0061053704, + 0.0061019324, 0.0060982662, 0.0060946713, 0.0060910308, 0.0060876203, 0.0060841376, 0.0060807182, 0.0060772342, + 0.0060738088, 0.0060703172, 0.0060668858, 0.0060633942, 0.0060599563, 0.0060562994, 0.0060527157, 0.0060490831, + 0.006045674, 0.0060422099, 0.0060387994, 0.0060353386, 0.0060319356, 0.006028471, 0.0060250564, 0.0060215858, + 0.0060181692, 0.006014538, 0.006010972, 0.0060073705, 0.0060039959, 0.0060005765, 0.0059971996, 0.0059937672, + 0.0059903804, 0.0059869452, 0.0059835534, 0.0059801145, 0.0059767258, 0.0059731323, 0.0059697502, 0.0059663234, + 0.0059629432, 0.0059595183, 0.0059561366, 0.0059527112, 0.0059493249, 0.0059459028, 0.0059425286, 0.0059391093, + 0.0059357323, 0.0059323162, 0.0059290999, 0.0059256731, 0.0059222816, 0.0059188567, 0.0059154741, 0.0059120581, + 0.0059086764, 0.0059052566, 0.0059018824, 0.0058984719, 0.0058952505, 0.0058919881, 0.0058887433, 0.0058853053, + 0.0058819083, 0.0058784815, 0.0058750915, 0.0058716754, 0.0058683008, 0.0058649029, 0.0058615427, 0.0058581606, + 0.005854961, 0.0058515635, 0.0058481921, 0.0058448059, 0.0058414517, 0.0058380705, 0.0058347192, 0.0058313417, + 0.0058279941, 0.005824632, 0.0058214469, 0.0058182324, 0.0058150273, 0.0058116349, 0.0058082729, 0.0058048959, + 0.0058015427, 0.0057981778, 0.0057948413, 0.0057914923, 0.0057881656, 0.005784825, 0.0057816543, 0.0057784538, + 0.0057752626, 0.0057719019, 0.0057685617, 0.0057652108, 0.005761886, 0.0057585523, 0.0057552336, 0.0057519129, + 0.0057487604, 0.0057455804, 0.0057424037, 0.005739213, 0.0057360241, 0.0057326672, 0.005729327, 0.0057259924, + 0.0057226834, 0.0057193707, 0.0057162172, 0.005713047, 0.0057098772, 0.005706693, 0.0057035103, 0.0057003158, + 0.005697119, 0.005693763, 0.0056904275, 0.0056871022, 0.0056839366, 0.005680766, 0.0056775901, 0.0056744064, + 0.0056712199, 0.0056680348, 0.0056648455, 0.0056615071, 0.0056581791, 0.005654864, 0.0056515611, 0.0056482712, + 0.0056451363, 0.0056420006, 0.0056388546, 0.0056357109, 0.0056325546, 0.0056294003, 0.0056262412, 0.0056229397, + 0.0056196395, 0.0056163548, 0.0056132171, 0.0056100851, 0.005606947, 0.0056038187, 0.0056006778, 0.0055975434, + 0.0055943914, 0.0055911005, 0.0055878065, 0.0055845375, 0.0055814255, 0.0055783265, 0.0055752019, 0.0055720857, + 0.0055689542, 0.0055658398, 0.0055627041, 0.0055595851, 0.0055564488, 0.0055531845, 0.0055500637, 0.0055469582, + 0.0055438299, 0.0055407239, 0.0055375975, 0.0055344887, 0.0055313585, 0.0055282502, 0.0055251219, 0.005521867, + 0.0055187484, 0.0055156569, 0.0055125444, 0.0055094515, 0.0055063297, 0.0055032428, 0.0055001345, 0.0054970528, + 0.0054939413, 0.0054908558, 0.0054878937, 0.0054848008, 0.0054816781, 0.005478574, 0.0054754457, 0.0054723565, + 0.0054692361, 0.0054661478, 0.0054630334, 0.005459961, 0.0054570031, 0.0054539125, 0.0054507866, 0.0054477002, + 0.0054445844, 0.0054415138, 0.0054384125, 0.0054353513, 0.0054322518, 0.0054291901, 0.0054262416, 0.0054231696, + 0.0054200613, 0.0054169996, 0.0054139006, 0.0054108477, 0.0054077627, 0.0054047168, 0.0054016281, 0.0053985901, + 0.0053956606, 0.0053926106, 0.0053895232, 0.0053864834, 0.0053834054, 0.0053803804, 0.0053773141, 0.0053742952, + 0.0053712325, 0.005368222, 0.0053653121, 0.0053624338, 0.0053595048, 0.0053564725, 0.0053533907, 0.0053503569, + 0.0053472784, 0.0053442637, 0.0053412085, 0.0053382055, 0.0053352923, 0.005332428, 0.0053295069, 0.0053264787, + 0.0053234068, 0.0053203977, 0.0053173397, 0.0053143413, 0.0053114356, 0.0053085769, 0.0053056534, 0.0053027794, + 0.0052998406, 0.0052968133, 0.0052937348, 0.0052907201, 0.0052876542, 0.0052846586, 0.005281759, 0.0052789091, + 0.0052759885, 0.0052731275, 0.0052701985, 0.0052671861, 0.0052641174, 0.0052611176, 0.005258067, 0.0052550863, + 0.0052521895, 0.0052493508, 0.005246446, 0.0052436055, 0.0052406914, 0.0052376962, 0.0052346415, 0.0052316622, + 0.0052287695, 0.0052259373, 0.0052230302, 0.0052201897, 0.0052172798, 0.0052144378, 0.0052115135, 0.0052085193, + 0.0052054706, 0.0052025006, 0.0051996121, 0.0051967963, 0.0051938943, 0.0051910616, 0.0051881587, 0.0051853289, + 0.0051824204, 0.005179442, 0.0051764031, 0.0051734531, 0.0051705833, 0.0051677912, 0.0051649068, 0.0051620984, + 0.0051592123, 0.0051564034, 0.0051535093, 0.0051505477, 0.0051476625, 0.0051448564, 0.0051419702, 0.0051391646, + 0.0051362733, 0.0051334659, 0.0051305732, 0.0051277643, 0.0051248674, 0.0051219133, 0.0051190341, 0.0051162424, + 0.0051133619, 0.0051105702, 0.0051076892, 0.0051049003, 0.0051020221, 0.005099087, 0.0050960816, 0.0050931736, + 0.0050903303, 0.0050875815, 0.0050847353, 0.0050819721, 0.0050791171, 0.0050763534, 0.0050734957, 0.0050705899, + 0.0050677476, 0.0050650015, 0.0050621619, 0.0050594145, 0.005056568, 0.0050538196, 0.0050509777, 0.0050482312, + 0.0050453888, 0.0050425008, 0.0050396672, 0.005036931, 0.0050340942, 0.0050313585, 0.0050285291, 0.0050258003, + 0.0050229654, 0.0050202366, 0.0050175502, 0.0050148051, 0.0050119571, 0.0050092158, 0.0050063781, 0.0050036428, + 0.0050008046, 0.0049980744, 0.0049953833, 0.004992641, 0.004989801, 0.0049870708, 0.004984234, 0.0049815089, + 0.0049786726, 0.004975948, 0.0049731229, 0.004970416, 0.0049677407, 0.004965018, 0.0049621928, 0.0049594766, + 0.0049566487, 0.0049539353, 0.0049511194, 0.0049484251, 0.0049457601, 0.0049431906, 0.0049404954, 0.0049377684, + 0.0049349321, 0.004932215, 0.0049293838, 0.0049266736, 0.0049238573, 0.0049211597, 0.0049184915, 0.0049157902, + 0.0049129785, 0.0049102851, 0.0049074725, 0.0049047889, 0.0049019926, 0.0048993169, 0.0048966627, 0.0048941211, + 0.0048914556, 0.0048887609, 0.004885945, 0.0048832623, 0.004880467, 0.0048777899, 0.0048751333, 0.0048725973, + 0.0048699295, 0.0048672385, 0.0048644291, 0.0048617544, 0.0048589599, 0.0048562968, 0.0048535164, 0.0048508663, + 0.0048482288, 0.0048457119, 0.0048430557, 0.0048403814, 0.0048375912, 0.0048349351, 0.0048321555, 0.0048295134, + 0.0048268847, 0.0048243767, 0.0048217336, 0.0048190737, 0.0048162863, 0.0048136422, 0.0048108762, 0.0048082503, + 0.0048056343, 0.0048031462, 0.0048005129, 0.0047980109, 0.0047953669, 0.004792707, 0.0047899177, 0.004787277, + 0.0047846506, 0.0047821593, 0.0047795251, 0.0047770208, 0.0047743712, 0.0047717183, 0.0047689374, 0.0047663129, + 0.0047636898, 0.0047611953, 0.0047585573, 0.0047560595, 0.0047534159, 0.0047509093, 0.0047482578, 0.0047456101, + 0.0047428305, 0.0047402089, 0.0047375956, 0.0047351206, 0.004732491, 0.0047300016, 0.0047273692, 0.0047247456, + 0.0047219782, 0.0047193705, 0.0047167656, 0.0047143009, 0.004711682, 0.0047092112, 0.0047065918, 0.004703973, + 0.0047012158, 0.0046986281, 0.0046960381, 0.004693599, 0.0046910015, 0.0046885461, 0.0046859365, 0.0046834736, + 0.0046808538, 0.0046782517, 0.0046756458, 0.0046731979, 0.0046705925, 0.0046681343, 0.0046655182, 0.0046630614, + 0.0046604476, 0.0046578529, 0.0046552601, 0.0046528191, 0.0046502114, 0.0046477597, 0.0046451525, 0.0046427092, + 0.0046401024, 0.0046375175, 0.0046349252, 0.0046324884, 0.0046298886, 0.0046274555, 0.0046248576, 0.0046224208, + 0.0046198256, 0.0046172533, 0.0046146689, 0.0046122507, 0.0046096668, 0.0046072458, 0.0046046642, 0.0046022455, + 0.004599656, 0.0045972299, 0.0045947763, 0.0045923432, 0.0045897462, 0.0045873169, 0.0045847204, 0.0045822952, + 0.0045797043, 0.0045772791, 0.0045748209, 0.0045723883, 0.0045697899, 0.0045673647, 0.0045647728, 0.0045623537, + 0.0045597684, 0.0045573548, 0.0045549027, 0.0045524812, 0.0045498936, 0.0045474786, 0.0045448928, 0.0045424798, + 0.0045398972, 0.0045374949, 0.0045350562, 0.0045326469, 0.0045300652, 0.0045276633, 0.0045250901, 0.0045226966, + 0.0045201266, 0.0045177364, 0.0045153038, 0.0045129051, 0.0045103338, 0.0045079435, 0.0045053796, 0.0045030033, + 0.0045004468, 0.0044980743, 0.004495658, 0.0044932775, 0.0044907187, 0.0044883462, 0.0044857929, 0.0044834288, + 0.0044808881, 0.0044785282, 0.0044761244, 0.0044737631, 0.0044712187, 0.0044688606, 0.0044663199, 0.004463973, + 0.0044614417, 0.0044590989, 0.0044567059, 0.0044544889, 0.0044520758, 0.0044497075, 0.0044471603, 0.0044448054, + 0.0044422667, 0.0044399193, 0.0044375206, 0.0044353055, 0.004432891, 0.004430532, 0.0044279895, 0.0044256407, + 0.0044231033, 0.0044207629, 0.0044183675, 0.004416157, 0.0044137463, 0.0044113924, 0.0044088499, 0.0044065095, + 0.004404116, 0.0044019059, 0.0043994919, 0.0043972675, 0.0043948418, 0.0043924805, 0.0043899347, 0.0043875924, + 0.0043851952, 0.0043829889, 0.0043805731, 0.0043783495, 0.0043759272, 0.0043735676, 0.0043710158, 0.0043686712, + 0.0043662717, 0.0043640691, 0.0043616625, 0.0043594497, 0.0043570306, 0.0043546841, 0.0043521454, 0.0043498171, + 0.0043474291, 0.0043452345, 0.0043428321, 0.0043405043, 0.0043379809, 0.0043356679, 0.0043331571, 0.0043308595, + 0.0043284963, 0.0043263347, 0.0043239645, 0.0043216641, 0.0043191654, 0.0043168808, 0.0043145246, 0.0043123686, + 0.004309997, 0.0043078312, 0.00430546, 0.0043031615, 0.0043006614, 0.004298375, 0.0042960183, 0.0042938679, + 0.0042914981, 0.0042893384, 0.0042869681, 0.0042846738, 0.0042821751, 0.0042799003, 0.0042775553, 0.0042754184, + 0.0042730626, 0.0042709159, 0.004268555, 0.0042662742, 0.0042637899, 0.0042615267, 0.0042591859, 0.0042570573, + 0.0042547132, 0.0042525809, 0.0042502261, 0.004247956, 0.0042456137, 0.0042434838, 0.0042411322, 0.0042389967, + 0.0042366371, 0.0042344979, 0.0042321403, 0.0042298674, 0.0042275153, 0.004225383, 0.0042230287, 0.004220895, + 0.0042185448, 0.0042164186, 0.0042140638, 0.0042117997, 0.0042094509, 0.0042073261, 0.0042049857, 0.004202866, + 0.0042005186, 0.0041982601, 0.0041959211, 0.0041938066, 0.0041914666, 0.0041893511, 0.0041870116, 0.0041848966, + 0.0041825525, 0.0041803075, 0.0041779773, 0.004175873, 0.004173541, 0.004171438, 0.0041691083, 0.004167011, + 0.0041646836, 0.0041624471, 0.0041601206, 0.0041580307, 0.0041557103, 0.0041536158, 0.0041512898, 0.0041491953, + 0.0041469987, 0.0041448926, 0.0041425587, 0.0041404623, 0.0041381298, 0.004136031, 0.0041336985, 0.0041314736, + 0.0041291588, 0.0041270782, 0.0041247667, 0.0041226903, 0.0041203755, 0.0041182972, 0.0041161124, 0.0041140215, + 0.0041117007, 0.0041096178, 0.0041073025, 0.0041052285, 0.0041029137, 0.0041008387, 0.0040986547, 0.0040965676, + 0.0040942505, 0.004092175, 0.004089864, 0.0040877904, 0.0040854807, 0.0040832874, 0.0040809917, 0.0040789419, + 0.0040766541, 0.0040746089, 0.0040723206, 0.0040702708, 0.0040681036, 0.004066044, 0.0040637478, 0.0040616966, + 0.0040594051, 0.0040573585, 0.004055074, 0.0040530371, 0.0040508821, 0.0040488299, 0.0040465393, 0.0040444979, + 0.0040422077, 0.0040401714, 0.0040380214, 0.0040359753, 0.0040336847, 0.0040316456, 0.0040293639, 0.004027334, + 0.0040250565, 0.0040230262, 0.0040208818, 0.0040188534, 0.0040165763, 0.0040145498, 0.0040122764, 0.0040102587, + 0.0040081209, 0.0040062247, 0.0040040663, 0.0040020221, 0.0039997376, 0.0039977077, 0.0039954274, 0.0039934083, + 0.00399127, 0.0039892462, 0.0039869696, 0.0039849509, 0.0039826878, 0.0039806832, 0.0039785504, 0.0039766612, + 0.0039745108, 0.0039724875, 0.0039702123, 0.0039681965, 0.0039659319, 0.0039639259, 0.0039617899, 0.0039597792, + 0.0039575179, 0.0039555216, 0.0039532743, 0.0039512883, 0.0039491719, 0.0039473055, 0.0039451742, 0.0039431676, + 0.0039409082, 0.0039389171, 0.0039367955, 0.0039349259, 0.003932789, 0.0039307848, 0.0039285244, 0.0039265295, + 0.0039242799, 0.0039223009, 0.0039201877, 0.0039183283, 0.003916203, 0.0039142068, 0.0039119525, 0.0039099678, + 0.0039078519, 0.0039059939, 0.0039038649, 0.0039018688, 0.0038996162, 0.0038976381, 0.0038953992, 0.0038934352, + 0.0038913332, 0.0038894892, 0.003887374, 0.0038853968, 0.0038831618, 0.0038811986, 0.0038790975, 0.0038772598, + 0.0038751473, 0.0038731731, 0.0038709426, 0.0038689873, 0.0038668904, 0.0038650578, 0.0038629514, 0.00386111, + 0.0038589938, 0.0038570198, 0.0038547867, 0.0038528321, 0.0038507364, 0.0038489078, 0.0038467979, 0.0038448323, + 0.0038426032, 0.0038406544, 0.0038385666, 0.0038367449, 0.0038346436, 0.0038328138, 0.003830709, 0.0038287521, + 0.0038266566, 0.0038248277, 0.0038227204, 0.0038208875, 0.0038187772, 0.0038168142, 0.0038145867, 0.0038126465, + 0.0038105641, 0.0038087522, 0.0038066609, 0.0038048439, 0.0038027435, 0.0038007966, 0.0037987079, 0.0037968932, + 0.0037947986, 0.0037929814, 0.0037908829, 0.0037889357, 0.0037868433, 0.0037850316, 0.0037829329, 0.0037811117, + 0.0037790122, 0.0037770693, 0.0037748546, 0.0037729323, 0.0037708641, 0.0037690781, 0.0037670059, 0.0037652107, + 0.003763129, 0.0037612056, 0.0037591355, 0.003757346, 0.0037552649, 0.0037534649, 0.003751386, 0.0037494688, + 0.0037473959, 0.0037456083, 0.0037435326, 0.0037417384, 0.003739655, 0.0037377339, 0.0037355437, 0.0037336515, + 0.003731603, 0.0037298372, 0.0037277841, 0.003726017, 0.0037239604, 0.0037220682, 0.0037200202, 0.0037182574, + 0.0037162036, 0.0037144367, 0.0037123831, 0.0037104944, 0.0037084492, 0.0037066934, 0.0037046412, 0.0037028783, + 0.0037008256, 0.0036990631, 0.0036971334, 0.0036953588, 0.0036932924, 0.0036915189, 0.0036894546, 0.0036876802, + 0.0036856171, 0.0036837289, 0.0036816846, 0.0036799295, 0.0036778788, 0.0036761244, 0.0036740738, 0.0036721991, + 0.0036701616, 0.0036684186, 0.003666386, 0.0036646458, 0.0036626069, 0.0036607403, 0.0036587112, 0.0036569799, + 0.0036549564, 0.0036532274, 0.0036511952, 0.003649459, 0.0036475533, 0.0036458124, 0.003643773, 0.0036420301, + 0.0036399902, 0.0036382512, 0.0036363332, 0.0036345811, 0.0036325355, 0.0036307897, 0.0036287473, 0.0036270083, + 0.0036249736, 0.0036231212, 0.0036211007, 0.0036193794, 0.0036173549, 0.0036156313, 0.003613611, 0.0036117723, + 0.0036097658, 0.0036080589, 0.0036060526, 0.0036043504, 0.0036023455, 0.0036006423, 0.0035987564, 0.003597046, + 0.0035950337, 0.0035933256, 0.0035913116, 0.0035896017, 0.0035877093, 0.0035859917, 0.0035839782, 0.0035822722, + 0.0035802627, 0.0035785576, 0.0035766677, 0.0035749564, 0.0035729441, 0.0035712367, 0.0035692188, 0.0035675119, + 0.0035656262, 0.0035639184, 0.0035619086, 0.0035602099, 0.0035582033, 0.0035565058, 0.0035546236, 0.0035530415, + 0.0035511435, 0.0035494296, 0.0035474109, 0.003545705, 0.0035436947, 0.0035419939, 0.0035401038, 0.0035383983, + 0.0035363904, 0.0035346977, 0.003532694, 0.0035310038, 0.0035291265, 0.0035274355, 0.0035254352, 0.0035237472, + 0.003521756, 0.0035200831, 0.003518217, 0.0035165374, 0.0035145483, 0.0035128756, 0.0035108929, 0.0035092265, + 0.0035073685, 0.0035056933, 0.0035037107, 0.0035020434, 0.0035000653, 0.0034984055, 0.0034965524, 0.0034948881, + 0.0034929125, 0.0034912573, 0.003489288, 0.0034876375, 0.0034857967, 0.0034842622, 0.0034824042, 0.0034807376, + 0.0034787564, 0.0034770959, 0.0034752421, 0.0034736963, 0.0034718267, 0.0034701517, 0.0034681654, 0.0034665018, + 0.0034646417, 0.0034630951, 0.003461224, 0.0034595472, 0.0034575579, 0.003455895, 0.0034540377, 0.0034524931, + 0.0034506214, 0.003448945, 0.0034469587, 0.0034453049, 0.0034434537, 0.0034419149, 0.0034400504, 0.0034383878, + 0.0034364113, 0.0034347596, 0.0034329088, 0.0034313737, 0.0034295125, 0.0034278561, 0.0034258829, 0.0034242372, + 0.0034223951, 0.0034208728, 0.0034190228, 0.0034173757, 0.0034154113, 0.0034137738, 0.0034119345, 0.0034104148, + 0.0034085668, 0.00340692, 0.0034049568, 0.0034033253, 0.0034014941, 0.0033999812, 0.0033981402, 0.0033965048, + 0.0033945525, 0.0033929327, 0.0033911052, 0.0033895986, 0.0033877601, 0.0033861289, 0.0033841799, 0.0033825608, + 0.0033807412, 0.0033792427, 0.0033774136, 0.0033757947, 0.0033738553, 0.0033722492, 0.0033704343, 0.0033689409, + 0.0033671202, 0.003365624, 0.0033637942, 0.0033621744, 0.0033603476, 0.0033588477, 0.0033570151, 0.0033555082, + 0.0033536702, 0.0033520476, 0.0033502176, 0.0033487119, 0.0033468746, 0.0033453675, 0.0033435284, 0.0033419041, + 0.0033400729, 0.0033385707, 0.0033367367, 0.003335231, 0.003333394, 0.0033317732, 0.0033299432, 0.0033284423, + 0.0033266093, 0.0033251063, 0.0033232716, 0.0033216514, 0.0033198223, 0.0033183263, 0.0033164979, 0.0033150031, + 0.0033131721, 0.0033115586, 0.0033097358, 0.0033082478, 0.003306424, 0.0033049325, 0.0033031106, 0.0033015076, + 0.0032996924, 0.0032982111, 0.003296393, 0.0032949105, 0.003293091, 0.0032914917, 0.0032896821, 0.0032882101, + 0.0032864015, 0.0032849279, 0.0032831172, 0.0032815263, 0.0032797225, 0.0032782536, 0.0032764494, 0.0032749807, + 0.0032731732, 0.0032715918, 0.0032697946, 0.0032683339, 0.0032665315, 0.0032650661, 0.0032632637, 0.0032616886, + 0.0032598989, 0.0032584451, 0.0032566527, 0.0032550825, 0.0032531829, 0.0032516315, 0.0032498674, 0.0032484415, + 0.003246668, 0.0032451192, 0.0032432391, 0.0032417092, 0.0032399609, 0.0032385518, 0.003236796, 0.0032352649, + 0.0032335201, 0.0032321145, 0.0032303608, 0.0032289487, 0.0032271927, 0.0032256602, 0.0032239065, 0.0032224916, + 0.0032207323, 0.0032193153, 0.003217557, 0.0032160247, 0.0032142706, 0.0032128624, 0.0032111101, 0.0032096996, + 0.0032079401, 0.0032064086, 0.0032046586, 0.0032032547, 0.0032015042, 0.0032000972, 0.0031983436, 0.0031968202, + 0.0031950751, 0.00319367, 0.0031919212, 0.0031905184, 0.0031887691, 0.0031872522, 0.003185505, 0.0031841053, + 0.00318236, 0.0031809602, 0.0031792144, 0.0031777031, 0.0031759695, 0.0031745795, 0.0031728409, 0.0031714474, + 0.0031698174, 0.0031684132, 0.0031666621, 0.0031652574, 0.0031635046, 0.0031621004, 0.0031604616, 0.0031590485, + 0.0031572913, 0.0031558818, 0.0031541204, 0.0031527099, 0.0031510657, 0.0031496498, 0.0031478875, 0.0031464784, + 0.0031447227, 0.0031432074, 0.0031414686, 0.0031400784, 0.0031383359, 0.0031369473, 0.0031352087, 0.0031337079, + 0.0031319798, 0.0031306022, 0.0031288734, 0.0031274927, 0.0031257616, 0.0031242731, 0.0031225584, 0.0031211979, + 0.0031194834, 0.0031181173, 0.0031165141, 0.0031151404, 0.0031134144, 0.0031120449, 0.0031103205, 0.0031089487, + 0.0031073366, 0.003105958, 0.0031042257, 0.003102852, 0.0031011244, 0.0030997507, 0.0030981381, 0.0030967607, + 0.0030950317, 0.0030936589, 0.0030919306, 0.003090445, 0.0030887304, 0.0030873723, 0.0030856645, 0.0030843138, + 0.0030826062, 0.0030811429, 0.0030794484, 0.0030781117, 0.0030764171, 0.0030750784, 0.0030734946, 0.0030721417, + 0.0030704362, 0.0030690902, 0.0030673856, 0.0030660382, 0.0030644492, 0.0030630981, 0.0030613937, 0.0030600484, + 0.0030583485, 0.0030570086, 0.0030554228, 0.0030540754, 0.0030523727, 0.0030510277, 0.0030493243, 0.0030479806, + 0.0030463971, 0.0030450546, 0.0030433547, 0.0030420145, 0.003040429, 0.0030390813, 0.0030373766, 0.0030360369, + 0.0030343421, 0.0030330063, 0.0030314242, 0.003030085, 0.0030283865, 0.0030270491, 0.0030253576, 0.0030240293, + 0.0030224517, 0.0030211199, 0.0030194332, 0.003018104, 0.0030164158, 0.0030150909, 0.0030135161, 0.0030121829, + 0.0030104951, 0.0030091717, 0.0030075992, 0.0030062692, 0.0030045831, 0.0030032622, 0.0030015826, 0.0030002682, + 0.0029987064, 0.0029973902, 0.0029957104, 0.0029943949, 0.0029927231, 0.0029914179, 0.002989863, 0.0029885522, + 0.0029868791, 0.0029855706, 0.0029840143, 0.0029828122, 0.0029812413, 0.002979917, 0.0029782327, 0.0029769179, + 0.0029753549, 0.0029740403, 0.0029723654, 0.0029710592, 0.0029693944, 0.0029680924, 0.0029665355, 0.0029652291, + 0.0029635634, 0.0029622656, 0.0029606048, 0.0029593115, 0.002957765, 0.0029564677, 0.0029548102, 0.0029535205, + 0.002951981, 0.0029507997, 0.0029492446, 0.0029479421, 0.0029462758, 0.0029449812, 0.0029434343, 0.0029421339, + 0.0029404743, 0.0029391877, 0.0029375372, 0.0029362552, 0.0029347187, 0.0029334337, 0.0029317867, 0.0029305094, + 0.0029289757, 0.0029278004, 0.0029262553, 0.0029249662, 0.0029233135, 0.0029220355, 0.0029205028, 0.0029193289, + 0.0029177843, 0.0029164911, 0.0029148331, 0.0029135526, 0.002912018, 0.0029107353, 0.0029090883, 0.0029078149, + 0.0029062864, 0.0029051197, 0.0029035776, 0.0029022912, 0.0029006437, 0.0028993695, 0.0028978395, 0.0028966728, + 0.0028951305, 0.0028938465, 0.0028922015, 0.0028909298, 0.0028894045, 0.0028881384, 0.0028865063, 0.0028852446, + 0.0028837251, 0.0028825691, 0.0028810364, 0.002879764, 0.0028781297, 0.0028768708, 0.0028753555, 0.0028742068, + 0.0028726822, 0.0028714153, 0.002869783, 0.0028685275, 0.0028670141, 0.002865758, 0.0028641373, 0.0028628935, + 0.0028613904, 0.0028602497, 0.0028587331, 0.0028574779, 0.0028558553, 0.0028546064, 0.0028530979, 0.0028519549, + 0.0028504396, 0.0028491884, 0.002847682, 0.00284654, 0.0028450149, 0.0028437527, 0.002842128, 0.0028408801, + 0.0028393753, 0.0028382395, 0.0028367254, 0.0028354735, 0.0028338563, 0.0028326206, 0.0028311238, 0.0028299945, + 0.002828487, 0.0028272406, 0.0028257347, 0.0028245968, 0.002823086, 0.0028218403, 0.0028202268, 0.0028189938, + 0.0028175013, 0.0028163784, 0.0028148768, 0.002813641, 0.002812146, 0.0028110177, 0.0028095117, 0.0028082719, + 0.0028066647, 0.0028054388, 0.0028039489, 0.0028028279, 0.002801331, 0.0028001005, 0.0027985012, 0.0027972814, + 0.0027958024, 0.0027946951, 0.0027932073, 0.0027919863, 0.0027905039, 0.0027893938, 0.0027879034, 0.0027866769, + 0.0027850815, 0.0027838722, 0.0027824, 0.0027812955, 0.0027798119, 0.0027785979, 0.0027771201, 0.0027760142, + 0.002774531, 0.0027734211, 0.0027719296, 0.0027707042, 0.0027692167, 0.002768104, 0.0027666138, 0.002765394, + 0.0027638099, 0.0027626059, 0.0027611372, 0.0027600438, 0.0027585702, 0.0027573651, 0.0027558955, 0.0027548007, + 0.002753325, 0.0027521176, 0.0027505439, 0.0027493553, 0.0027478992, 0.0027468139, 0.0027453483, 0.002744155, + 0.002742697, 0.0027416151, 0.0027401519, 0.0027389571, 0.0027373945, 0.0027362143, 0.002734767, 0.0027336928, + 0.0027322369, 0.0027310534, 0.0027296073, 0.0027285318, 0.0027270736, 0.0027259919, 0.0027245281, 0.0027233367, + 0.0027218792, 0.0027207953, 0.0027193339, 0.0027181467, 0.0027166917, 0.0027156135, 0.0027141522, 0.0027130723, + 0.0027116153, 0.0027104283, 0.0027089715, 0.0027078926, 0.0027064322, 0.0027052481, 0.0027037994, 0.0027027279, + 0.0027012755, 0.0027002001, 0.002698743, 0.0026975586, 0.0026961062, 0.0026950315, 0.0026935767, 0.0026923958, + 0.0026909474, 0.0026898789, 0.0026884309, 0.0026873627, 0.0026859134, 0.0026847383, 0.0026832933, 0.0026822279, + 0.0026807822, 0.0026797149, 0.0026782665, 0.0026770921, 0.0026756513, 0.0026745913, 0.0026731477, 0.0026719822, + 0.0026705477, 0.0026694909, 0.0026680527, 0.0026669933, 0.0026655523, 0.00266439, 0.0026629616, 0.0026619094, + 0.0026604745, 0.0026593187, 0.0026578926, 0.0026568442, 0.0026554128, 0.0026543634, 0.0026529322, 0.0026517785, + 0.0026503559, 0.0026493124, 0.0026478844, 0.0026467338, 0.0026453161, 0.0026442781, 0.0026428557, 0.0026418108, + 0.0026404883, 0.0026394341, 0.0026380019, 0.0026369535, 0.0026355211, 0.0026343698, 0.0026329469, 0.0026319046, + 0.0026304789, 0.002629434, 0.0026281106, 0.0026270573, 0.0026256221, 0.0026245697, 0.0026231338, 0.0026219797, + 0.0026205599, 0.0026195238, 0.0026181026, 0.0026170628, 0.0026157442, 0.0026146972, 0.0026132667, 0.0026122201, + 0.0026107936, 0.002609649, 0.0026082336, 0.002607201, 0.0026057875, 0.0026047565, 0.0026034461, 0.0026024044, + 0.0026009805, 0.0025999437, 0.0025985253, 0.002597386, 0.0025959762, 0.0025949529, 0.0025935448, 0.002592518, + 0.0025912118, 0.0025901783, 0.0025887615, 0.0025877294, 0.002586317, 0.0025851852, 0.0025837801, 0.0025827591, + 0.0025813584, 0.0025803405, 0.0025790404, 0.0025780138, 0.0025766056, 0.0025755828, 0.0025741816, 0.0025730631, + 0.0025716696, 0.0025706582, 0.0025692645, 0.0025681551, 0.0025667748, 0.0025657783, 0.0025643951, 0.0025633939, + 0.0025621103, 0.0025611012, 0.0025597096, 0.0025587033, 0.0025573133, 0.0025562036, 0.0025548199, 0.0025538248, + 0.0025524469, 0.0025514509, 0.0025501731, 0.0025491689, 0.002547784, 0.0025467835, 0.0025453991, 0.0025442995, + 0.0025429265, 0.0025419376, 0.0025405632, 0.0025395751, 0.0025383022, 0.002537302, 0.0025359197, 0.002534925, + 0.002533549, 0.0025324586, 0.0025310947, 0.0025301136, 0.0025287468, 0.0025277669, 0.0025265017, 0.0025255114, + 0.0025241398, 0.002523151, 0.0025218772, 0.0025208828, 0.0025195056, 0.002518516, 0.0025171423, 0.0025160513, + 0.0025146869, 0.0025137088, 0.0025123479, 0.0025113733, 0.0025101132, 0.0025091297, 0.0025077639, 0.0025067851, + 0.0025054214, 0.0025043422, 0.002502989, 0.0025020204, 0.0025006691, 0.0024997087, 0.0024984619, 0.0024974877, + 0.0024961287, 0.0024951585, 0.0024939044, 0.0024929275, 0.0024915701, 0.0024905978, 0.0024892378, 0.0024882664, + 0.0024870094, 0.0024860303, 0.0024846701, 0.0024836974, 0.0024824392, 0.0024814622, 0.0024801043, 0.0024791337, + 0.0024777802, 0.0024767122, 0.0024753695, 0.0024744128, 0.0024730691, 0.0024721134, 0.0024708714, 0.0024699082, + 0.0024685627, 0.0024676048, 0.0024663606, 0.0024653936, 0.0024640446, 0.002463083, 0.0024617387, 0.0024607817, + 0.00245954, 0.0024585775, 0.0024572294, 0.0024562674, 0.0024550245, 0.0024540639, 0.0024527197, 0.0024517642, + 0.0024504219, 0.0024493681, 0.0024480422, 0.0024471022, 0.0024457774, 0.0024448419, 0.00244362, 0.0024426742, + 0.0024413436, 0.0024404014, 0.0024391743, 0.0024382274, 0.0024368947, 0.0024359499, 0.0024346218, 0.0024335822, + 0.0024322676, 0.0024313431, 0.0024300353, 0.0024291135, 0.0024279018, 0.0024269687, 0.0024256541, 0.0024247239, + 0.0024235081, 0.0024225705, 0.0024212475, 0.0024203144, 0.0024190005, 0.0024180757, 0.0024168626, 0.0024159306, + 0.0024146154, 0.002413688, 0.0024124731, 0.0024115373, 0.0024102214, 0.0024092922, 0.0024080803, 0.0024071496, + 0.0024058323, 0.0024049024, 0.0024035911, 0.0024026686, 0.0024014567, 0.0024005261, 0.0023992136, 0.0023982902, + 0.0023970813, 0.0023961531, 0.0023948427, 0.0023939207, 0.0023927114, 0.0023917826, 0.002390472, 0.0023895504, + 0.0023882443, 0.002387326, 0.0023861229, 0.0023852028, 0.0023838987, 0.0023829832, 0.00238178, 0.002380857, + 0.0023795543, 0.0023786414, 0.0023774439, 0.0023765275, 0.0023752269, 0.0023743145, 0.0023730183, 0.0023721114, + 0.0023709172, 0.002370005, 0.0023687107, 0.0023678052, 0.0023666134, 0.0023657023, 0.0023644087, 0.002363506, + 0.0023623167, 0.0023614084, 0.0023601172, 0.0023592156, 0.0023579297, 0.0023570303, 0.0023558466, 0.0023549441, + 0.0023536575, 0.002352759, 0.0023515744, 0.0023506719, 0.0023493876, 0.0023484954, 0.002347314, 0.0023464151, + 0.0023451336, 0.0023442388, 0.002342961, 0.0023420728, 0.0023409012, 0.0023400097, 0.0023387347, 0.0023378492, + 0.0023366758, 0.0023357843, 0.0023345114, 0.0023336273, 0.0023324576, 0.0023315682, 0.0023302946, 0.0023294091, + 0.002328238, 0.0023274461, 0.0023262606, 0.0023253597, 0.0023240796, 0.00232319, 0.0023220128, 0.002321118, + 0.0023198405, 0.0023189513, 0.0023177753, 0.0023168852, 0.0023156144, 0.002314735, 0.0023135687, 0.0023127797, + 0.0023116006, 0.0023107075, 0.0023094334, 0.0023085449, 0.0023073719, 0.002306483, 0.0023052136, 0.0023043333, + 0.0023031693, 0.0023022895, 0.0023010273, 0.002300154, 0.0022989942, 0.0022981162, 0.0022968566, 0.0022959886, + 0.0022948328, 0.0022940545, 0.0022928854, 0.0022920009, 0.0022907362, 0.0022898593, 0.0022886968, 0.0022878188, + 0.0022865608, 0.0022856935, 0.0022845403, 0.00228367, 0.0022824171, 0.002281554, 0.0022804074, 0.0022796388, + 0.0022784793, 0.0022776024, 0.002276439, 0.0022756567, 0.0022744886, 0.0022736057, 0.0022723407, 0.0022714676, + 0.002270312, 0.0022694403, 0.0022681877, 0.0022673239, 0.0022661765, 0.0022653148, 0.0022640706, 0.0022632119, + 0.0022620712, 0.0022613108, 0.0022601602, 0.0022592938, 0.0022580468, 0.0022571858, 0.0022560391, 0.0022551774, + 0.0022539375, 0.0022530872, 0.0022519536, 0.0022511033, 0.00224987, 0.0022490241, 0.0022478921, 0.0022470427, + 0.0022458152, 0.0022449759, 0.002243849, 0.002243103, 0.0022419686, 0.0022411169, 0.002239886, 0.0022390443, + 0.0022379162, 0.0022370711, 0.0022358489, 0.002235014, 0.0022338906, 0.0022330489, 0.0022318305, 0.0022310002, + 0.0022298829, 0.0022290484, 0.0022278335, 0.0022270067, 0.002225897, 0.0022251636, 0.0022240379, 0.002223195, + 0.0022220709, 0.0022213235, 0.0022201887, 0.0022193422, 0.0022181179, 0.0022172823, 0.0022161601, 0.0022153219, + 0.0022141067, 0.0022132779, 0.0022121645, 0.0022113351, 0.0022101258, 0.0022093034, 0.0022081963, 0.0022074685, + 0.002206353, 0.0022055197, 0.002204401, 0.0022036629, 0.0022025364, 0.0022016945, 0.0022004768, 0.0021996433, + 0.0021985283, 0.0021976978, 0.0021964889, 0.0021956696, 0.0021945655, 0.002193745, 0.0021925431, 0.0021917289, + 0.0021906323, 0.0021898188, 0.002188629, 0.0021878232, 0.002186731, 0.0021860159, 0.0021849121, 0.002184093, + 0.0021829894, 0.0021822643, 0.0021811542, 0.0021803288, 0.0021791253, 0.0021783097, 0.0021772089, 0.0021763907, + 0.0021751965, 0.0021743916, 0.0021733018, 0.0021724934, 0.0021713083, 0.0021705097, 0.0021694251, 0.0021687159, + 0.0021676207, 0.00216681, 0.0021657159, 0.0021649969, 0.0021638921, 0.0021630751, 0.0021619771, 0.0021612549, + 0.0021601473, 0.0021593263, 0.002158128, 0.0021573156, 0.0021562222, 0.0021554159, 0.0021542336, 0.002153435, + 0.002152354, 0.0021515551, 0.0021503787, 0.0021495896, 0.002148516, 0.0021478175, 0.0021467323, 0.0021459337, + 0.0021448515, 0.0021441428, 0.0021430512, 0.0021422443, 0.0021411534, 0.002140444, 0.0021393513, 0.0021385415, + 0.0021373576, 0.0021365623, 0.0021354808, 0.0021346812, 0.002133511, 0.002132724, 0.002131653, 0.0021308667, + 0.0021297028, 0.002128924, 0.0021278625, 0.0021271745, 0.0021261037, 0.0021253156, 0.002124243, 0.0021235463, + 0.0021224674, 0.0021216723, 0.002120595, 0.0021198944, 0.0021188096, 0.0021180136, 0.0021169374, 0.0021162345, + 0.0021151488, 0.0021143507, 0.0021131793, 0.0021123919, 0.0021113241, 0.0021105409, 0.002109383, 0.0021086112, + 0.0021075543, 0.0021067781, 0.0021056291, 0.0021048647, 0.0021038149, 0.0021031385, 0.0021020812, 0.002101308, + 0.0021002521, 0.0020995694, 0.0020985035, 0.0020977219, 0.0020966595, 0.0020959731, 0.0020949026, 0.0020941165, + 0.0020930518, 0.0020923631, 0.0020912923, 0.0020905058, 0.0020893477, 0.0020885726, 0.0020875155, 0.0020867425, + 0.002085597, 0.0020848359, 0.0020837928, 0.002083034, 0.0020819029, 0.0020811525, 0.0020801204, 0.0020794589, + 0.0020784154, 0.0020776542, 0.0020766128, 0.0020759476, 0.0020749012, 0.0020741359, 0.0020730877, 0.0020724137, + 0.0020713604, 0.0020705913, 0.0020695424, 0.0020688667, 0.0020678099, 0.002067036, 0.002065985, 0.0020653105, + 0.002064256, 0.0020634842, 0.0020623414, 0.0020615817, 0.0020605391, 0.0020597782, 0.0020586487, 0.0020579009, + 0.0020568729, 0.0020561269, 0.0020550115, 0.002054275, 0.0020532545, 0.0020526091, 0.0020515828, 0.0020508373, + 0.0020498107, 0.0020491567, 0.0020481239, 0.0020473716, 0.0020463418, 0.0020456864, 0.0020446503, 0.0020438959, + 0.0020428633, 0.0020422037, 0.0020411669, 0.0020404118, 0.0020393785, 0.0020387166, 0.002037677, 0.0020369205, + 0.0020357936, 0.0020350495, 0.0020340255, 0.0020332832, 0.0020321712, 0.0020314406, 0.002030432, 0.0020297021, + 0.0020286005, 0.0020278802, 0.0020268825, 0.0020261635, 0.0020250746, 0.0020243633, 0.0020233714, 0.0020227483, + 0.0020217439, 0.0020210214, 0.0020200196, 0.0020193856, 0.0020183732, 0.0020176407, 0.0020166331, 0.0020159972, + 0.0020149813, 0.0020142458, 0.0020132337, 0.0020125906, 0.0020115729, 0.0020108358, 0.0020098209, 0.0020091813, + 0.0020081648, 0.0020074272, 0.0020064118, 0.0020057671, 0.0020047484, 0.0020040115, 0.0020029084, 0.0020021836, + 0.0020011782, 0.0020004513, 0.0019993598, 0.0019986476, 0.0019976539, 0.0019969402, 0.0019958634, 0.0019951623, + 0.0019941807, 0.0019935656, 0.0019925733, 0.001991862, 0.0019908759, 0.0019902582, 0.001989265, 0.0019885488, + 0.0019875541, 0.0019869285, 0.0019859276, 0.0019852065, 0.00198421, 0.0019835802, 0.0019825753, 0.0019818512, + 0.0019808493, 0.0019802165, 0.001979212, 0.0019784879, 0.0019774903, 0.0019768619, 0.0019758602, 0.001975138, + 0.0019741417, 0.0019735144, 0.0019725109, 0.0019717857, 0.0019707866, 0.0019701587, 0.0019691573, 0.0019684348, + 0.0019674378, 0.0019668103, 0.0019658115, 0.0019650932, 0.0019640108, 0.0019633044, 0.0019623211, 0.0019616191, + 0.0019605532, 0.0019598585, 0.0019588885, 0.0019581963, 0.0019571402, 0.0019564596, 0.0019555013, 0.0019549073, + 0.0019539415, 0.0019532545, 0.0019522903, 0.0019516916, 0.001950719, 0.0019500218, 0.0019490493, 0.0019484432, + 0.0019474649, 0.0019467666, 0.0019457963, 0.0019451909, 0.0019442132, 0.0019435144, 0.0019425424, 0.0019419349, + 0.0019409569, 0.0019402568, 0.0019392832, 0.0019386766, 0.0019377004, 0.001936999, 0.0019360252, 0.0019354192, + 0.0019344405, 0.0019337373, 0.001932763, 0.0019321562, 0.0019311793, 0.00193048, 0.0019295089, 0.0019289032, + 0.0019279266, 0.0019272282, 0.0019262604, 0.0019256575, 0.0019246856, 0.0019239897, 0.0019230199, 0.0019224156, + 0.0019214451, 0.0019207525, 0.0019197861, 0.0019191868, 0.0019182174, 0.0019175231, 0.0019164714, 0.0019157931, + 0.0019148432, 0.0019141671, 0.0019131287, 0.0019124643, 0.0019115263, 0.0019108598, 0.0019098305, 0.0019091732, + 0.0019082432, 0.0019075884, 0.0019065746, 0.0019059272, 0.0019050068, 0.0019044463, 0.0019035139, 0.001902855, + 0.0019019246, 0.0019013573, 0.0019004198, 0.0018997547, 0.0018988186, 0.0018982453, 0.0018973041, 0.0018966382, + 0.0018957031, 0.0018951286, 0.0018941859, 0.0018935166, 0.0018925776, 0.0018920007, 0.0018910568, 0.0018903845, + 0.0018894407, 0.0018888613, 0.0018879169, 0.0018872458, 0.0018863054, 0.0018857262, 0.0018847832, 0.001884114, + 0.0018831724, 0.0018825937, 0.0018816498, 0.0018809813, 0.0018800424, 0.0018794631, 0.0018785204, 0.0018778526, + 0.0018769152, 0.0018763358, 0.0018753919, 0.0018747248, 0.0018737887, 0.0018732115, 0.0018722677, 0.0018715991, + 0.0018706635, 0.0018700887, 0.0018691502, 0.0018684864, 0.0018675536, 0.0018669785, 0.0018660399, 0.001865374, + 0.0018644406, 0.0018638687, 0.0018629334, 0.0018622723, 0.0018613446, 0.0018607749, 0.001859843, 0.0018591818, + 0.0018582522, 0.0018576822, 0.0018567494, 0.0018560898, 0.0018551626, 0.0018545946, 0.0018536658, 0.0018530079, + 0.0018520828, 0.001851514, 0.0018505841, 0.0018499286, 0.0018490069, 0.0018484424, 0.0018475162, 0.0018468639, + 0.0018459443, 0.001845381, 0.0018444575, 0.0018438076, 0.0018428905, 0.0018423299, 0.0018414077, 0.0018407597, + 0.0018398443, 0.0018392837, 0.0018383643, 0.0018377155, 0.0018368006, 0.0018362418, 0.0018353238, 0.0018346774, + 0.0018337674, 0.0018332133, 0.0018322978, 0.0018316533, 0.0018307434, 0.0018301887, 0.0018292743, 0.0018286316, + 0.0018277244, 0.0018271727, 0.0018262616, 0.0018256211, 0.0018247149, 0.0018241646, 0.0018232572, 0.0018226191, + 0.0018217162, 0.0018211674, 0.001820259, 0.0018196231, 0.0018187212, 0.0018181744, 0.0018172694, 0.0018166323, + 0.0018157306, 0.0018151839, 0.0018142806, 0.0018136466, 0.0018127487, 0.0018122058, 0.0018113045, 0.0018106715, + 0.0018097757, 0.0018092344, 0.0018083367, 0.0018077082, 0.0018068153, 0.0018062738, 0.0018053739, 0.0018047434, + 0.0018038506, 0.0018033112, 0.0018024158, 0.0018017902, 0.0018009017, 0.0018003645, 0.0017994693, 0.001798844, + 0.0017979555, 0.0017974194, 0.0017965259, 0.0017959003, 0.0017950141, 0.0017944816, 0.001793592, 0.0017929683, + 0.0017920822, 0.001791548, 0.001790659, 0.001790038, 0.0017891548, 0.0017886229, 0.0017877361, 0.0017871168, + 0.0017862353, 0.0017857041, 0.0017848188, 0.0017842029, 0.0017833244, 0.0017827955, 0.0017819142, 0.0017812987, + 0.0017804215, 0.0017798949, 0.0017790142, 0.0017784021, 0.0017775282, 0.0017770033, 0.0017761246, 0.0017755124, + 0.0017746391, 0.0017741156, 0.0017732374, 0.0017726228, 0.0017717486, 0.0017712269, 0.0017703527, 0.001769744, + 0.0017688768, 0.0017683561, 0.0017674814, 0.0017668738, 0.0017660041, 0.0017654835, 0.0017646115, 0.001764004, + 0.0017631371, 0.001762619, 0.0017617482, 0.0017611419, 0.0017602778, 0.0017597608, 0.0017588901, 0.0017582856, + 0.0017574234, 0.0017569084, 0.0017560419, 0.0017554441, 0.0017545857, 0.0017540717, 0.0017532096, 0.0017526117, + 0.001751753, 0.0017512414, 0.0017503788, 0.0017497794, 0.0017489224, 0.0017484124, 0.0017475514, 0.0017469553, + 0.001746101, 0.0017455916, 0.0017447345, 0.001744141, 0.0017432892, 0.0017427828, 0.0017419244, 0.0017413293, + 0.0017404762, 0.0017399684, 0.001739111, 0.0017385167, 0.0017376662, 0.0017371606, 0.0017363059, 0.0017357148, + 0.0017348675, 0.0017343651, 0.0017335144, 0.0017329264, 0.0017320809, 0.0017315799, 0.0017307308, 0.0017301425, + 0.0017292959, 0.0017287941, 0.0017279473, 0.0017273616, 0.0017265173, 0.0017260192, 0.0017251761, 0.0017245907, + 0.0017237489, 0.0017231696, 0.0017222514, 0.0017216841, 0.0017208587, 0.0017202919, 0.0017193852, 0.0017188278, + 0.0017180131, 0.0017174575, 0.0017166459, 0.0017161742, 0.0017153549, 0.0017147933, 0.001713973, 0.0017134947, + 0.0017126703, 0.0017121036, 0.0017112812, 0.0017108008, 0.0017099755, 0.0017094096, 0.0017085854, 0.0017081035, + 0.0017072759, 0.0017067067, 0.0017058838, 0.0017054019, 0.0017045734, 0.0017040038, 0.0017031803, 0.0017026963, + 0.0017018681, 0.0017012992, 0.0017004749, 0.0016999904, 0.0016991619, 0.0016985942, 0.0016977716, 0.0016972896, + 0.0016964634, 0.0016958949, 0.001695072, 0.0016945887, 0.0016937644, 0.0016931995, 0.0016923774, 0.0016918934, + 0.0016910677, 0.0016905003, 0.0016896816, 0.001689201, 0.0016883771, 0.0016878111, 0.0016869921, 0.0016865113, + 0.001685689, 0.0016851234, 0.0016843061, 0.0016838294, 0.0016830101, 0.0016824466, 0.00168163, 0.0016811528, + 0.0016803348, 0.0016797708, 0.0016789543, 0.0016783957, 0.001677586, 0.0016771118, 0.001676296, 0.0016757379, + 0.00167493, 0.0016744586, 0.0016736469, 0.001673091, 0.0016722832, 0.0016718127, 0.0016710028, 0.0016704461, + 0.0016696398, 0.0016691722, 0.0016683636, 0.0016678085, 0.0016670033, 0.0016665339, 0.001665724, 0.0016651663, + 0.0016643608, 0.0016638939, 0.0016630874, 0.0016625336, 0.0016617299, 0.0016612625, 0.0016604559, 0.0016599047, + 0.0016591049, 0.0016586398, 0.0016578345, 0.0016572831, 0.0016564827, 0.0016560176, 0.001655216, 0.0016546661, + 0.0016538661, 0.0016534014, 0.0016525987, 0.0016520499, 0.0016512551, 0.0016507946, 0.0016499961, 0.0016494514, + 0.0016486569, 0.0016481145, 0.0016473249, 0.0016468674, 0.0016460735, 0.0016455319, 0.0016447424, 0.0016442877, + 0.0016434948, 0.0016429533, 0.0016421664, 0.0016417111, 0.0016409199, 0.00164038, 0.0016395916, 0.0016391338, + 0.0016383429, 0.0016378037, 0.0016370181, 0.0016365644, 0.0016357743, 0.0016352349, 0.0016344507, 0.001633998, + 0.0016332102, 0.0016326734, 0.0016318917, 0.0016314421, 0.0016306564, 0.0016301197, 0.0016293403, 0.0016288899, + 0.001628104, 0.0016275686, 0.001626789, 0.0016263407, 0.001625558, 0.0016250252, 0.0016242459, 0.0016237156, + 0.0016228619, 0.0016223454, 0.0016215821, 0.0016210673, 0.0016203066, 0.0016198738, 0.0016191074, 0.0016185895, + 0.001617827, 0.0016173922, 0.001616624, 0.0016161033, 0.0016153373, 0.0016148987, 0.0016141293, 0.0016136094, + 0.0016128459, 0.0016124103, 0.0016116407, 0.0016111182, 0.0016103521, 0.0016099111, 0.0016091379, 0.0016086146, + 0.001607849, 0.0016074111, 0.0016066429, 0.001606121, 0.0016053563, 0.001604919, 0.0016041507, 0.0016036296, + 0.0016028658, 0.0016023483, 0.0016015089, 0.0016010032, 0.0016002533, 0.0015997478, 0.0015990005, 0.0015985796, + 0.0015978278, 0.0015973207, 0.0015965718, 0.0015961477, 0.0015953934, 0.001594884, 0.0015941325, 0.0015937071, + 0.0015929517, 0.0015924397, 0.0015916879, 0.0015912602, 0.0015905038, 0.0015899946, 0.0015892419, 0.0015888133, + 0.0015880573, 0.0015875454, 0.001586793, 0.0015863626, 0.0015856052, 0.0015850937, 0.0015843419, 0.0015838357, + 0.0015830097, 0.0015825126, 0.0015817747, 0.0015812807, 0.0015805464, 0.0015801319, 0.0015793907, 0.0015788946, + 0.0015781587, 0.0015777434, 0.0015769996, 0.0015764977, 0.0015757559, 0.0015753362, 0.0015745912, 0.0015740907, + 0.001573352, 0.0015729329, 0.0015721879, 0.0015716857, 0.0015709455, 0.0015705269, 0.0015697817, 0.0015692787, + 0.0015685373, 0.0015681169, 0.0015673724, 0.0015668689, 0.0015661281, 0.0015656298, 0.0015648154, 0.0015643288, + 0.0015636038, 0.0015631191, 0.0015623942, 0.0015619873, 0.0015612557, 0.0015607646, 0.0015600383, 0.0015596304, + 0.0015588981, 0.0015584081, 0.00155768, 0.0015572683, 0.0015565339, 0.0015560404, 0.0015553122, 0.0015549021, + 0.0015541685, 0.0015536757, 0.0015529461, 0.0015525352, 0.0015518011, 0.0015513066, 0.0015505775, 0.0015500861, + 0.0015492809, 0.0015488025, 0.0015480868, 0.0015476086, 0.001546895, 0.0015464977, 0.0015457767, 0.0015452941, + 0.0015445778, 0.0015441768, 0.0015434549, 0.0015429703, 0.001542251, 0.001541849, 0.0015411247, 0.0015406378, + 0.0015399179, 0.0015395141, 0.001538791, 0.0015383052, 0.001537585, 0.0015371807, 0.0015364569, 0.0015359707, + 0.0015352522, 0.0015347699, 0.0015339747, 0.0015335038, 0.0015328004, 0.0015323319, 0.0015316294, 0.0015312396, + 0.0015305295, 0.0015300547, 0.001529348, 0.0015289547, 0.0015282413, 0.0015277622, 0.0015270505, 0.0015266552, + 0.0015259427, 0.0015254666, 0.0015247575, 0.00152436, 0.0015236455, 0.0015231653, 0.001522453, 0.0015219748, + 0.0015211881, 0.0015207217, 0.001520023, 0.0015195621, 0.0015188686, 0.0015184821, 0.0015177797, 0.0015173124, + 0.0015166135, 0.0015162271, 0.0015155231, 0.0015150532, 0.0015143532, 0.001513963, 0.0015132563, 0.0015127836, + 0.0015120807, 0.0015116887, 0.0015109817, 0.0015105094, 0.0015098072, 0.0015093377, 0.0015085612, 0.0015081037, + 0.0015074154, 0.0015069599, 0.0015062742, 0.0015058954, 0.0015052013, 0.001504738, 0.0015040459, 0.0015036634, + 0.0015029665, 0.0015025039, 0.001501812, 0.0015014277, 0.0015007291, 0.0015002633, 0.0014995694, 0.0014991839, + 0.0014984844, 0.0014980182, 0.0014973249, 0.0014968634, 0.0014960979, 0.0014956469, 0.0014949647, 0.0014945118, + 0.001493834, 0.0014934631, 0.0014927755, 0.0014923175, 0.0014916352, 0.0014912592, 0.0014905699, 0.0014901105, + 0.0014894244, 0.0014890463, 0.0014883555, 0.001487895, 0.0014872089, 0.0014868292, 0.0014861388, 0.0014856766, + 0.001484989, 0.0014845319, 0.0014837726, 0.0014833272, 0.0014826522, 0.0014822044, 0.0014815306, 0.0014811631, + 0.0014804855, 0.0014800361, 0.0014793614, 0.0014789912, 0.0014783104, 0.0014778574, 0.0014771797, 0.0014768072, + 0.0014761256, 0.0014756715, 0.0014749925, 0.0014745418, 0.0014737892, 0.0014733473, 0.0014726816, 0.0014722408, + 0.0014715756, 0.0014712135, 0.0014705415, 0.0014700969, 0.0014694288, 0.0014690626, 0.0014683877, 0.0014679391, + 0.0014672681, 0.0014669, 0.0014662243, 0.0014657753, 0.0014651039, 0.0014647361, 0.0014640612, 0.0014636125, + 0.0014629402, 0.0014624937, 0.0014617484, 0.0014613115, 0.001460653, 0.0014602197, 0.0014595621, 0.0014592048, + 0.0014585415, 0.0014581017, 0.00145744, 0.0014570793, 0.0014564131, 0.0014559715, 0.0014553078, 0.001454946, + 0.0014542771, 0.0014538339, 0.0014531709, 0.001452731, 0.0014519952, 0.0014515658, 0.0014509123, 0.0014504828, + 0.0014498327, 0.0014494812, 0.0014488235, 0.0014483882, 0.001447733, 0.0014473787, 0.0014467197, 0.0014462817, + 0.0014456238, 0.0014452651, 0.0014446033, 0.0014441652, 0.0014435053, 0.0014430674, 0.0014423343, 0.0014419055, + 0.0014412592, 0.0014408346, 0.0014401897, 0.0014398404, 0.001439188, 0.0014387581, 0.0014381091, 0.0014377573, + 0.0014371034, 0.001436671, 0.0014360199, 0.0014356667, 0.0014350117, 0.0014345775, 0.0014339254, 0.0014334943, + 0.0014327703, 0.0014323501, 0.0014317097, 0.0014312906, 0.001430653, 0.0014303107, 0.0014296658, 0.0014292379, + 0.0014285949, 0.0014282488, 0.0014276005, 0.0014271715, 0.0014265245, 0.0014260984, 0.0014253813, 0.0014249645, + 0.0014243304, 0.0014239154, 0.0014232072, 0.0014228002, 0.0014221764, 0.001421769, 0.0014211438, 0.0014208117, + 0.0014201788, 0.0014197641, 0.0014191334, 0.0014187942, 0.0014181552, 0.0014177343, 0.0014170995, 0.0014166831, + 0.0014159748, 0.0014155663, 0.0014149415, 0.001414535, 0.0014138381, 0.0014134378, 0.00141282, 0.0014124189, + 0.0014118007, 0.0014114729, 0.0014108462, 0.0014104355, 0.0014098113, 0.001409479, 0.001408848, 0.0014084319, + 0.0014078018, 0.0014073898, 0.0014066888, 0.0014062856, 0.0014056674, 0.001405264, 0.0014046457, 0.0014043167, + 0.0014036925, 0.0014032843, 0.0014026607, 0.0014023267, 0.0014016966, 0.0014012816, 0.0014006555, 0.0014002444, + 0.001399545, 0.0013991421, 0.0013985259, 0.0013981242, 0.0013974337, 0.001397039, 0.0013964305, 0.0013960353, + 0.0013954265, 0.0013951054, 0.0013944895, 0.001394087, 0.0013934725, 0.0013931444, 0.0013925226, 0.0013921156, + 0.0013914969, 0.0013910912, 0.0013903991, 0.0013900015, 0.001389391, 0.0013889933, 0.0013883851, 0.001388063, + 0.0013874477, 0.0013870428, 0.0013864288, 0.0013861029, 0.0013854832, 0.0013850734, 0.0013844534, 0.0013840476, + 0.001383358, 0.0013829615, 0.0013823543, 0.0013819579, 0.0013812772, 0.0013808884, 0.0013802891, 0.0013799001, + 0.0013793021, 0.0013789868, 0.001378377, 0.0013779793, 0.0013773734, 0.001376978, 0.0013762993, 0.0013759115, + 0.0013753141, 0.001374926, 0.0013742544, 0.0013738733, 0.0013732826, 0.0013729002, 0.0013723071, 0.0013719974, + 0.0013713983, 0.0013710079, 0.0013704104, 0.0013700216, 0.0013693491, 0.0013689658, 0.0013683733, 0.0013679879, + 0.0013673229, 0.0013669477, 0.0013663637, 0.0013659875, 0.0013654015, 0.001365096, 0.0013645014, 0.0013641148, + 0.0013635211, 0.0013631342, 0.0013624667, 0.0013620884, 0.0013615019, 0.0013611222, 0.0013604629, 0.0013600906, + 0.001359509, 0.0013591328, 0.0013585503, 0.0013582475, 0.0013576571, 0.0013572725, 0.0013566805, 0.0013563691, + 0.0013557724, 0.0013553833, 0.0013547888, 0.0013544002, 0.0013537343, 0.0013533565, 0.0013527725, 0.0013523919, + 0.0013518061, 0.0013515005, 0.0013509075, 0.0013505215, 0.0013499315, 0.0013496185, 0.0013490219, 0.0013486325, + 0.0013480381, 0.00134765, 0.0013469851, 0.0013466048, 0.0013460203, 0.0013456396, 0.0013450545, 0.0013447484, + 0.0013441591, 0.0013437746, 0.0013431868, 0.0013428018, 0.0013421399, 0.0013417646, 0.0013411863, 0.0013408104, + 0.0013401563, 0.0013397856, 0.0013392132, 0.0013388438, 0.0013382711, 0.0013379754, 0.0013373966, 0.0013370201, + 0.0013364396, 0.0013360629, 0.0013354116, 0.0013350426, 0.0013344702, 0.0013341004, 0.0013334552, 0.0013330926, + 0.0013325268, 0.0013321618, 0.0013315949, 0.0013313021, 0.0013307267, 0.0013303533, 0.0013297796, 0.0013294083, + 0.0013287629, 0.0013283982, 0.0013278318, 0.0013274653, 0.0013268242, 0.0013264643, 0.0013259026, 0.0013255425, + 0.0013249812, 0.0013246916, 0.0013241214, 0.0013237522, 0.0013231827, 0.0013228119, 0.0013221698, 0.001321808, + 0.0013212459, 0.0013208855, 0.0013202511, 0.0013198933, 0.0013193371, 0.0013189818, 0.0013184249, 0.0013181387, + 0.0013175745, 0.0013172099, 0.0013166465, 0.00131628, 0.0013156416, 0.0013152814, 0.0013147218, 0.0013143619, + 0.0013137321, 0.0013133797, 0.0013128282, 0.0013124734, 0.0013119207, 0.0013115656, 0.0013109386, 0.0013105888, + 0.0013100394, 0.0013096867, 0.0013090639, 0.0013087178, 0.0013081734, 0.0013078236, 0.0013072037, 0.001306859, + 0.0013063162, 0.0013059686, 0.0013054224, 0.0013050714, 0.0013044516, 0.0013041083, 0.001303568, 0.0013032232, + 0.0013026068, 0.001302265, 0.0013017271, 0.0013013836, 0.0013008426, 0.0013005685, 0.001300018, 0.0012996626, + 0.0012991115, 0.0012987573, 0.0012981355, 0.001297786, 0.0012972405, 0.0012968906, 0.0012962724, 0.0012959272, + 0.0012953866, 0.0012950412, 0.001294501, 0.0012941539, 0.0012935397, 0.0012931982, 0.0012926603, 0.0012923161, + 0.001291706, 0.0012913676, 0.0012908326, 0.0012904914, 0.0012899559, 0.0012896846, 0.0012891393, 0.0012887886, + 0.0012882442, 0.001287893, 0.0012872765, 0.0012869323, 0.0012863937, 0.0012860461, 0.0012854338, 0.0012850943, + 0.0012845612, 0.0012842194, 0.0012836828, 0.0012833396, 0.0012827319, 0.0012823936, 0.0012818616, 0.0012815228, + 0.0012809183, 0.001280582, 0.0012800534, 0.0012797165, 0.0012791142, 0.0012787803, 0.0012782541, 0.0012779186, + 0.0012773912, 0.0012770541, 0.001276452, 0.0012761195, 0.0012755949, 0.0012752607, 0.0012746633, 0.0012743326, + 0.0012738098, 0.0012734766, 0.001272951, 0.0012726155, 0.0012720174, 0.0012716873, 0.001271165, 0.0012708314, + 0.001270236, 0.001269908, 0.0012693895, 0.0012690591, 0.0012684668, 0.0012681417, 0.0012676241, 0.0012672954, + 0.0012667765, 0.0012664455, 0.0012658522, 0.0012655247, 0.0012650059, 0.0012646758, 0.0012640868, 0.0012637638, + 0.0012632476, 0.0012629183, 0.0012624005, 0.0012620686, 0.0012614776, 0.0012611533, 0.0012606373, 0.0012603088, + 0.0012597201, 0.0012593964, 0.0012588835, 0.0012585571, 0.0012580425, 0.0012577146, 0.0012571273, 0.001256804, + 0.00125629, 0.0012559623, 0.0012553765, 0.0012550552, 0.0012545451, 0.0012542197, 0.0012536359, 0.0012533145, + 0.0012528042, 0.0012524799, 0.0012519679, 0.0012516414, 0.0012510575, 0.0012507368, 0.0012502298, 0.0012499066, + 0.001249323, 0.0012490017, 0.0012484933, 0.001248169, 0.0012476589, 0.0012473342, 0.0012467508, 0.0012464315, + 0.0012459271, 0.0012456056, 0.0012450262, 0.0012447084, 0.0012442035, 0.0012438815, 0.0012433035, 0.0012429159, + 0.0012423495, 0.0012420441, 0.0012415505, 0.0012412382, 0.001240671, 0.0012403645, 0.0012398702, 0.0012395575, + 0.0012389884, 0.0012386792, 0.0012381849, 0.0012378735, 0.0012373762, 0.0012370594, 0.0012364879, 0.0012361762, + 0.0012356793, 0.001235364, 0.0012347939, 0.001234484, 0.0012339882, 0.0012336737, 0.0012331755, 0.0012328599, + 0.0012322881, 0.0012319738, 0.0012314772, 0.0012311629, 0.0012305947, 0.0012302842, 0.0012297885, 0.0012294737, + 0.0012289761, 0.0012286593, 0.00122809, 0.0012277791, 0.0012272841, 0.0012269694, 0.0012264015, 0.0012260905, + 0.0012255955, 0.0012252814, 0.0012247163, 0.0012243369, 0.001223782, 0.001223483, 0.0012230002, 0.001222697, + 0.0012221413, 0.0012218407, 0.001221358, 0.0012210535, 0.0012204973, 0.0012201264, 0.0012195783, 0.0012192836, + 0.0012188073, 0.00121851, 0.001217961, 0.0012176662, 0.0012171878, 0.0012168866, 0.0012163341, 0.0012159672, + 0.0012154264, 0.0012151375, 0.0012146668, 0.0012143718, 0.0012138247, 0.0012135328, 0.0012130596, 0.0012127628, + 0.0012122161, 0.0012118525, 0.0012113141, 0.0012110283, 0.0012105625, 0.0012102711, 0.0012097297, 0.0012094408, + 0.0012089701, 0.0012086739, 0.0012081275, 0.0012078331, 0.0012073608, 0.0012070646, 0.0012065874, 0.0012062851, + 0.0012057346, 0.0012054362, 0.001204959, 0.0012046583, 0.0012041093, 0.0012038113, 0.0012033351, 0.0012030354, + 0.0012025553, 0.0012022499, 0.0012016981, 0.0012013965, 0.0012009174, 0.0012006141, 0.001200064, 0.0011997651, + 0.0011992888, 0.0011989869, 0.0011985082, 0.0011982044, 0.001197653, 0.0011973521, 0.001196875, 0.0011965723, + 0.0011960227, 0.0011957238, 0.001195249, 0.0011949484, 0.0011944026, 0.0011940369, 0.0011935007, 0.0011932129, + 0.0011927474, 0.0011924548, 0.0011919166, 0.0011916268, 0.0011911598, 0.0011908656, 0.0011903263, 0.0011899652, + 0.0011894342, 0.0011891521, 0.0011886932, 0.0011884058, 0.0011878753, 0.0011875908, 0.0011871296, 0.0011868401, + 0.0011863062, 0.0011859512, 0.0011854275, 0.0011851502, 0.001184696, 0.0011844126, 0.001183885, 0.0011836026, + 0.0011831458, 0.0011828591, 0.0011823276, 0.0011819752, 0.0011814537, 0.0011811772, 0.0011807266, 0.001180445, + 0.0011799203, 0.001179642, 0.0011791888, 0.0011789049, 0.0011783785, 0.0011780274, 0.0011775099, 0.0011772366, + 0.0011767877, 0.0011765081, 0.0011759851, 0.0011756374, 0.0011751236, 0.0011748536, 0.001174342, 0.0011740039, + 0.001173499, 0.0011732368, 0.0011728001, 0.0011725307, 0.0011720185, 0.0011716803, 0.0011711761, 0.0011709128, + 0.0011704069, 0.0011700764, 0.0011695782, 0.0011693201, 0.0011688881, 0.0011686224, 0.0011681166, 0.0011677835, + 0.0011672846, 0.0011670262, 0.0011665935, 0.0011663263, 0.0011658198, 0.0011655535, 0.0011651147, 0.0011648416, + 0.0011643273, 0.0011639873, 0.0011634821, 0.0011632176, 0.0011627825, 0.0011625127, 0.0011620033, 0.0011617325, + 0.0011612909, 0.0011610155, 0.0011605014, 0.0011601606, 0.0011596567, 0.0011593923, 0.0011589555, 0.0011586846, + 0.0011581756, 0.0011579057, 0.0011574657, 0.0011571908, 0.0011566787, 0.001156338, 0.0011558359, 0.001155572, + 0.001155137, 0.0011548665, 0.0011543581, 0.0011540876, 0.001153648, 0.0011533725, 0.0011528603, 0.0011525204, + 0.0011520176, 0.0011517528, 0.0011513195, 0.0011510497, 0.0011505422, 0.0011502728, 0.0011498362, 0.0011495627, + 0.0011490537, 0.0011487142, 0.0011482139, 0.0011479508, 0.0011475194, 0.0011472513, 0.0011467473, 0.0011464112, + 0.0011459135, 0.0011456542, 0.0011451597, 0.0011448328, 0.0011443448, 0.0011440908, 0.0011436674, 0.0011434064, + 0.0011429114, 0.0011425839, 0.0011420965, 0.0011418439, 0.0011413546, 0.0011410331, 0.001140552, 0.0011403044, + 0.0011398888, 0.0011396322, 0.0011391408, 0.0011388174, 0.0011383343, 0.0011380847, 0.0011376687, 0.0011374119, + 0.0011369197, 0.0011366617, 0.0011362378, 0.0011359737, 0.0011354788, 0.0011351506, 0.0011346616, 0.0011344061, + 0.0011339856, 0.0011337256, 0.0011332335, 0.0011329062, 0.0011324205, 0.001132168, 0.0011316832, 0.0011313643, + 0.0011308861, 0.0011306396, 0.0011302275, 0.0011299738, 0.0011294874, 0.001129166, 0.0011286868, 0.001128439, + 0.0011279598, 0.001127645, 0.0011271719, 0.0011269293, 0.0011265205, 0.0011262702, 0.0011257898, 0.0011254721, + 0.0011249975, 0.0011247541, 0.0011242784, 0.0011239651, 0.0011234944, 0.0011232536, 0.0011228477, 0.0011225992, + 0.0011221215, 0.0011218063, 0.001121335, 0.0011210927, 0.0011206859, 0.0011204358, 0.0011199552, 0.0011196376, + 0.0011191647, 0.0011189217, 0.0011184487, 0.0011181366, 0.0011176687, 0.0011174296, 0.0011170267, 0.0011167796, + 0.0011163044, 0.0011159915, 0.0011155228, 0.0011152819, 0.001114812, 0.0011145038, 0.0011140403, 0.0011138035, + 0.0011134037, 0.0011131589, 0.0011126855, 0.001112374, 0.0011119079, 0.0011116683, 0.0011112018, 0.0011108959, + 0.0011104348, 0.0011101337, 0.0011096764, 0.001109444, 0.0011089846, 0.0011086856, 0.0011082315, 0.0011080033, + 0.0011076127, 0.0011073734, 0.0011069067, 0.001106601, 0.0011061413, 0.0011059074, 0.0011054461, 0.0011051437, + 0.0011046885, 0.0011044584, 0.0011040677, 0.0011038285, 0.0011033625, 0.0011030557, 0.0011025962, 0.0011023624, + 0.001101903, 0.0011016006, 0.0011011447, 0.0011008468, 0.0011003952, 0.0011001673, 0.0010997134, 0.0010994179, + 0.0010989701, 0.0010987436, 0.0010983578, 0.0010981241, 0.0010976644, 0.0010973632, 0.0010969094, 0.0010966782, + 0.0010962237, 0.0010959258, 0.0010954742, 0.0010952451, 0.0010948598, 0.0010946244, 0.0010941642, 0.0010938601, + 0.0010934055, 0.0010931747, 0.0010927202, 0.001092421, 0.0010919706, 0.0010916772, 0.0010912322, 0.0010910089, + 0.0010905613, 0.001090268, 0.0010898246, 0.001089602, 0.0010892218, 0.0010889897, 0.0010885351, 0.0010882365, + 0.0010877867, 0.0010875585, 0.0010871084, 0.0010868134, 0.0010863671, 0.0010860764, 0.0010856367, 0.001085417, + 0.0010849742, 0.0010846849, 0.0010842461, 0.0010840256, 0.0010836474, 0.0010834178, 0.0010829681, 0.0010826719, + 0.0010822256, 0.0010819981, 0.0010815504, 0.0010812576, 0.0010808164, 0.0010805279, 0.0010800901, 0.0010798714, + 0.0010794315, 0.0010791431, 0.001078707, 0.001078489, 0.0010780497, 0.0010777636, 0.0010773297, 0.0010770469, + 0.0010766153, 0.0010764007, 0.0010759642, 0.0010756807, 0.0010752502, 0.0010750366, 0.0010746669, 0.0010744429, + 0.0010740001, 0.0010737093, 0.0010732712, 0.0010730498, 0.00107261, 0.0010723219, 0.0010718855, 0.0010716004, + 0.0010711689, 0.001070954, 0.0010705204, 0.0010702374, 0.0010698072, 0.0010695942, 0.0010692278, 0.0010690046, + 0.0010685625, 0.001068271, 0.0010678349, 0.0010676151, 0.0010671765, 0.0010668883, 0.0010664542, 0.0010661701, + 0.0010657407, 0.0010655266, 0.0010650947, 0.0010648117, 0.001064383, 0.001064169, 0.0010637374, 0.0010634563, + 0.0010630294, 0.001062751, 0.0010623275, 0.001062118, 0.0010616911, 0.0010614137, 0.0010609908, 0.0010607163, + 0.0010602969, 0.0010600904, 0.0010596674, 0.0010593921, 0.0010589716, 0.0010587644, 0.0010583404, 0.0010580646, + 0.0010576434, 0.0010573701, 0.0010569525, 0.0010567461, 0.0010563255, 0.0010560529, 0.0010556347, 0.0010553629, + 0.0010549469, 0.0010547424, 0.0010543219, 0.0010540499, 0.0010536351, 0.0010534322, 0.0010530133, 0.0010527396, + 0.0010523231, 0.0010520539, 0.0010516404, 0.0010514363, 0.0010510179, 0.0010507469, 0.001050334, 0.0010500664, + 0.001049655, 0.0010494537, 0.0010490379, 0.0010487679, 0.0010483551, 0.0010481525, 0.0010477357, 0.0010474636, + 0.001047049, 0.001046779, 0.0010463665, 0.0010461649, 0.0010457509, 0.0010454827, 0.0010450715, 0.0010448042, + 0.0010443961, 0.0010441971, 0.0010437841, 0.001043516, 0.0010431061, 0.0010428397, 0.0010423663, 0.0010421082, + 0.0010417101, 0.0010414553, 0.0010410572, 0.0010408653, 0.0010404603, 0.0010401995, 0.0010397977, 0.0010395384, + 0.0010391382, 0.0010389461, 0.0010385412, 0.0010382783, 0.0010378748, 0.0010376135, 0.0010371469, 0.0010368945, + 0.0010365002, 0.0010362476, 0.0010358543, 0.0010356668, 0.0010352681, 0.0010350107, 0.001034613, 0.0010343576, + 0.001033962, 0.0010337718, 0.0010333693, 0.001033109, 0.0010327103, 0.0010324529, 0.0010320554, 0.0010318636, + 0.0010314612, 0.0010312005, 0.0010308007, 0.0010306054, 0.0010302019, 0.0010299401, 0.0010295387, 0.0010292785, + 0.0010288785, 0.0010286844, 0.001028282, 0.0010280199, 0.0010276187, 0.0010273574, 0.0010269586, 0.001026765, + 0.0010263625, 0.0010260995, 0.0010256973, 0.001025437, 0.0010249761, 0.0010247257, 0.0010243352, 0.0010240843, + 0.0010236955, 0.0010235085, 0.0010231134, 0.0010228582, 0.001022466, 0.0010222133, 0.0010218226, 0.0010216337, + 0.0010212372, 0.0010209811, 0.0010205872, 0.0010203327, 0.0010198787, 0.001019632, 0.0010192461, 0.0010189991, + 0.0010186151, 0.0010183688, 0.0010179216, 0.0010176811, 0.001017303, 0.0010170627, 0.0010166849, 0.0010165077, + 0.0010161237, 0.0010158783, 0.001015495, 0.0010152486, 0.0010148655, 0.0010146837, 0.0010142962, 0.0010140459, + 0.0010136596, 0.0010134099, 0.0010129598, 0.0010127164, 0.0010123379, 0.0010120954, 0.0010117155, 0.0010115363, + 0.0010111524, 0.0010109042, 0.0010105212, 0.0010102746, 0.0010098922, 0.0010097104, 0.0010093228, 0.0010090722, + 0.0010086867, 0.0010084368, 0.0010079897, 0.001007748, 0.0010073717, 0.00100713, 0.0010067527, 0.0010065114, + 0.0010060715, 0.0010058357, 0.0010054642, 0.0010052276, 0.0010048564, 0.0010046826, 0.0010043044, 0.0010040621, + 0.0010036863, 0.0010034447, 0.0010030689, 0.001002891, 0.0010025083, 0.0010022611, 0.001001881, 0.001001635, + 0.0010011926, 0.0010009538, 0.0010005803, 0.0010003406, 0.00099996885, 0.00099973066, 0.0009992955, 0.00099906267, + 0.00099869573, 0.00099846267, 0.00099809596, 0.00099792506, 0.00099755125, 0.00099731039, 0.00099693716, + 0.00099669769, 0.00099632586, 0.00099615089, 0.00099577336, 0.00099552667, 0.00099514751, 0.00099490408, + 0.00099446601, 0.00099422969, 0.00099386135, 0.00099362561, 0.00099325785, 0.00099302165, 0.00099258986, + 0.00099235936, 0.00099199731, 0.00099176634, 0.00099140254, 0.00099117006, 0.00099074317, 0.00099051616, + 0.00099015655, 0.00098992907, 0.00098956982, 0.00098940264, 0.00098903524, 0.00098879973, 0.00098843384, + 0.00098819891, 0.00098777039, 0.00098754209, 0.00098718225, 0.00098695164, 0.00098659121, 0.00098636211, + 0.00098593766, 0.0009857117, 0.0009853557, 0.00098512939, 0.00098477281, 0.00098454487, 0.00098412356, + 0.00098390062, 0.000983548, 0.00098332576, 0.00098297186, 0.00098280865, 0.0009824466, 0.00098221446, + 0.00098185206, 0.00098161981, 0.00098119525, 0.00098096894, 0.00098061422, 0.00098038837, 0.00098003214, + 0.00097980455, 0.00097938452, 0.0009791624, 0.0009788106, 0.00097858661, 0.00097823353, 0.00097800896, + 0.00097759161, 0.00097737077, 0.00097702094, 0.00097679906, 0.00097644934, 0.00097622769, 0.00097581372, + 0.00097559497, 0.00097524736, 0.00097502815, 0.00097461703, 0.00097440084, 0.00097405585, 0.00097383809, + 0.00097349205, 0.00097327307, 0.00097286247, 0.00097264606, 0.00097230182, 0.000972084, 0.00097173807, + 0.00097151787, 0.00097110769, 0.00097089226, 0.00097054779, 0.00097033015, 0.00096998451, 0.00096976431, + 0.00096935412, 0.00096913887, 0.00096879585, 0.00096857926, 0.0009682352, 0.00096801639, 0.0009676083, + 0.00096739485, 0.00096705381, 0.00096683763, 0.00096643192, 0.00096621964, 0.00096588052, 0.00096566632, + 0.00096532557, 0.00096510991, 0.0009647042, 0.00096449064, 0.00096415053, 0.00096393598, 0.00096359471, + 0.000963378, 0.00096297346, 0.00096276088, 0.00096242211, 0.0009622089, 0.00096186908, 0.00096165255, + 0.00096124795, 0.00096103671, 0.0009606994, 0.00096048589, 0.0009601459, 0.00095992972, 0.00095952628, + 0.00095931324, 0.000958975, 0.00095876044, 0.00095835904, 0.00095808803, 0.00095769763, 0.00095749716, + 0.00095716998, 0.00095696386, 0.00095656991, 0.0009563677, 0.00095603976, 0.00095583394, 0.00095550308, + 0.00095529429, 0.00095489848, 0.00095469179, 0.0009543596, 0.00095415121, 0.00095381832, 0.00095360744, + 0.00095321081, 0.00095300475, 0.00095267309, 0.00095246348, 0.00095213001, 0.00095191755, 0.00095152028, + 0.00095131242, 0.00095097843, 0.00095076731, 0.00095037115, 0.00095010211, 0.00094971503, 0.00094951631, + 0.00094919343, 0.00094899122, 0.00094860443, 0.00094834389, 0.00094796432, 0.00094777241, 0.00094745582, + 0.00094725925, 0.00094687718, 0.00094668195, 0.00094636227, 0.00094616314, 0.0009458416, 0.00094563974, + 0.00094525225, 0.00094505219, 0.0009447289, 0.00094452593, 0.00094420067, 0.00094399601, 0.00094360643, + 0.00094340323, 0.00094307808, 0.00094287354, 0.00094254594, 0.00094233756, 0.00094194594, 0.00094174186, + 0.00094141596, 0.00094120996, 0.0009408195, 0.00094055524, 0.00094017538, 0.00093998061, 0.00093966373, + 0.00093946484, 0.00093908288, 0.00093882583, 0.00093845261, 0.00093826378, 0.00093795237, 0.00093775993, + 0.00093738281, 0.0009371292, 0.00093675946, 0.00093657477, 0.00093626836, 0.00093607814, 0.00093570363, + 0.00093551457, 0.00093520433, 0.00093501149, 0.00093469699, 0.00093449943, 0.0009341198, 0.0009339251, + 0.00093360955, 0.00093341124, 0.00093309168, 0.00093288993, 0.00093250757, 0.00093230943, 0.00093199074, + 0.00093178899, 0.00093140703, 0.00093114865, 0.00093077548, 0.00093058578, 0.00093027548, 0.00093008106, + 0.00092970551, 0.00092945248, 0.00092908472, 0.00092890067, 0.00092859566, 0.0009284055, 0.0009280353, + 0.00092778652, 0.00092742348, 0.00092724158, 0.0009269382, 0.00092675001, 0.00092638237, 0.00092613616, + 0.00092577474, 0.00092559488, 0.00092529535, 0.00092511089, 0.00092474598, 0.00092450174, 0.00092414272, + 0.00092396513, 0.00092366827, 0.00092348416, 0.00092311914, 0.00092293485, 0.00092263223, 0.00092244509, + 0.00092213805, 0.00092194497, 0.00092157343, 0.00092138309, 0.000921075, 0.00092088192, 0.00092050945, + 0.0009202573, 0.00091989333, 0.00091970904, 0.00091940735, 0.00091922062, 0.00091885426, 0.00091860699, + 0.0009182482, 0.00091806857, 0.00091777096, 0.00091758621, 0.00091722247, 0.00091697852, 0.00091662299, + 0.00091644563, 0.00091614935, 0.00091596582, 0.00091560383, 0.00091536104, 0.00091500673, 0.00091483095, + 0.00091453712, 0.00091435539, 0.0009139952, 0.00091375364, 0.00091340131, 0.00091322634, 0.00091293344, + 0.0009127527, 0.00091239472, 0.00091215502, 0.0009118056, 0.00091163372, 0.00091134309, 0.00091116375, + 0.00091080752, 0.00091056811, 0.00091021764, 0.00091004441, 0.00090975419, 0.00090957485, 0.0009092195, + 0.00090898148, 0.00090863305, 0.00090846122, 0.00090817246, 0.00090799452, 0.00090763997, 0.00090746174, + 0.0009071675, 0.00090698374, 0.00090662419, 0.00090638269, 0.00090603181, 0.00090585666, 0.00090556586, + 0.00090538483, 0.0009050286, 0.0009047889, 0.00090443966, 0.00090426684, 0.00090397859, 0.0009037992, + 0.00090344297, 0.00090320304, 0.00090285495, 0.00090268318, 0.00090239587, 0.00090221793, 0.0009018656, + 0.00090162846, 0.00090128265, 0.00090111175, 0.00090082479, 0.00090064685, 0.00090029504, 0.00090005965, + 0.00089971564, 0.00089954608, 0.00089926162, 0.00089908624, 0.00089873676, 0.00089850143, 0.00089815789, + 0.0008979892, 0.00089770532, 0.00089752936, 0.00089717971, 0.00089694461, 0.00089660136, 0.00089643203, + 0.0008961492, 0.00089597376, 0.00089562457, 0.00089538988, 0.00089504762, 0.00089487812, 0.00089459517, + 0.00089442061, 0.00089407392, 0.00089384109, 0.00089350081, 0.00089333334, 0.00089305273, 0.00089287956, + 0.00089253281, 0.00089230022, 0.00089196063, 0.00089179253, 0.00089145126, 0.0008912225, 0.00089088653, + 0.00089066342, 0.00089033332, 0.00089017494, 0.00088984263, 0.00088962173, 0.00088929379, 0.00088907679, + 0.00088875304, 0.0008886006, 0.0008882737, 0.00088805764, 0.00088773458, 0.00088752294, 0.00088720326, + 0.00088705355, 0.00088673085, 0.0008865181, 0.00088619842, 0.0008859894, 0.00088567374, 0.00088552688, + 0.00088520604, 0.00088499591, 0.0008846781, 0.00088447105, 0.00088415766, 0.00088401308, 0.00088369567, + 0.0008834867, 0.00088317128, 0.00088296481, 0.00088265102, 0.00088250649, 0.0008821899, 0.00088198221, + 0.00088166818, 0.00088152272, 0.00088126445, 0.00088110944, 0.00088078313, 0.00088056712, 0.00088024657, + 0.00088009419, 0.00087982969, 0.0008796695, 0.00087933842, 0.00087911647, 0.00087878987, 0.00087863253, + 0.00087836367, 0.00087819842, 0.00087786437, 0.00087764033, 0.00087731215, 0.00087715324, 0.00087688363, + 0.00087671715, 0.00087638164, 0.0008761565, 0.00087582704, 0.00087566517, 0.00087539427, 0.00087522663, + 0.00087488961, 0.00087466295, 0.00087433349, 0.00087417144, 0.00087389973, 0.00087373157, 0.00087339542, + 0.00087316841, 0.00087283779, 0.00087267515, 0.00087240333, 0.00087223412, 0.00087189779, 0.0008716709, + 0.00087134127, 0.00087117864, 0.00087090762, 0.00087073911, 0.00087040343, 0.00087017647, 0.00086984807, + 0.00086968532, 0.0008694139, 0.00086924573, 0.00086891034, 0.00086868362, 0.00086835522, 0.00086819322, + 0.00086792209, 0.00086775352, 0.00086741988, 0.00086719421, 0.00086686655, 0.0008667052, 0.00086643599, + 0.00086626853, 0.00086593436, 0.00086570811, 0.0008653804, 0.00086521794, 0.00086494826, 0.00086478062, + 0.00086444733, 0.00086422137, 0.00086389558, 0.00086373551, 0.00086340908, 0.00086318981, 0.00086286885, + 0.00086265337, 0.00086233712, 0.00086218538, 0.00086186733, 0.0008616554, 0.00086134137, 0.00086113322, + 0.00086082408, 0.00086067815, 0.00086036604, 0.00086015934, 0.00085985078, 0.00085964717, 0.00085934228, + 0.00085919996, 0.00085889164, 0.00085868774, 0.0008583832, 0.00085818337, 0.00085788139, 0.00085774122, + 0.00085743575, 0.00085723441, 0.00085693313, 0.00085673534, 0.0008564351, 0.00085629697, 0.00085599307, + 0.00085579284, 0.0008554922, 0.00085529534, 0.00085499673, 0.00085485849, 0.00085455505, 0.00085435557, + 0.00085405639, 0.00085386052, 0.00085356238, 0.00085342623, 0.00085312524, 0.00085292646, 0.00085262832, + 0.00085243274, 0.00085213582, 0.00085200043, 0.00085170037, 0.00085150282, 0.00085120555, 0.00085101067, + 0.00085071562, 0.00085058081, 0.00085028197, 0.00085008558, 0.00084978907, 0.00084959489, 0.00084930065, + 0.00084916624, 0.00084886723, 0.0008486709, 0.00084837561, 0.00084818195, 0.00084788847, 0.00084769598, + 0.00084734545, 0.00084715959, 0.00084687339, 0.00084668823, 0.00084640272, 0.00084621791, 0.00084587553, + 0.0008456962, 0.00084541662, 0.0008452367, 0.00084495527, 0.00084477389, 0.00084443565, 0.00084426062, + 0.00084398518, 0.00084380922, 0.00084353244, 0.00084335491, 0.00084301911, 0.00084284681, 0.00084257376, + 0.00084239867, 0.00084212399, 0.00084194896, 0.00084161671, 0.00084144616, 0.00084117497, 0.00084100192, + 0.00084072945, 0.00084055535, 0.00084022403, 0.00084005471, 0.00083978457, 0.00083961315, 0.00083934248, + 0.00083916902, 0.0008388384, 0.00083866942, 0.00083840109, 0.00083823095, 0.00083796121, 0.0008377888, + 0.00083751744, 0.00083740178, 0.00083712366, 0.00083694345, 0.00083666522, 0.00083648547, 0.0008362073, + 0.00083608524, 0.00083580089, 0.00083561405, 0.00083533011, 0.00083514513, 0.00083486288, 0.00083473662, + 0.00083444885, 0.00083425915, 0.00083397201, 0.00083378376, 0.0008334989, 0.00083336892, 0.00083307922, + 0.00083288847, 0.00083260081, 0.00083241105, 0.00083212444, 0.00083199283, 0.00083170121, 0.0008315086, + 0.00083121978, 0.00083102827, 0.00083074061, 0.00083060906, 0.00083031802, 0.00083012407, 0.00082983507, + 0.0008296445, 0.00082935777, 0.00082922593, 0.00082893507, 0.00082874222, 0.00082845375, 0.00082826288, + 0.0008279758, 0.0008278428, 0.00082755066, 0.00082735665, 0.00082706846, 0.00082687777, 0.00082659157, + 0.0008264599, 0.00082616927, 0.00082597591, 0.00082568754, 0.00082549668, 0.00082521146, 0.00082507939, + 0.00082478975, 0.00082459743, 0.00082430965, 0.00082411821, 0.00082383229, 0.00082364317, 0.0008233019, + 0.00082312064, 0.00082284515, 0.00082266401, 0.0008223874, 0.00082220603, 0.00082187227, 0.00082169729, + 0.00082142715, 0.00082125177, 0.00082098157, 0.00082080608, 0.00082047813, 0.00082030805, 0.00082004222, + 0.00081986975, 0.00081960252, 0.00081943127, 0.00081910787, 0.00081894104, 0.00081867934, 0.00081851135, + 0.00081824663, 0.0008180759, 0.00081775419, 0.00081758905, 0.00081732875, 0.0008171614, 0.00081689918, + 0.00081673072, 0.00081641041, 0.00081624638, 0.00081598852, 0.0008158235, 0.00081556337, 0.00081539666, + 0.00081507734, 0.00081491348, 0.00081465539, 0.00081448985, 0.00081423036, 0.00081406365, 0.00081374578, + 0.0008135832, 0.00081332546, 0.00081316096, 0.00081290264, 0.00081273611, 0.00081241853, 0.00081225659, + 0.00081200106, 0.0008118375, 0.00081157987, 0.00081141421, 0.00081115542, 0.00081104616, 0.00081078103, + 0.00081060786, 0.00081034092, 0.0008101674, 0.00080990203, 0.00080972916, 0.00080940576, 0.00080923742, + 0.00080897688, 0.0008088079, 0.00080854492, 0.00080837449, 0.0008080554, 0.00080789044, 0.00080763275, + 0.00080746697, 0.00080720888, 0.00080704177, 0.00080672477, 0.00080656225, 0.00080630789, 0.00080614415, + 0.00080588716, 0.00080572104, 0.00080540584, 0.0008052442, 0.00080498954, 0.00080482522, 0.00080456887, + 0.0008044038, 0.00080408953, 0.00080392789, 0.00080367428, 0.00080351083, 0.00080325478, 0.00080308988, + 0.00080277753, 0.00080261764, 0.00080236507, 0.00080220343, 0.0008019497, 0.00080178585, 0.00080147356, + 0.0008013125, 0.00080105988, 0.00080089847, 0.00080064597, 0.00080048334, 0.00080017268, 0.00080001378, + 0.00079976249, 0.00079960044, 0.00079934741, 0.00079918368, 0.0007988725, 0.00079865719, 0.00079835602, + 0.00079820474, 0.00079796155, 0.00079780811, 0.000797563, 0.00079740654, 0.00079710287, 0.00079694955, + 0.0007967042, 0.00079654786, 0.00079630018, 0.00079614081, 0.00079583423, 0.00079567818, 0.00079543126, + 0.00079527294, 0.00079502456, 0.00079486577, 0.00079456018, 0.00079440529, 0.00079415948, 0.00079400087, + 0.00079375203, 0.00079359178, 0.0007932845, 0.0007931267, 0.00079287915, 0.00079272001, 0.00079247158, + 0.00079231156, 0.00079200539, 0.00079184899, 0.00079160277, 0.00079144351, 0.00079119467, 0.00079103466, + 0.00079072895, 0.00079051557, 0.00079021824, 0.00079007016, 0.0007898325, 0.00078968267, 0.00078938605, + 0.0007891811, 0.00078889134, 0.00078874896, 0.00078851648, 0.0007883705, 0.00078807835, 0.00078787736, + 0.0007875915, 0.00078745349, 0.00078722462, 0.00078708102, 0.00078684796, 0.00078670064, 0.00078640768, + 0.00078626338, 0.00078602962, 0.00078588125, 0.00078564259, 0.00078549038, 0.00078519434, 0.00078504538, + 0.00078480697, 0.00078465481, 0.00078441377, 0.00078425941, 0.0007839601, 0.00078380905, 0.00078357017, + 0.00078341644, 0.00078317412, 0.00078301749, 0.00078271708, 0.00078250881, 0.00078221771, 0.00078207353, + 0.0007818407, 0.00078169239, 0.00078139949, 0.00078119728, 0.00078091247, 0.00078077335, 0.00078054529, + 0.00078040198, 0.0007801145, 0.00077991723, 0.00077963731, 0.00077950268, 0.00077927805, 0.00077913684, + 0.00077885151, 0.00077865628, 0.00077837898, 0.00077824702, 0.00077802525, 0.00077788631, 0.00077765918, + 0.00077751576, 0.00077722908, 0.00077708793, 0.00077685853, 0.00077671331, 0.00077648065, 0.0007763321, + 0.00077604066, 0.00077583845, 0.00077555474, 0.00077541708, 0.000775191, 0.00077504793, 0.00077476213, + 0.00077456504, 0.00077428547, 0.00077414967, 0.00077392597, 0.00077378529, 0.00077350292, 0.00077330926, + 0.00077303324, 0.00077290012, 0.00077267957, 0.00077254203, 0.00077226199, 0.00077206967, 0.00077179488, + 0.00077166309, 0.00077144417, 0.0007713082, 0.00077102846, 0.00077083631, 0.00077056471, 0.00077043555, + 0.00077021768, 0.00077008194, 0.00076985941, 0.00076971902, 0.00076943659, 0.00076924235, 0.00076896802, + 0.00076883595, 0.00076861656, 0.00076847908, 0.00076819945, 0.00076800771, 0.00076773559, 0.00076760486, + 0.00076738669, 0.00076725078, 0.00076697319, 0.00076678215, 0.00076651108, 0.00076638156, 0.00076616538, + 0.00076603063, 0.00076575432, 0.00076556468, 0.00076529494, 0.00076516642, 0.00076495192, 0.00076481811, + 0.00076454302, 0.00076435483, 0.00076408609, 0.00076395727, 0.00076374173, 0.00076360721, 0.00076338754, + 0.000763249, 0.0007629696, 0.00076277729, 0.00076250528, 0.00076237519, 0.00076215947, 0.00076202344, + 0.00076174701, 0.00076155644, 0.00076128636, 0.00076115708, 0.00076094188, 0.00076080736, 0.00076053326, + 0.00076034444, 0.00076007633, 0.00075994857, 0.00075973594, 0.00075960264, 0.00075932947, 0.00075914181, + 0.00075887394, 0.00075874606, 0.00075853372, 0.000758401, 0.00075812859, 0.00075794087, 0.00075767364] + run3 = [0.19196351, 0.091059953, 0.0362758, 0.012824859, 0.0042401007, 0.0013526141, 0.00042205845, 0.00012939602, + 3.903449e-05, 1.1579151e-05, 3.3806659e-06, 9.6812869e-07, 2.7218476e-07, 7.5073842e-08, 2.0223904e-08, + 5.3321623e-09, 1.3634635e-09, 3.4914369e-10, 8.7817767e-11, 2.2855481e-11, 5.6689479e-12, 1.6426149e-12, + 2.1838817e-13, 1.3663947e-13, 5.8704147e-14, 5.8478714e-14, 3.3034305e-14, 3.2907474e-14, 3.2780887e-14, + 2.7491139e-14, 2.7375448e-14, 2.0378786e-14, 1.6257239e-14, 9.500153e-15, 9.4548198e-15, 9.409595e-15, + 6.7025455e-15, 6.6644764e-15, 6.6265158e-15, 6.5886636e-15, 6.5509198e-15, 6.5132844e-15, 2.5674255e-15, + 2.5556416e-15, 2.5438847e-15, 2.532155e-15, 1.8278641e-15, 1.8179233e-15, 1.8080096e-15, 1.798123e-15, + 1.7882636e-15, 1.7784312e-15, 1.768626e-15, 1.7588478e-15, 1.7490968e-15, 1.7393728e-15, 1.1654572e-15, + 1.1575222e-15, 3.6118247e-16, 3.5677112e-16, 3.5238688e-16, 3.4802974e-16, 3.4369971e-16, 3.3939678e-16, + 3.3512096e-16, 1.3484849e-16, 1.3484849e-16, 1.3484849e-16, 1.3484849e-16, 1.3484849e-16, 1.3484849e-16, + 1.3484849e-16, 1.3484849e-16, 1.3484849e-16, 3.3512096e-16, 1.3484849e-16, 3.3512096e-16, 1.3484849e-16, + 3.3512096e-16, 1.3484849e-16, 3.3512096e-16, 1.3484849e-16, 3.3512096e-16, 1.3484849e-16, 3.3512096e-16, + 1.3484849e-16, 3.3512096e-16, 1.3484849e-16, 3.3512096e-16, 1.3484849e-16, 3.3512096e-16, 3.6339831e-16, + 3.3512096e-16, 3.6339831e-16, 3.3512096e-16, 3.6339831e-16, 3.3512096e-16, 3.6339831e-16, 3.3939678e-16, + 1.1784685e-16, 3.6339831e-16, 3.3939678e-16, 3.6339831e-16, 3.3939678e-16, 3.6339831e-16, 3.3939678e-16, + 3.6339831e-16, 3.3939678e-16, 3.6339831e-16, 3.3939678e-16, 3.6339831e-16, 3.9849182e-15, 5.1551179e-15, + 5.1599573e-14, 7.0798906e-13, 6.5942043e-12, 7.5642041e-11, 9.3633334e-10, 1.2323223e-08, 1.7281157e-07, + 2.581314e-06, 4.0918148e-05, 0.00064730487, 0.0050754538, 0.0065303696, 0.0068672579, 0.0071375067, 0.0073931455, + 0.0076441481, 0.007894001, 0.008143804, 0.008394191, 0.0086452449, 0.0088970223, 0.0091494517, 0.0094028702, + 0.0096570384, 0.0099118287, 0.010167048, 0.010423006, 0.010679451, 0.010936451, 0.011193766, 0.011451295, + 0.011708812, 0.011966674, 0.012224645, 0.012482625, 0.01274035, 0.012998256, 0.013256085, 0.013514004, 0.013771743, + 0.014029227, 0.014286222, 0.014543193, 0.014799871, 0.015056482, 0.015312711, 0.015568529, 0.015823716, + 0.016078793, 0.016333438, 0.016587906, 0.016841903, 0.017095704, 0.017348712, 0.017601235, 0.017853264, + 0.018105092, 0.018356394, 0.018607447, 0.018857911, 0.019107874, 0.019356994, 0.019605884, 0.019854218, + 0.020102289, 0.020349748, 0.020596942, 0.020843219, 0.021088973, 0.02133413, 0.021579089, 0.021823419, 0.022067515, + 0.022310948, 0.022554094, 0.022796283, 0.023037953, 0.023278998, 0.023519855, 0.023760056, 0.024000008, + 0.024239233, 0.024478236, 0.024716219, 0.024953654, 0.025190426, 0.025427047, 0.025663009, 0.025898727, + 0.026133714, 0.026368478, 0.02660252, 0.026836025, 0.027068466, 0.027300749, 0.027532335, 0.02776376, 0.027994426, + 0.02822488, 0.028454579, 0.028683737, 0.028911842, 0.029139802, 0.029367028, 0.029594066, 0.029820351, 0.030046489, + 0.030271824, 0.030496964, 0.030721314, 0.03094513, 0.031168193, 0.031391092, 0.031612817, 0.031834394, 0.032055214, + 0.032275867, 0.032495685, 0.032715373, 0.032934245, 0.033152588, 0.033370126, 0.03358753, 0.033803701, 0.034019712, + 0.034234919, 0.034450047, 0.034664322, 0.034878459, 0.035091743, 0.035304464, 0.035516325, 0.035728142, + 0.035939123, 0.036149941, 0.036359873, 0.036569647, 0.036778152, 0.036986183, 0.037193414, 0.037400544, + 0.037606798, 0.037812967, 0.038018204, 0.038223326, 0.038427528, 0.038631607, 0.038834769, 0.039037425, + 0.039239183, 0.039440833, 0.039641578, 0.039842252, 0.040041592, 0.040240832, 0.040439121, 0.040637363, + 0.040834688, 0.041031469, 0.041227337, 0.041423179, 0.041618101, 0.041812938, 0.042006806, 0.042200573, + 0.042393375, 0.042586129, 0.042777888, 0.042969074, 0.043159291, 0.043349452, 0.043538637, 0.043727756, 0.04391589, + 0.044103965, 0.044291019, 0.044477519, 0.044662628, 0.044847783, 0.045031946, 0.045216113, 0.045399308, + 0.045582414, 0.045764558, 0.045946687, 0.046127766, 0.046308335, 0.046487946, 0.046667565, 0.046846166, + 0.047024723, 0.047202267, 0.047379773, 0.047556203, 0.047732159, 0.047907118, 0.04808208, 0.048256032, 0.048429921, + 0.048602749, 0.048775561, 0.048947334, 0.049119059, 0.049289703, 0.049459875, 0.049629033, 0.049798183, + 0.049966291, 0.050134402, 0.05030147, 0.050468531, 0.050634481, 0.050799906, 0.050964307, 0.051128708, 0.051292058, + 0.051455434, 0.051617742, 0.051780075, 0.051941343, 0.052102096, 0.052261829, 0.052421622, 0.052580319, + 0.052739076, 0.052896779, 0.053054422, 0.053210981, 0.053367138, 0.053522285, 0.053677462, 0.053831499, + 0.053985562, 0.054138556, 0.054291122, 0.054443095, 0.054595094, 0.054746013, 0.054897007, 0.055046834, + 0.055196617, 0.055345308, 0.055493519, 0.055640642, 0.055787846, 0.055933975, 0.056080118, 0.056225147, + 0.056370236, 0.056514218, 0.056657735, 0.05680022, 0.056942761, 0.057084214, 0.057225786, 0.057366244, 0.057506267, + 0.05764576, 0.057785299, 0.057923704, 0.05806214, 0.058199473, 0.058336381, 0.05847219, 0.058608111, 0.05874297, + 0.058877919, 0.059011761, 0.059145663, 0.059278425, 0.059410755, 0.059542045, 0.059673488, 0.059804346, + 0.059935272, 0.06006505, 0.060194373, 0.060322616, 0.060450949, 0.06057816, 0.060705461, 0.0608317, 0.06095751, + 0.061082255, 0.061207145, 0.061331421, 0.06145579, 0.06157906, 0.061701886, 0.061823636, 0.061945483, 0.062066291, + 0.062187206, 0.062307023, 0.062426478, 0.062545352, 0.06266433, 0.062782221, 0.062899627, 0.063016012, 0.063132599, + 0.06324812, 0.063363761, 0.063478336, 0.063592501, 0.06370616, 0.063819915, 0.06393256, 0.06404534, 0.064157061, + 0.064268343, 0.064378627, 0.064489074, 0.064598918, 0.06470833, 0.064816691, 0.064925209, 0.065032646, 0.065140195, + 0.065246731, 0.065352924, 0.065458573, 0.065564394, 0.065669164, 0.065773495, 0.065876797, 0.065980256, + 0.066082671, 0.066185296, 0.066287413, 0.066389151, 0.06648986, 0.066590674, 0.066690475, 0.066789888, 0.066888817, + 0.066987887, 0.067085862, 0.067183964, 0.067281008, 0.067377672, 0.067473844, 0.06757015, 0.067665406, 0.067760281, + 0.067854188, 0.067948215, 0.068041794, 0.068134971, 0.068227127, 0.068319514, 0.068410918, 0.068501897, + 0.068592407, 0.068683088, 0.0687728, 0.068862095, 0.068950452, 0.069039017, 0.069127142, 0.069215402, 0.069302633, + 0.069389492, 0.069475405, 0.069561474, 0.069647051, 0.069732271, 0.069816552, 0.069900952, 0.069984339, + 0.070067413, 0.070150092, 0.070233002, 0.070314929, 0.070396431, 0.070477486, 0.070558734, 0.070639022, + 0.070718989, 0.07079801, 0.070877232, 0.070956044, 0.071034431, 0.07111191, 0.071189567, 0.071266793, 0.071343638, + 0.071419552, 0.071495682, 0.071571454, 0.071646772, 0.071721151, 0.071795762, 0.071869455, 0.071942739, + 0.072015643, 0.072088182, 0.072159879, 0.072231822, 0.072303444, 0.072374687, 0.072445035, 0.072515562, + 0.072585709, 0.072655447, 0.072724327, 0.072793446, 0.072862238, 0.072930634, 0.072998062, 0.073065683, + 0.073132999, 0.07319992, 0.073265992, 0.073331714, 0.073397167, 0.073462777, 0.073527493, 0.073591866, 0.073655985, + 0.073720239, 0.073783532, 0.073846474, 0.073909193, 0.073972061, 0.074033998, 0.07409554, 0.074156851, 0.074217878, + 0.074278072, 0.074338429, 0.074398488, 0.074458152, 0.074517027, 0.07457608, 0.074634887, 0.074693345, 0.074750967, + 0.074808195, 0.0748652, 0.074922442, 0.074978903, 0.075035006, 0.075090908, 0.075146452, 0.075201198, 0.075256094, + 0.075310767, 0.075365111, 0.07541927, 0.075473577, 0.075527012, 0.075580098, 0.075632952, 0.075685367, 0.075737, + 0.075788908, 0.075840622, 0.075891942, 0.075943112, 0.075993881, 0.076043837, 0.076094024, 0.076144032, + 0.076193668, 0.076242551, 0.076291062, 0.076339439, 0.076387949, 0.076436289, 0.076484151, 0.076531321, + 0.076578222, 0.076624945, 0.076671794, 0.076717913, 0.076763615, 0.076809183, 0.076854371, 0.076899469, + 0.076944701, 0.076989181, 0.077033333, 0.077077344, 0.077120937, 0.077164374, 0.077207416, 0.077249885, + 0.077292547, 0.07733506, 0.077377215, 0.077419303, 0.077460937, 0.077501863, 0.077542976, 0.077584028, 0.077624671, + 0.07766518, 0.077705249, 0.07774467, 0.077783696, 0.077822715, 0.077861942, 0.077901073, 0.077939756, 0.077977799, + 0.078015432, 0.078053065, 0.078090303, 0.078127481, 0.078164823, 0.078202076, 0.078238882, 0.078275084, 0.07831087, + 0.078346603, 0.078381941, 0.078417338, 0.078452848, 0.078487709, 0.078522228, 0.078556724, 0.078590728, + 0.078624733, 0.07865835, 0.078691952, 0.078725144, 0.078757793, 0.078790568, 0.07882338, 0.078855745, 0.078888066, + 0.078919962, 0.078951851, 0.078983255, 0.07901413, 0.079044729, 0.079075344, 0.079106092, 0.079136886, 0.079167157, + 0.079197429, 0.079227321, 0.079257257, 0.079286695, 0.07931558, 0.079344101, 0.079372734, 0.079400875, 0.079429112, + 0.079457439, 0.079485781, 0.079513632, 0.079541534, 0.07956899, 0.079595923, 0.079622447, 0.079649076, 0.079675287, + 0.079701602, 0.079727434, 0.079753369, 0.079779446, 0.079805613, 0.079831325, 0.079856522, 0.079881199, + 0.079905994, 0.07993038, 0.079954863, 0.079978883, 0.08000306, 0.080026783, 0.080050662, 0.080074064, 0.080097601, + 0.080120698, 0.080143861, 0.0801671, 0.080189846, 0.080212131, 0.080234565, 0.080256537, 0.080278635, 0.080300272, + 0.080322027, 0.080343284, 0.080364771, 0.080385759, 0.080406889, 0.080427572, 0.080448434, 0.080468774, 0.08048927, + 0.080509275, 0.080528878, 0.080548078, 0.080567531, 0.080586411, 0.080605485, 0.080624118, 0.080642991, + 0.080661997, 0.080681212, 0.080699854, 0.080718681, 0.080736972, 0.080755487, 0.080773428, 0.080791518, + 0.080809087, 0.080826826, 0.08084406, 0.080861524, 0.080878474, 0.080895677, 0.080912292, 0.080929063, 0.08094532, + 0.080961876, 0.080977902, 0.080993623, 0.081008844, 0.081024311, 0.081039332, 0.081054673, 0.081069499, + 0.081084624, 0.08109919, 0.081114009, 0.081128351, 0.081143022, 0.081157163, 0.081171602, 0.081185542, 0.081199773, + 0.081213415, 0.08122734, 0.081240714, 0.081254385, 0.081267506, 0.081280932, 0.081293814, 0.081307001, 0.08131966, + 0.081332594, 0.08134497, 0.081357688, 0.081369862, 0.081382275, 0.081394091, 0.08140634, 0.081418, 0.081429943, + 0.081441343, 0.081453077, 0.081464171, 0.081475638, 0.081486613, 0.081497908, 0.081508048, 0.081519164, + 0.081529647, 0.081540488, 0.08155068, 0.081561238, 0.081571229, 0.081581548, 0.081591301, 0.081601463, 0.081611015, + 0.081620879, 0.081630155, 0.081639811, 0.081648909, 0.081658378, 0.081667237, 0.081676453, 0.081685066, + 0.081694119, 0.081702478, 0.081711255, 0.081719533, 0.081728227, 0.081735708, 0.081743509, 0.081750736, + 0.081758477, 0.081765704, 0.081773899, 0.081781417, 0.081789345, 0.081796587, 0.081804276, 0.081811398, + 0.081818886, 0.081825688, 0.081832938, 0.081839584, 0.081846662, 0.081852473, 0.081858732, 0.081864469, + 0.081870727, 0.08187639, 0.081883036, 0.081888989, 0.081895389, 0.081901133, 0.081907295, 0.081912801, 0.081918739, + 0.081923433, 0.08192867, 0.08193326, 0.081938341, 0.081942849, 0.081948482, 0.081953391, 0.081958719, 0.08196336, + 0.081968412, 0.081972845, 0.081977777, 0.081981465, 0.081985645, 0.081989147, 0.081993192, 0.081996672, + 0.082001276, 0.082005106, 0.082009368, 0.082012989, 0.082017049, 0.082019813, 0.082023196, 0.08202593, 0.082029209, + 0.082031853, 0.082035571, 0.082038574, 0.082042076, 0.082044333, 0.082047179, 0.082049333, 0.082052, 0.082053974, + 0.082057104, 0.08205951, 0.082062408, 0.082064018, 0.082066201, 0.082067706, 0.08206977, 0.082071118, 0.082073562, + 0.08207529, 0.082077608, 0.082078688, 0.082080327, 0.082081228, 0.082082748, 0.082083657, 0.082085684, 0.082086898, + 0.082088642, 0.082089052, 0.082090072, 0.0820904, 0.082091339, 0.082091562, 0.082092963, 0.08209303, 0.082093716, + 0.082093641, 0.082094178, 0.082094021, 0.082095094, 0.082094803, 0.082095094, 0.082094632, 0.082094774, + 0.082094193, 0.082094803, 0.082094103, 0.082094051, 0.082093231, 0.082093097, 0.082092211, 0.082092449, + 0.082091272, 0.082090773, 0.082089618, 0.082089081, 0.08208777, 0.082087651, 0.082086168, 0.082085326, 0.082083739, + 0.082082838, 0.082081124, 0.082080632, 0.08207877, 0.08207754, 0.082075529, 0.082074225, 0.082072198, 0.082071379, + 0.082069121, 0.082067572, 0.082065247, 0.082064152, 0.082061678, 0.082059853, 0.082057238, 0.08205536, 0.0820527, + 0.0820513, 0.082048528, 0.082046464, 0.082043543, 0.082041889, 0.082038797, 0.082036376, 0.08203318, 0.082030758, + 0.082027495, 0.082025483, 0.082022056, 0.082019337, 0.08201582, 0.0820136, 0.082009934, 0.082006998, 0.082003243, + 0.082000785, 0.081996858, 0.081993699, 0.081989773, 0.08198715, 0.081983052, 0.08197967, 0.081975505, 0.081972092, + 0.081967264, 0.0819638, 0.081959464, 0.081955902, 0.081950955, 0.081947386, 0.081942953, 0.08193925, 0.081934676, + 0.08193142, 0.081926726, 0.081922784, 0.081917986, 0.081914529, 0.081909597, 0.081905432, 0.081900403, 0.081896715, + 0.081891529, 0.081887096, 0.08188121, 0.081876762, 0.081871472, 0.081866957, 0.081860989, 0.081856385, 0.081850924, + 0.081846304, 0.081840232, 0.081835508, 0.081829883, 0.081825651, 0.081819944, 0.081815034, 0.081809238, + 0.081804767, 0.081798732, 0.081793502, 0.081787415, 0.081782691, 0.081776425, 0.081771001, 0.081764132, 0.08175873, + 0.081752405, 0.081747465, 0.08174099, 0.081735313, 0.081728756, 0.081723571, 0.081716828, 0.081710935, 0.081704147, + 0.08169882, 0.081691973, 0.081685953, 0.081678443, 0.081672363, 0.081665382, 0.081659794, 0.081652656, 0.081646457, + 0.081638724, 0.081632458, 0.08162529, 0.081619464, 0.081612021, 0.081605487, 0.081598058, 0.081592016, 0.081584424, + 0.081578277, 0.081570633, 0.08156389, 0.081556179, 0.081549868, 0.081541948, 0.081534952, 0.081526481, 0.081519522, + 0.081511572, 0.081505105, 0.08149711, 0.081490576, 0.08148244, 0.081475124, 0.081466854, 0.081460156, 0.081451833, + 0.081444949, 0.081436478, 0.081428923, 0.081420399, 0.081413344, 0.081404738, 0.081397615, 0.081388876, + 0.081381068, 0.081371702, 0.081363894, 0.08135514, 0.081347883, 0.081338987, 0.081331596, 0.081322566, 0.081314497, + 0.081305452, 0.081297942, 0.081288852, 0.0812812, 0.081271909, 0.081264175, 0.081254832, 0.081246436, 0.08123704, + 0.081229158, 0.081219643, 0.081211627, 0.081202082, 0.081194118, 0.081184454, 0.081175722, 0.081165433, + 0.081156708, 0.081147008, 0.081138879, 0.081129067, 0.081120782, 0.08111088, 0.08110255, 0.081092618, 0.081083603, + 0.081072949, 0.081063919, 0.081053838, 0.081045307, 0.081035174, 0.081026636, 0.081016406, 0.081007704, + 0.080997378, 0.080988027, 0.080977023, 0.080967642, 0.080957264, 0.080948405, 0.080937877, 0.080928922, 0.08091826, + 0.080909185, 0.080898508, 0.080889419, 0.080878608, 0.080869332, 0.080858432, 0.08084859, 0.080837198, 0.080827408, + 0.080816455, 0.080807142, 0.080796145, 0.080786705, 0.080775611, 0.080766127, 0.080754876, 0.080745205, + 0.080733895, 0.080724224, 0.080712825, 0.08070302, 0.080691524, 0.0806816, 0.080670007, 0.080660053, 0.080648407, + 0.080637828, 0.080625609, 0.080615029, 0.080602795, 0.080592252, 0.080580629, 0.080570541, 0.080558784, + 0.080548689, 0.080536827, 0.08052659, 0.080514655, 0.080504373, 0.080492295, 0.080481865, 0.080469705, 0.080459185, + 0.080446966, 0.080436364, 0.080424093, 0.080413461, 0.080401093, 0.080390409, 0.080378018, 0.080367237, + 0.080354668, 0.080343738, 0.080331102, 0.080320172, 0.080307499, 0.080296487, 0.080283687, 0.080272555, + 0.080259725, 0.080248579, 0.080235697, 0.080224521, 0.08021161, 0.080200329, 0.080187298, 0.080176011, 0.080162942, + 0.080151536, 0.080138393, 0.080126934, 0.080113724, 0.080102205, 0.080088913, 0.080077916, 0.080064468, + 0.080052696, 0.080039226, 0.080027454, 0.080013901, 0.080002062, 0.079988495, 0.079976596, 0.079962924, + 0.079950973, 0.079937205, 0.079925172, 0.079911426, 0.079899393, 0.079885595, 0.079873517, 0.079859689, + 0.079847574, 0.079833649, 0.079821959, 0.079808384, 0.079796515, 0.07978224, 0.079769649, 0.079755321, 0.079742834, + 0.079728529, 0.079715885, 0.079701498, 0.079688847, 0.079674393, 0.079661727, 0.079647273, 0.079635143, + 0.079621121, 0.079608791, 0.079594091, 0.079581149, 0.079566367, 0.079553373, 0.079538591, 0.079525515, + 0.079510674, 0.079498135, 0.079483733, 0.079471067, 0.079455994, 0.079442702, 0.0794276, 0.079414278, 0.079399116, + 0.07938578, 0.079370648, 0.079357818, 0.079343043, 0.079330035, 0.079314619, 0.079300977, 0.079285488, 0.079271793, + 0.079256281, 0.079243131, 0.079228081, 0.079214774, 0.079199009, 0.079185016, 0.079169184, 0.079155184, + 0.079139367, 0.079125926, 0.079110064, 0.079096034, 0.079080157, 0.079066113, 0.079050206, 0.079036631, + 0.079021163, 0.079007514, 0.078991346, 0.078976974, 0.078960828, 0.078947075, 0.078931384, 0.078917399, + 0.078900941, 0.078886345, 0.078869909, 0.07885588, 0.078839943, 0.078825735, 0.078808986, 0.078794129, 0.078777447, + 0.078763165, 0.078746967, 0.078732587, 0.078715727, 0.078700744, 0.078683905, 0.078669466, 0.078653134, + 0.078638591, 0.078621477, 0.078606799, 0.078590244, 0.078575507, 0.078558281, 0.078542873, 0.078525618, + 0.078510821, 0.078494087, 0.078479126, 0.078461699, 0.078446724, 0.078429811, 0.078414738, 0.07839708, 0.078381859, + 0.07836476, 0.078349471, 0.078331709, 0.078315862, 0.078298092, 0.078282766, 0.078265458, 0.078250036, 0.078232132, + 0.078216612, 0.078199141, 0.078183554, 0.078165457, 0.07814981, 0.078132182, 0.078116439, 0.07809823, 0.078082457, + 0.078064673, 0.078048721, 0.078030288, 0.078014322, 0.077996403, 0.077980362, 0.077961802, 0.077945724, + 0.077927671, 0.077911481, 0.077892818, 0.077876598, 0.077858351, 0.077842556, 0.077824183, 0.077807717, 0.0777888, + 0.077772357, 0.077753842, 0.07773722, 0.077718116, 0.077701434, 0.077682808, 0.077666111, 0.077646874, 0.077630103, + 0.077611305, 0.077595018, 0.07757619, 0.07755924, 0.077539772, 0.077522822, 0.07750386, 0.077486753, 0.077467091, + 0.077449985, 0.077430896, 0.07741423, 0.077394977, 0.077377632, 0.077357754, 0.077340417, 0.077321038, 0.077304117, + 0.077284597, 0.077266984, 0.077246822, 0.077229224, 0.077209614, 0.077192493, 0.077172786, 0.077154987, + 0.077134572, 0.077116713, 0.07709685, 0.07707949, 0.077059567, 0.077042118, 0.077022083, 0.077004038, 0.076983906, + 0.076966263, 0.076946042, 0.076928265, 0.076907836, 0.076889388, 0.076868437, 0.076850027, 0.076829605, + 0.076811679, 0.07679113, 0.076773092, 0.076752417, 0.076734237, 0.076713435, 0.076694615, 0.076673791, 0.076655455, + 0.076634496, 0.076616116, 0.076595113, 0.07657662, 0.076555498, 0.076536283, 0.076515079, 0.076496467, 0.076475218, + 0.076456524, 0.076435186, 0.076416351, 0.076394953, 0.07637614, 0.076354645, 0.076335654, 0.07631398, 0.07629431, + 0.076272674, 0.076253563, 0.07623174, 0.076212555, 0.076190755, 0.076171488, 0.076149575, 0.076130189, 0.07610815, + 0.076088697, 0.076066621, 0.076047122, 0.07602492, 0.07600528, 0.075983591, 0.075964391, 0.075942472, 0.075923145, + 0.075901084, 0.075880989, 0.075858235, 0.075838074, 0.075815313, 0.075795144, 0.075772315, 0.075752087, + 0.075729221, 0.075708948, 0.075685956, 0.075665608, 0.075642608, 0.075622186, 0.075599127, 0.075578704, + 0.075555585, 0.075535044, 0.075511828, 0.075491227, 0.075468004, 0.075447381, 0.075423986, 0.075403146, + 0.075379677, 0.07535886, 0.075335339, 0.07531438, 0.075290792, 0.075269848, 0.075246185, 0.07522516, 0.075201407, + 0.075180262, 0.07515648, 0.075135253, 0.075111322, 0.075090006, 0.07506603, 0.075045213, 0.075021602, 0.075000606, + 0.074976929, 0.074955747, 0.074931823, 0.074910566, 0.074886501, 0.074865006, 0.074840821, 0.074819237, + 0.074794948, 0.07477323, 0.074748233, 0.074725911, 0.074700914, 0.074678585, 0.074653566, 0.074631728, 0.074607179, + 0.074585199, 0.074560493, 0.074538492, 0.074513756, 0.074491583, 0.074466623, 0.074444316, 0.074418783, + 0.074396446, 0.07437133, 0.074348867, 0.074323662, 0.074301086, 0.074275777, 0.074253067, 0.074227653, 0.07420487, + 0.074179366, 0.074157067, 0.074131384, 0.074108377, 0.074082643, 0.074059576, 0.07403376, 0.074010551, 0.073984638, + 0.073961928, 0.073935866, 0.073912434, 0.073886327, 0.073862948, 0.073836744, 0.073813178, 0.073786944, + 0.073763944, 0.073737577, 0.073713817, 0.073687278, 0.073663414, 0.073636837, 0.073613435, 0.073586673, + 0.073562644, 0.073535882, 0.073511779, 0.073484927, 0.073461302, 0.073434293, 0.073409975, 0.073382944, 0.07335861, + 0.07333152, 0.073307656, 0.073280431, 0.073255859, 0.073228516, 0.073204435, 0.073177524, 0.073153272, 0.073125646, + 0.073100679, 0.073073044, 0.073048718, 0.073021546, 0.072996967, 0.072969064, 0.072944432, 0.07291697, 0.072892167, + 0.072864056, 0.072838657, 0.072810493, 0.072785608, 0.072757877, 0.072732762, 0.072704315, 0.072679199, + 0.072651275, 0.072626032, 0.072597414, 0.072572023, 0.0725438, 0.072518289, 0.072489433, 0.072463855, 0.072435476, + 0.072409764, 0.072380722, 0.072354935, 0.072326317, 0.072300434, 0.07227122, 0.072245292, 0.072216541, 0.072190464, + 0.072161049, 0.072134942, 0.072106011, 0.072080329, 0.07205119, 0.072024807, 0.071995616, 0.07196968, 0.07194031, + 0.071913674, 0.071884207, 0.071858004, 0.071828395, 0.071801499, 0.071771264, 0.071744397, 0.071714722, + 0.071688317, 0.071658447, 0.071631275, 0.071601354, 0.071574688, 0.071544588, 0.071517773, 0.071487583, + 0.071460165, 0.071429856, 0.071402863, 0.071372472, 0.071345329, 0.071314797, 0.071287036, 0.071256407, + 0.071229123, 0.071198456, 0.071171083, 0.071140334, 0.071112312, 0.071081445, 0.071053892, 0.071022913, + 0.070995212, 0.070964091, 0.070936292, 0.070905611, 0.070877664, 0.070846304, 0.070818231, 0.070786797, + 0.070758663, 0.070727102, 0.070698902, 0.070667796, 0.070639387, 0.070607617, 0.070579186, 0.070547312, + 0.070518762, 0.070486777, 0.070458151, 0.070426665, 0.070398435, 0.070366763, 0.070337892, 0.070305601, 0.07027667, + 0.070244297, 0.070215203, 0.070183255, 0.070154577, 0.070122473, 0.070093714, 0.070061497, 0.070032582, + 0.070000187, 0.069970556, 0.069937512, 0.069907852, 0.069874808, 0.06984511, 0.069812521, 0.069783233, 0.069750473, + 0.069721065, 0.069688223, 0.069658697, 0.069625713, 0.069596022, 0.069562875, 0.069533072, 0.069499791, + 0.069469839, 0.069436461, 0.06940642, 0.0693729, 0.06934274, 0.069309175, 0.069278985, 0.069245309, 0.069214962, + 0.069181159, 0.06915015, 0.069116294, 0.069085807, 0.069051862, 0.069021307, 0.068987302, 0.068956621, 0.068922482, + 0.068891741, 0.068857513, 0.06882716, 0.068793289, 0.068762779, 0.068728775, 0.068698071, 0.06866385, 0.068632975, + 0.068598621, 0.068567604, 0.06853307, 0.068501912, 0.068467274, 0.068435945, 0.068401158, 0.068369769, 0.068334378, + 0.068302393, 0.068266943, 0.068234883, 0.068199433, 0.068167418, 0.068131939, 0.068099864, 0.068064339, 0.06803222, + 0.067996621, 0.067964949, 0.067929775, 0.067897931, 0.067862615, 0.067830667, 0.067795187, 0.067763075, + 0.067727439, 0.067695178, 0.067659453, 0.067627102, 0.067590773, 0.067558378, 0.067522436, 0.06748987, 0.067453861, + 0.067421272, 0.067385145, 0.067352392, 0.067316137, 0.067283295, 0.067246951, 0.067214541, 0.067178093, 0.06714496, + 0.067108326, 0.067075163, 0.067038506, 0.067005254, 0.066968538, 0.066935733, 0.066899382, 0.066866376, + 0.066829309, 0.066795647, 0.066758499, 0.066724777, 0.066687584, 0.066654369, 0.066617608, 0.066584185, + 0.066546723, 0.066512719, 0.066475227, 0.066441655, 0.066404529, 0.066370785, 0.066333048, 0.066298753, + 0.066260979, 0.066227086, 0.066189699, 0.066155717, 0.06611824, 0.066084161, 0.066046029, 0.066011861, 0.065974161, + 0.065939859, 0.06590198, 0.065867491, 0.065829009, 0.065794513, 0.065756515, 0.065721914, 0.065683812, 0.065649644, + 0.065611362, 0.065576524, 0.06553819, 0.065503217, 0.065464221, 0.065429211, 0.065390714, 0.065355681, 0.065317102, + 0.065282419, 0.065243609, 0.065208264, 0.065169454, 0.06513463, 0.065095708, 0.065060206, 0.06502115, 0.06498605, + 0.064946897, 0.064911239, 0.064872079, 0.064836875, 0.064798042, 0.064762592, 0.064723112, 0.064687617, + 0.064648591, 0.064612977, 0.064573303, 0.064537577, 0.064498305, 0.064462483, 0.0644226, 0.064386703, 0.064347312, + 0.064311296, 0.064271159, 0.064235076, 0.064195476, 0.064159252, 0.064119019, 0.064082861, 0.064043157, 0.06400682, + 0.063966386, 0.063929953, 0.06389001, 0.063853994, 0.063813888, 0.06377726, 0.063736565, 0.063699856, 0.063659601, + 0.063623346, 0.063583016, 0.063546099, 0.063505612, 0.063469082, 0.063428499, 0.063391373, 0.063350178, + 0.063313089, 0.063272461, 0.063235722, 0.063194901, 0.063157596, 0.063116752, 0.063079894, 0.063038923, + 0.063001953, 0.062960938, 0.062923387, 0.062882274, 0.06284517, 0.062803961, 0.062766746, 0.062725477, 0.062688179, + 0.062647313, 0.062609896, 0.062568419, 0.062530927, 0.062489383, 0.062451825, 0.062410701, 0.062372994, + 0.062331174, 0.062293388, 0.062251583, 0.062213756, 0.062172376, 0.062134985, 0.062093496, 0.06205548, 0.062013391, + 0.061975289, 0.061933126, 0.061894979, 0.061853301, 0.061815567, 0.06177371, 0.061735842, 0.06169387, 0.061655406, + 0.061612893, 0.061574388, 0.061532352, 0.061494302, 0.061452132, 0.061413929, 0.061371665, 0.061333429, + 0.061291087, 0.061252732, 0.061210316, 0.06117139, 0.061128888, 0.061090365, 0.061047811, 0.061009247, 0.060966611, + 0.060928013, 0.060885333, 0.060846638, 0.06080389, 0.060765099, 0.060722727, 0.060684331, 0.060641818, 0.06060325, + 0.060560565, 0.060521383, 0.060478166, 0.060438968, 0.060395733, 0.06035652, 0.06031324, 0.060273986, 0.060230672, + 0.060191359, 0.060148038, 0.060108781, 0.060065906, 0.060026981, 0.059983995, 0.05994501, 0.059901889, 0.05986274, + 0.059819493, 0.059780255, 0.05973696, 0.059697669, 0.059654284, 0.05961486, 0.059571363, 0.059531894, 0.059488352, + 0.059448794, 0.059405167, 0.059365585, 0.059321903, 0.05928221, 0.059238501, 0.059198786, 0.059154999, 0.059115216, + 0.059071366, 0.059031557, 0.05898764, 0.05894772, 0.05890375, 0.058863796, 0.058819849, 0.058779906, 0.058735918, + 0.058695961, 0.058651906, 0.058611855, 0.058567792, 0.058527734, 0.058483575, 0.058443438, 0.058399282, + 0.058359131, 0.058314927, 0.058275249, 0.058231421, 0.05819156, 0.058147613, 0.058107648, 0.058063582, 0.058023546, + 0.057979457, 0.057939313, 0.057895124, 0.057854947, 0.057810653, 0.057770345, 0.057725988, 0.057685658, + 0.057641253, 0.057600863, 0.057556417, 0.057516471, 0.057472415, 0.057432372, 0.057388235, 0.057348032, + 0.057303298, 0.057262633, 0.057217885, 0.057177145, 0.057132378, 0.057091668, 0.057046931, 0.057006668, 0.05696224, + 0.056921799, 0.056877304, 0.05683684, 0.056792326, 0.056751803, 0.056707162, 0.056666546, 0.056621421, 0.056580801, + 0.056536149, 0.05649548, 0.056450721, 0.056409966, 0.056365203, 0.056324463, 0.056279644, 0.056238849, 0.056193981, + 0.056153562, 0.056108557, 0.056067556, 0.056022558, 0.055981576, 0.055936582, 0.055895653, 0.055850629, + 0.055810075, 0.055765491, 0.055724878, 0.055679712, 0.055638596, 0.055593416, 0.055552311, 0.055507191, + 0.055466548, 0.055421825, 0.055381045, 0.055335753, 0.055294495, 0.055249158, 0.055208348, 0.05516351, 0.055122662, + 0.05507778, 0.055036891, 0.054991461, 0.054950524, 0.054905549, 0.054864593, 0.054819603, 0.054778617, 0.054733519, + 0.05469241, 0.054646801, 0.054605749, 0.05456065, 0.054519571, 0.054474447, 0.054433312, 0.054388169, 0.054347489, + 0.054302242, 0.054261018, 0.054215778, 0.054174989, 0.054130141, 0.054089278, 0.05404387, 0.054002501, 0.05395719, + 0.053916395, 0.053871468, 0.053830523, 0.053785097, 0.053743698, 0.053698275, 0.053657364, 0.053612396, + 0.053571396, 0.053525873, 0.053484861, 0.053439811, 0.053398728, 0.053353615, 0.053312507, 0.053266902, + 0.053225789, 0.053180702, 0.053139593, 0.053094398, 0.053053696, 0.053008512, 0.052967347, 0.052922145, + 0.052881386, 0.052836124, 0.0527949, 0.05274963, 0.052708339, 0.052663054, 0.052622244, 0.052576955, 0.052535716, + 0.052490465, 0.05244964, 0.05240478, 0.052363891, 0.052318495, 0.052277587, 0.052232657, 0.052191705, 0.052146286, + 0.052105352, 0.05206041, 0.052019443, 0.051973999, 0.051933035, 0.051888045, 0.051847037, 0.051802028, 0.051761482, + 0.051716413, 0.051675323, 0.051630247, 0.051589645, 0.051544532, 0.051503409, 0.051458288, 0.051417604, + 0.051372416, 0.051331222, 0.051286072, 0.051245425, 0.051200327, 0.051159222, 0.051114086, 0.051073391, + 0.051028695, 0.050987966, 0.050942767, 0.050902024, 0.050857287, 0.050816566, 0.050771412, 0.050730657, 0.05068586, + 0.050645076, 0.050599828, 0.050559077, 0.05051437, 0.050473571, 0.05042832, 0.050387558, 0.050342768, 0.050301965, + 0.050256751, 0.050216012, 0.050171312, 0.050131038, 0.050086308, 0.050045572, 0.050000846, 0.049960542, + 0.049915753, 0.049874939, 0.049830191, 0.049789857, 0.049745046, 0.049704224, 0.049659472, 0.049619164, + 0.049574405, 0.049534108, 0.049489837, 0.049449496, 0.049404714, 0.049364381, 0.049319617, 0.049278848, + 0.049234122, 0.049193833, 0.049149126, 0.049108863, 0.049064636, 0.049024343, 0.048979647, 0.048939392, + 0.048895147, 0.048854891, 0.048810247, 0.048769992, 0.04872578, 0.048685975, 0.048641693, 0.048601374, 0.048556697, + 0.048516475, 0.048472267, 0.048432473, 0.048388258, 0.048347987, 0.048303779, 0.048263974, 0.048219766, + 0.048179526, 0.048135355, 0.048095569, 0.048051402, 0.048011687, 0.047967546, 0.047927346, 0.04788322, 0.047843523, + 0.047799423, 0.04775973, 0.047716059, 0.047676284, 0.047632109, 0.047592383, 0.047548261, 0.047508549, 0.047464922, + 0.047425251, 0.0473812, 0.04734157, 0.047297988, 0.047258776, 0.04721519, 0.047175545, 0.047131501, 0.04709186, + 0.047048308, 0.047009148, 0.046965595, 0.046925984, 0.046882026, 0.046842489, 0.046799015, 0.046759941, + 0.046716493, 0.046677396, 0.046633918, 0.046594393, 0.046550948, 0.046511848, 0.046468362, 0.046429325, + 0.046386354, 0.046347272, 0.046303816, 0.046264764, 0.046221316, 0.04618226, 0.046139307, 0.046100266, 0.046056926, + 0.046017952, 0.045974616, 0.045935676, 0.045892816, 0.045854311, 0.045811418, 0.045772437, 0.045729142, + 0.045690257, 0.045647483, 0.045609064, 0.045566272, 0.045527816, 0.045484968, 0.045446053, 0.045403261, + 0.045364849, 0.045322087, 0.045283668, 0.045240927, 0.04520214, 0.045159452, 0.045121092, 0.045078397, 0.045040086, + 0.044997454, 0.044959147, 0.044916924, 0.044878624, 0.044836011, 0.044797767, 0.044755206, 0.044717006, + 0.044674501, 0.044636331, 0.044594269, 0.044556089, 0.044513602, 0.044475488, 0.044433106, 0.044395078, + 0.044353146, 0.044315521, 0.044273566, 0.04423593, 0.044193961, 0.044155911, 0.044113979, 0.044076357, 0.044034462, + 0.043996904, 0.043954987, 0.043917395, 0.043875504, 0.043837551, 0.043795787, 0.043758299, 0.04371649, 0.04367904, + 0.043637283, 0.043599848, 0.043558553, 0.043521129, 0.043479394, 0.043441992, 0.043400347, 0.043363031, + 0.043321379, 0.04328407, 0.043242928, 0.043206088, 0.043164901, 0.04312763, 0.043086115, 0.043048926, 0.043007445, + 0.042970296, 0.042929292, 0.042892579, 0.042851597, 0.042814888, 0.042773895, 0.042736799, 0.042695455, + 0.042658452, 0.042617608, 0.042581048, 0.042540211, 0.04250367, 0.042462826, 0.042426262, 0.042385869, 0.042349309, + 0.042308502, 0.042272024, 0.04223128, 0.042194836, 0.042154167, 0.042117778, 0.042077128, 0.042040776, 0.042000577, + 0.041964225, 0.041923601, 0.041887295, 0.041846767, 0.04181052, 0.041770011, 0.041733801, 0.041693825, 0.041658092, + 0.041618083, 0.041582361, 0.04154237, 0.041506216, 0.041465856, 0.041429792, 0.041389905, 0.041354243, 0.041314367, + 0.041278787, 0.041238956, 0.041203365, 0.041163538, 0.041127563, 0.04108784, 0.041052375, 0.041012652, 0.040977191, + 0.040937558, 0.04090219, 0.040862575, 0.040827215, 0.040787622, 0.040752295, 0.040713158, 0.040677819, 0.040638272, + 0.040603001, 0.04056358, 0.040528424, 0.040489037, 0.040453907, 0.040414978, 0.040380247, 0.040341314, 0.040306613, + 0.040267684, 0.04023255, 0.040193241, 0.040158212, 0.040119018, 0.040084071, 0.040045351, 0.040010862, 0.039972164, + 0.039937656, 0.039898951, 0.03986448, 0.039825823, 0.039790995, 0.03975242, 0.039718062, 0.039679527, 0.039645206, + 0.039606676, 0.039572373, 0.039533876, 0.039499603, 0.039461192, 0.039426986, 0.039389022, 0.039355256, + 0.039317276, 0.039283074, 0.039244726, 0.03921058, 0.039172255, 0.039138157, 0.039099947, 0.039065946, 0.039028149, + 0.038994558, 0.038956795, 0.038923234, 0.038885511, 0.038851939, 0.038814195, 0.038780261, 0.038742214, + 0.038708445, 0.038670935, 0.038637552, 0.038600005, 0.038566656, 0.038529169, 0.038495842, 0.038458355, + 0.038425069, 0.03838766, 0.038354408, 0.038317416, 0.038284194, 0.038246851, 0.038213685, 0.038176369, 0.03814324, + 0.038106035, 0.038072985, 0.038035784, 0.038002778, 0.037966028, 0.037933417, 0.037896667, 0.037864055, + 0.037827265, 0.037794255, 0.037757184, 0.037724283, 0.03768729, 0.037654489, 0.037617989, 0.037585642, 0.037549164, + 0.03751684, 0.037480358, 0.037448023, 0.037411563, 0.037379228, 0.037342787, 0.037310135, 0.037273422, 0.037240881, + 0.037204679, 0.037172612, 0.037136432, 0.037104398, 0.037068244, 0.03703621, 0.037000071, 0.036968078, 0.036932014, + 0.036900088, 0.036864452, 0.036832947, 0.036797322, 0.036765411, 0.036729421, 0.03669757, 0.036661644, 0.036629844, + 0.036593977, 0.036562238, 0.036526814, 0.036495522, 0.036460154, 0.036428887, 0.036393512, 0.036362216, + 0.036326841, 0.036295198, 0.036259495, 0.03622796, 0.03619238, 0.036160935, 0.036125835, 0.036094852, 0.036059786, + 0.036028784, 0.035993725, 0.035962764, 0.035927732, 0.035896789, 0.035861779, 0.035830885, 0.035796329, + 0.035765469, 0.035730585, 0.0356998, 0.035664946, 0.03563419, 0.035599388, 0.035568703, 0.035533998, 0.035503369, + 0.035468694, 0.035438098, 0.035403833, 0.035373621, 0.035339363, 0.035309181, 0.035274941, 0.035244428, + 0.035209887, 0.035179444, 0.035144981, 0.035114571, 0.035080541, 0.035050571, 0.035016552, 0.03498657, 0.034952562, + 0.034922622, 0.034888651, 0.034858726, 0.03482477, 0.034794528, 0.03476068, 0.034730881, 0.034697063, 0.034667321, + 0.034633584, 0.034603901, 0.034570247, 0.034540631, 0.034506962, 0.034477349, 0.034443744, 0.034414195, + 0.034381006, 0.034351811, 0.034318596, 0.034289058, 0.034255523, 0.03422603, 0.034192573, 0.03416317, 0.034129784, + 0.034100439, 0.034067497, 0.03403857, 0.03400562, 0.033976696, 0.033943806, 0.033914924, 0.033882029, 0.033852771, + 0.033819549, 0.033790376, 0.033757262, 0.03372819, 0.033695519, 0.033666868, 0.033634249, 0.033605643, 0.033573035, + 0.033544417, 0.03351184, 0.033483297, 0.033450767, 0.033421874, 0.03338943, 0.033360995, 0.033328604, 0.03330021, + 0.033267852, 0.03323948, 0.033207141, 0.033178825, 0.033146583, 0.033118319, 0.033086471, 0.03305858, 0.03302671, + 0.032998797, 0.032966923, 0.032938674, 0.032906491, 0.032878291, 0.032846194, 0.032818105, 0.03278641, 0.03275869, + 0.03272704, 0.032699361, 0.032667737, 0.032640073, 0.032608449, 0.032580789, 0.032549214, 0.032521259, 0.032489426, + 0.03246155, 0.032430127, 0.032402668, 0.032371286, 0.032343872, 0.032312531, 0.032285158, 0.032253869, 0.032226525, + 0.032195251, 0.032167584, 0.032136396, 0.032109186, 0.032078061, 0.032050904, 0.03201982, 0.031992678, 0.031961646, + 0.031934574, 0.031903591, 0.031876557, 0.031845968, 0.031819306, 0.031788729, 0.031761684, 0.031730749, + 0.031703796, 0.031672969, 0.031646077, 0.031615321, 0.031588513, 0.031558178, 0.03153174, 0.031501397, 0.031474959, + 0.031444624, 0.031418238, 0.031387977, 0.031361237, 0.031330641, 0.031304013, 0.031273875, 0.031247629, 0.03121748, + 0.031191248, 0.031161128, 0.031134892, 0.031104797, 0.031078624, 0.031048946, 0.031022778, 0.030992771, + 0.030966658, 0.030936657, 0.030910579, 0.030880664, 0.030854661, 0.030824803, 0.03079883, 0.030769339, 0.030743718, + 0.030714242, 0.030688299, 0.030658528, 0.030632639, 0.030602915, 0.030577099, 0.030547421, 0.030521659, + 0.030492432, 0.030467078, 0.030437859, 0.030412482, 0.030383253, 0.030357545, 0.030328043, 0.030302441, + 0.030273369, 0.030248117, 0.030219015, 0.030193789, 0.030164724, 0.030139511, 0.030110493, 0.030085366, + 0.030056424, 0.030030984, 0.030002063, 0.029977001, 0.029948123, 0.029923089, 0.029894216, 0.029869219, 0.02984044, + 0.029815508, 0.029787097, 0.029762141, 0.029733388, 0.029708495, 0.029679812, 0.029654983, 0.029626368, + 0.029601596, 0.029573023, 0.029548289, 0.02952012, 0.029495763, 0.029467568, 0.029442847, 0.02941435, 0.029389719, + 0.029361324, 0.029336745, 0.029308729, 0.029284518, 0.029256521, 0.029232318, 0.029204311, 0.029179782, + 0.029151488, 0.029127039, 0.029099178, 0.029075101, 0.029047251, 0.0290232, 0.028995363, 0.028971359, 0.028943598, + 0.028919281, 0.028891545, 0.02886761, 0.028839894, 0.028815996, 0.028788349, 0.028764483, 0.02873685, 0.028712984, + 0.028685721, 0.028661916, 0.028634354, 0.028610572, 0.028583044, 0.028559333, 0.028531875, 0.02850819, 0.0284811, + 0.028457768, 0.02843067, 0.028407013, 0.028379628, 0.028356032, 0.028328693, 0.028305158, 0.028278245, 0.028255075, + 0.028228115, 0.028204922, 0.028178021, 0.028154513, 0.028127281, 0.028103849, 0.028077057, 0.028054001, + 0.028027231, 0.028004205, 0.027977441, 0.027954105, 0.027927091, 0.027903836, 0.02787724, 0.027854403, 0.027827831, + 0.02780498, 0.027778421, 0.027755581, 0.027729034, 0.027705902, 0.027679415, 0.027656661, 0.027630197, 0.027607458, + 0.027581042, 0.027558383, 0.02753235, 0.027509676, 0.027483307, 0.027460683, 0.027434371, 0.027411804, 0.02738555, + 0.027363027, 0.02733713, 0.027314937, 0.02728905, 0.027266525, 0.027240327, 0.027217863, 0.027191741, 0.027169351, + 0.027143611, 0.027121536, 0.027095795, 0.027073419, 0.027047377, 0.027025066, 0.026999438, 0.026977509, 0.02695189, + 0.026929941, 0.026904311, 0.026882049, 0.026856475, 0.02683459, 0.026809024, 0.026787143, 0.02676164, 0.026739812, + 0.026714306, 0.026692158, 0.026666746, 0.026645012, 0.026619613, 0.026597893, 0.026572552, 0.026550898, 0.0265259, + 0.026504198, 0.026478868, 0.026457209, 0.02643194, 0.026410354, 0.026385128, 0.026363561, 0.026338704, 0.026317166, + 0.026291998, 0.026270473, 0.026245346, 0.026223905, 0.026199171, 0.026177755, 0.026152709, 0.026131339, + 0.026106346, 0.02608503, 0.026060453, 0.026039477, 0.026014861, 0.02599356, 0.025968667, 0.025947435, 0.025922919, + 0.025902022, 0.025877494, 0.025856595, 0.025832104, 0.025810907, 0.025786461, 0.025765652, 0.025741236, + 0.025720423, 0.025696, 0.02567488, 0.025650522, 0.02562979, 0.025605477, 0.02558477, 0.025560465, 0.025539776, + 0.025515502, 0.025494527, 0.02547032, 0.025449721, 0.025425551, 0.025405006, 0.025380867, 0.025360005, 0.025335938, + 0.025315469, 0.025291415, 0.025270954, 0.025247267, 0.025227163, 0.025203478, 0.025183039, 0.025159027, + 0.025138617, 0.025114981, 0.025094923, 0.025071289, 0.025050903, 0.025026957, 0.025006598, 0.024983034, + 0.024963032, 0.024939466, 0.024919143, 0.02489531, 0.024875091, 0.024851665, 0.024831805, 0.024808384, 0.024788186, + 0.024764478, 0.024744358, 0.024721017, 0.024701232, 0.024677908, 0.02465814, 0.024634831, 0.024614759, 0.024591502, + 0.02457178, 0.02454854, 0.024528861, 0.024505656, 0.024485674, 0.024462538, 0.024442956, 0.024419861, 0.024400296, + 0.024377503, 0.024357894, 0.024334783, 0.024315232, 0.024292178, 0.02427265, 0.024249943, 0.024230445, 0.024207441, + 0.024187978, 0.024165014, 0.024145577, 0.024122979, 0.024103547, 0.02408064, 0.024061281, 0.024038754, 0.024019707, + 0.023997154, 0.023977814, 0.023954971, 0.023935638, 0.023913167, 0.023894193, 0.023871725, 0.023852441, + 0.023830017, 0.02381108, 0.023788676, 0.023769457, 0.023746764, 0.0237276, 0.023705294, 0.02368647, 0.023664171, + 0.02364503, 0.02362247, 0.023603428, 0.023581253, 0.023562549, 0.023540391, 0.023521367, 0.0234992, 0.023480527, + 0.023458431, 0.0234398, 0.023417713, 0.023398809, 0.023376796, 0.023358241, 0.023336219, 0.023317652, 0.023295976, + 0.023277435, 0.023255447, 0.023236912, 0.023215251, 0.023196707, 0.023174742, 0.023156263, 0.023134364, + 0.023115924, 0.023094364, 0.023075921, 0.023054065, 0.023035657, 0.023014136, 0.022995746, 0.022973986, 0.02295566, + 0.022933904, 0.022915598, 0.022894209, 0.022875933, 0.022854257, 0.022836018, 0.022814695, 0.022796754, + 0.022775399, 0.022757178, 0.022735873, 0.022717969, 0.022696661, 0.02267847, 0.022657234, 0.022639388, 0.022618143, + 0.022600308, 0.022579085, 0.02256096, 0.022539765, 0.022521971, 0.022500802, 0.022482723, 0.022461595, 0.022443885, + 0.022422781, 0.022404745, 0.022383682, 0.022366038, 0.022345005, 0.022327358, 0.022306651, 0.022289025, + 0.022268023, 0.022250393, 0.022229413, 0.022211526, 0.022190606, 0.022173075, 0.022152182, 0.022134656, + 0.022114087, 0.022096585, 0.022075742, 0.022058263, 0.022037748, 0.022020312, 0.02199953, 0.021982109, 0.021961642, + 0.021944236, 0.021923492, 0.021906117, 0.021885727, 0.02186868, 0.021848297, 0.021830967, 0.02181061, 0.021793576, + 0.021773202, 0.021755865, 0.021735517, 0.021718517, 0.021698186, 0.021680899, 0.021660598, 0.021643637, + 0.021623341, 0.021606091, 0.021585857, 0.021568924, 0.021548694, 0.021531789, 0.021511568, 0.021494368, + 0.021474194, 0.02145735, 0.021437202, 0.02142011, 0.021400038, 0.021383256, 0.021363178, 0.021346124, 0.021326117, + 0.021309426, 0.021289431, 0.021272454, 0.021252511, 0.021235874, 0.02121624, 0.021199601, 0.02117968, 0.021163058, + 0.021143449, 0.021126812, 0.021106916, 0.021090323, 0.021070749, 0.021054152, 0.021034317, 0.021017779, + 0.020998258, 0.020981718, 0.020961924, 0.020945415, 0.020925937, 0.020909442, 0.020889712, 0.020873275, + 0.020853886, 0.02083776, 0.020818362, 0.020801933, 0.020782579, 0.020766474, 0.020747114, 0.020730721, 0.020711385, + 0.020695282, 0.020675942, 0.020659564, 0.020640267, 0.020624209, 0.02060492, 0.02058861, 0.020569377, 0.02055336, + 0.020534415, 0.02051839, 0.020499146, 0.020482879, 0.020463703, 0.020447757, 0.020428589, 0.020412372, 0.020393254, + 0.020377349, 0.020358248, 0.020342104, 0.020323046, 0.020307219, 0.020288192, 0.020272102, 0.020253139, + 0.020237403, 0.020218752, 0.020203009, 0.020184057, 0.020168317, 0.020149678, 0.020133944, 0.020115016, + 0.020099301, 0.020080693, 0.020064985, 0.020046104, 0.020030426, 0.020011868, 0.0199962, 0.01997737, 0.019961756, + 0.019943258, 0.019927664, 0.019909186, 0.019893596, 0.019874854, 0.019859303, 0.019840878, 0.019825336, + 0.019806651, 0.019791177, 0.019772846, 0.019757377, 0.019739034, 0.019723842, 0.019705484, 0.019690009, + 0.019671688, 0.019656533, 0.019638233, 0.019622801, 0.019604495, 0.019589087, 0.019570863, 0.019555774, + 0.019537553, 0.019522198, 0.019504005, 0.019488957, 0.019470792, 0.019455492, 0.019437343, 0.019422321, + 0.019404465, 0.019389475, 0.019371368, 0.019356104, 0.019338017, 0.019323055, 0.019304963, 0.019289745, + 0.019271722, 0.019256826, 0.019239098, 0.019224195, 0.019206166, 0.019191271, 0.019173564, 0.019158678, + 0.019141002, 0.019126149, 0.019108195, 0.019093351, 0.019075697, 0.019060861, 0.019042946, 0.019028148, + 0.019010553, 0.018995767, 0.018978186, 0.018963417, 0.018945565, 0.018930817, 0.018913284, 0.018898563, + 0.018881049, 0.018866338, 0.018848585, 0.018833937, 0.018816512, 0.018801864, 0.018784447, 0.018770101, + 0.018752649, 0.018738015, 0.018720619, 0.018705999, 0.018688619, 0.018674312, 0.018656939, 0.018642349, + 0.018625027, 0.018610489, 0.018593173, 0.018578924, 0.018561631, 0.018547103, 0.018529832, 0.018515624, + 0.018498644, 0.018484419, 0.018467167, 0.018452695, 0.018435486, 0.018421309, 0.018404381, 0.018390201, + 0.018373001, 0.018358562, 0.018341413, 0.018327305, 0.018310465, 0.018296352, 0.018279208, 0.01826483, 0.01824774, + 0.018233705, 0.018216932, 0.018202895, 0.018185856, 0.01817154, 0.01815453, 0.018140558, 0.018123874, 0.018109933, + 0.018093251, 0.018079299, 0.018062349, 0.018048398, 0.018031737, 0.018017793, 0.018001152, 0.017987216, + 0.017970316, 0.017956439, 0.017939875, 0.017926006, 0.017909423, 0.017895566, 0.01787875, 0.017864913, 0.017848389, + 0.017834596, 0.017818112, 0.017804317, 0.017787842, 0.017774323, 0.017757837, 0.017744048, 0.017727572, + 0.017713813, 0.017697388, 0.017683916, 0.017667733, 0.017654223, 0.017637771, 0.017624019, 0.017607637, + 0.017593944, 0.01757759, 0.017564174, 0.017547803, 0.017534129, 0.017517816, 0.017504191, 0.017487921, 0.017474575, + 0.01745856, 0.017445207, 0.017428933, 0.01741533, 0.017399091, 0.017385535, 0.017369341, 0.017356081, 0.01734017, + 0.017326901, 0.017310703, 0.017297179, 0.017281054, 0.017267849, 0.017251996, 0.017238779, 0.017222928, + 0.017209725, 0.017193887, 0.017180674, 0.017164571, 0.017151389, 0.017135577, 0.017122397, 0.017106593, + 0.017093416, 0.01707763, 0.017064469, 0.017048437, 0.017035322, 0.017019616, 0.017006528, 0.016990818, 0.016977733, + 0.016962051, 0.016948991, 0.016933322, 0.01692052, 0.016904835, 0.016891763, 0.016876103, 0.016863057, 0.016847439, + 0.016834429, 0.016818818, 0.016806066, 0.016790457, 0.016777461, 0.016761899, 0.016748922, 0.016733374, + 0.016720437, 0.016704921, 0.016692003, 0.016676528, 0.0166639, 0.016648427, 0.016635539, 0.016620111, 0.016607253, + 0.016591828, 0.016579002, 0.016563622, 0.016551074, 0.016535953, 0.016523372, 0.016508229, 0.016495656, + 0.016480258, 0.016467435, 0.0164521, 0.016439326, 0.016424019, 0.016411543, 0.016396513, 0.016384028, 0.016368994, + 0.016356509, 0.016341483, 0.016328994, 0.016313715, 0.016301008, 0.016285775, 0.016273372, 0.016258446, + 0.016246034, 0.016231075, 0.016218664, 0.016203729, 0.016191315, 0.016176384, 0.016163988, 0.016148809, + 0.016136171, 0.016121073, 0.016108792, 0.016093975, 0.01608168, 0.016066875, 0.016054578, 0.01603977, 0.016027469, + 0.016012663, 0.016000379, 0.015985604, 0.015973339, 0.015958332, 0.015946122, 0.015931426, 0.015919233, + 0.015904548, 0.015892366, 0.01587769, 0.015865514, 0.015850862, 0.015838694, 0.015824039, 0.015811898, 0.015797284, + 0.0157854, 0.015771024, 0.015759118, 0.015744729, 0.015732814, 0.01571817, 0.015706021, 0.015691414, 0.015679291, + 0.015664719, 0.015652625, 0.015638085, 0.015626039, 0.015611536, 0.015599749, 0.015585502, 0.015573707, + 0.015559455, 0.015547656, 0.01553339, 0.015521577, 0.015507321, 0.015495501, 0.015481236, 0.015469426, 0.015454931, + 0.015442914, 0.015428483, 0.015416509, 0.015402121, 0.015390186, 0.015375833, 0.015364191, 0.015350118, + 0.015338467, 0.015324391, 0.015312759, 0.015298707, 0.015287074, 0.015273006, 0.015261364, 0.015247314, + 0.015235671, 0.015221607, 0.015209978, 0.015195954, 0.015184345, 0.015170334, 0.015158746, 0.015144744, + 0.015133156, 0.015119182, 0.015107632, 0.01509343, 0.015081911, 0.015068014, 0.015056502, 0.015042595, 0.015031092, + 0.015017218, 0.015005747, 0.014991881, 0.014980403, 0.014966563, 0.014955134, 0.014941306, 0.014929865, + 0.014916066, 0.014904661, 0.014890877, 0.014879481, 0.014865737, 0.014854373, 0.014840634, 0.014829258, 0.01481553, + 0.0148042, 0.014790513, 0.014779205, 0.014765546, 0.014754262, 0.014740628, 0.014729359, 0.014715742, 0.014704499, + 0.014690904, 0.014679908, 0.01466656, 0.014655563, 0.014642199, 0.014631172, 0.014617801, 0.014606762, 0.014593379, + 0.014582341, 0.014568971, 0.014557946, 0.014544587, 0.014533565, 0.014520205, 0.014509181, 0.014495829, + 0.014484801, 0.014471445, 0.014460429, 0.014447089, 0.014436075, 0.01442275, 0.014411748, 0.014398438, 0.014387459, + 0.014374178, 0.014363219, 0.014349947, 0.014338993, 0.01432575, 0.014314819, 0.014301588, 0.014290674, 0.014277475, + 0.014266589, 0.0142534, 0.014242513, 0.014229339, 0.014218483, 0.014205329, 0.014194485, 0.014181372, 0.01417054, + 0.014157427, 0.014146634, 0.014133554, 0.01412275, 0.014109687, 0.014098917, 0.014085885, 0.014075157, 0.014062156, + 0.014051439, 0.01403869, 0.014028196, 0.014015429, 0.014004922, 0.013992145, 0.013981619, 0.013968814, 0.013958275, + 0.01394548, 0.013934947, 0.013922156, 0.013911375, 0.013898365, 0.013887637, 0.013874668, 0.01386399, 0.013851083, + 0.013840436, 0.013827561, 0.013816955, 0.013804127, 0.013793557, 0.013780763, 0.013770217, 0.013757442, + 0.013746915, 0.013734178, 0.013723698, 0.013711234, 0.013700978, 0.013688491, 0.013678229, 0.013665745, 0.01365548, + 0.013642977, 0.013632706, 0.013620217, 0.013609925, 0.013597418, 0.013587145, 0.013574664, 0.013564402, + 0.013551917, 0.013541413, 0.013528729, 0.013518288, 0.013505666, 0.013495262, 0.013482915, 0.013472787, + 0.013460469, 0.013450338, 0.013438008, 0.01342787, 0.013415532, 0.013405387, 0.013393064, 0.013382951, 0.013370647, + 0.013360531, 0.013348245, 0.013338151, 0.013325878, 0.013315781, 0.013303737, 0.013293619, 0.013281336, + 0.013271257, 0.013259024, 0.01324896, 0.013236725, 0.013226673, 0.013214473, 0.013204447, 0.013192263, 0.013182256, + 0.013170098, 0.013160108, 0.013148194, 0.013138426, 0.013126481, 0.013116458, 0.013104313, 0.013094321, + 0.013082181, 0.013072225, 0.013060133, 0.01305018, 0.013038085, 0.013028149, 0.013016324, 0.013006635, 0.012994799, + 0.01298509, 0.012973233, 0.012963279, 0.012951222, 0.012941316, 0.012929304, 0.012919432, 0.012907444, 0.012897601, + 0.012885866, 0.012876255, 0.012864523, 0.012854896, 0.012843155, 0.012833539, 0.012821808, 0.012811957, + 0.012800013, 0.012790199, 0.012778522, 0.012768949, 0.012757268, 0.012747699, 0.012736016, 0.012726422, + 0.012714733, 0.012704925, 0.01269306, 0.012683327, 0.012671743, 0.012662239, 0.012650653, 0.012641163, 0.012629572, + 0.012620076, 0.012608497, 0.012599007, 0.012587434, 0.012577723, 0.012566175, 0.012556699, 0.012545147, + 0.012535691, 0.012524167, 0.01251472, 0.012503215, 0.012493783, 0.012482517, 0.012473083, 0.012461579, 0.012452161, + 0.012440689, 0.012431285, 0.012419821, 0.012410422, 0.012398965, 0.01238935, 0.012377945, 0.012368605, 0.012357227, + 0.012347903, 0.01233653, 0.012327231, 0.012315892, 0.012306596, 0.012295492, 0.012286186, 0.012274855, 0.012265575, + 0.01225426, 0.012244983, 0.012233911, 0.012224861, 0.012213759, 0.012204471, 0.012193159, 0.012183893, 0.012172612, + 0.012163373, 0.012152359, 0.01214336, 0.012132334, 0.012123095, 0.012111837, 0.012102616, 0.012091399, 0.012082209, + 0.012071242, 0.012062279, 0.012051295, 0.012042103, 0.012030925, 0.012021765, 0.012010843, 0.01200192, 0.011990976, + 0.01198203, 0.011971092, 0.011961926, 0.011950781, 0.011941656, 0.011930772, 0.011921894, 0.011911015, 0.011901909, + 0.011890846, 0.011881784, 0.01187097, 0.011862134, 0.011851311, 0.011842467, 0.011831642, 0.011822578, 0.011811764, + 0.011802925, 0.011792123, 0.011783299, 0.011772512, 0.011763472, 0.011752707, 0.011743916, 0.011733159, + 0.011724362, 0.011713607, 0.011704604, 0.011693876, 0.011685102, 0.011674386, 0.011665644, 0.011654947, 0.01164621, + 0.011635751, 0.011627004, 0.011616321, 0.011607588, 0.01159691, 0.011588192, 0.011577741, 0.011569021, 0.011558367, + 0.011549647, 0.011539008, 0.011530312, 0.011519903, 0.011511208, 0.011500585, 0.011491903, 0.011481295, + 0.011472624, 0.011462252, 0.011453585, 0.011442997, 0.011434355, 0.011423811, 0.011415193, 0.011404878, + 0.011396265, 0.011385744, 0.011377146, 0.011366861, 0.011358474, 0.011348166, 0.011339562, 0.011329068, + 0.011320495, 0.011310233, 0.011301656, 0.011291191, 0.011282641, 0.011272203, 0.011263683, 0.011253499, + 0.011244991, 0.011234593, 0.011226103, 0.011215952, 0.011207686, 0.011197505, 0.011189, 0.01117864, 0.011170188, + 0.011160064, 0.011151596, 0.011141268, 0.011132839, 0.011122752, 0.011114549, 0.011104456, 0.011096014, + 0.011085931, 0.01107772, 0.01106763, 0.0110592, 0.011048935, 0.01104056, 0.01103055, 0.011022396, 0.011012369, + 0.011003992, 0.01099399, 0.010985853, 0.010975845, 0.010967479, 0.010957481, 0.010949336, 0.010939355, 0.010931225, + 0.010921241, 0.010912896, 0.010902936, 0.01089483, 0.010884888, 0.010876576, 0.010866646, 0.010858557, 0.010848629, + 0.010840542, 0.010830836, 0.010822753, 0.01081284, 0.010804756, 0.010795043, 0.010786952, 0.010777041, 0.010768965, + 0.010759071, 0.010750792, 0.010740922, 0.0107329, 0.010723058, 0.01071484, 0.010705031, 0.010697045, 0.010687253, + 0.010679273, 0.010669684, 0.010661691, 0.010651897, 0.010643939, 0.010634381, 0.010626412, 0.010616648, + 0.010608688, 0.010599139, 0.010591182, 0.010581433, 0.010573492, 0.010563964, 0.010556017, 0.010546289, + 0.010538368, 0.010528862, 0.010520939, 0.010511244, 0.010503357, 0.010493897, 0.010486007, 0.010476336, + 0.010468463, 0.010459028, 0.010451161, 0.010441515, 0.010433678, 0.010424279, 0.010416443, 0.010406851, + 0.010399053, 0.010389687, 0.010381874, 0.010372294, 0.010364498, 0.010355157, 0.010347369, 0.010337831, + 0.010330074, 0.010320771, 0.010313014, 0.010303503, 0.010295766, 0.010286487, 0.010278756, 0.010269286, + 0.010261592, 0.010252352, 0.010244651, 0.010235417, 0.010227931, 0.010218679, 0.010210967, 0.010201732, + 0.010194233, 0.010184985, 0.010177282, 0.010168067, 0.010160583, 0.010151349, 0.010143662, 0.010134456, + 0.010126983, 0.010117784, 0.010110125, 0.010100942, 0.010093496, 0.010084318, 0.01007666, 0.010067504, 0.010059885, + 0.010050747, 0.010043333, 0.010034201, 0.010026593, 0.010017487, 0.010010097, 0.010000985, 0.0099933976, + 0.00998432, 0.0099769616, 0.0099680908, 0.0099607147, 0.009951626, 0.0099442536, 0.00993538, 0.0099279908, + 0.0099189067, 0.0099113351, 0.0099022724, 0.0098949252, 0.0098858858, 0.0098783439, 0.0098693315, 0.0098620225, + 0.0098532178, 0.0098459078, 0.0098369056, 0.0098296013, 0.0098208161, 0.0098135062, 0.0098045096, 0.0097969994, + 0.009788041, 0.0097807869, 0.0097720437, 0.0097647803, 0.0097558377, 0.0097485837, 0.0097398562, 0.0097326022, + 0.0097238822, 0.0097166328, 0.0097077237, 0.009700493, 0.0096917842, 0.0096845422, 0.0096756397, 0.0096684191, + 0.0096597299, 0.0096525066, 0.0096438285, 0.0096366154, 0.0096277548, 0.0096205696, 0.0096119232, 0.0096047316, + 0.0095960917, 0.0095889177, 0.0095800944, 0.0095729372, 0.0095643364, 0.009557182, 0.0095485831, 0.0095416345, + 0.0095330225, 0.009525856, 0.009517258, 0.0095101157, 0.0095015271, 0.0094945878, 0.0094860159, 0.0094788829, + 0.0094703091, 0.0094631845, 0.0094546443, 0.0094477367, 0.0094391787, 0.0094320606, 0.0094235195, 0.0094164247, + 0.0094079133, 0.0094010327, 0.0093925158, 0.009385433, 0.0093769301, 0.0093698679, 0.0093614012, 0.0093545541, + 0.0093460763, 0.0093390271, 0.0093305707, 0.0093235448, 0.0093151154, 0.0093083074, 0.009299879, 0.009292867, + 0.0092844479, 0.0092774583, 0.0092690708, 0.009262288, 0.0092538986, 0.0092469323, 0.0092385691, 0.0092316223, + 0.0092232814, 0.0092165479, 0.0092083933, 0.0092016263, 0.0091932658, 0.0091863237, 0.0091779996, 0.0091712708, + 0.0091631385, 0.0091563975, 0.0091480706, 0.0091411527, 0.0091328453, 0.0091259517, 0.0091176797, 0.00911099, + 0.0091029052, 0.0090962145, 0.0090879397, 0.0090810684, 0.0090728253, 0.0090661785, 0.0090581356, 0.0090514617, + 0.0090434067, 0.00903673, 0.0090284878, 0.0090216454, 0.0090134377, 0.009006816, 0.0089988159, 0.0089921849, + 0.0089839809, 0.0089771673, 0.0089690033, 0.008962417, 0.0089544579, 0.0089478726, 0.0089399042, 0.0089333002, + 0.0089251483, 0.0089183701, 0.0089102462, 0.0089037046, 0.0088957874, 0.0088892393, 0.0088813296, 0.0088747703, + 0.0088668531, 0.008860304, 0.0088522127, 0.008845685, 0.0088377977, 0.0088312617, 0.0088233752, 0.0088168429, + 0.0088089546, 0.0088024214, 0.0087943561, 0.0087878546, 0.0087800045, 0.0087734982, 0.0087656546, 0.0087591605, + 0.0087513234, 0.0087448265, 0.0087369923, 0.0087305028, 0.0087224869, 0.0087160273, 0.0087082312, 0.0087017762, + 0.0086939894, 0.0086875381, 0.0086797578, 0.0086733317, 0.0086655756, 0.0086591449, 0.0086512025, 0.0086448072, + 0.0086370939, 0.0086307032, 0.0086229844, 0.0086165937, 0.0086088721, 0.0086024832, 0.008594783, 0.0085886009, + 0.0085809007, 0.0085745202, 0.0085668238, 0.0085604573, 0.0085527813, 0.0085464269, 0.008538764, 0.0085324319, + 0.0085247895, 0.0085184639, 0.0085108345, 0.0085047055, 0.0084970668, 0.0084907487, 0.0084831361, 0.0084768431, + 0.0084692473, 0.0084629664, 0.0084553901, 0.0084491149, 0.0084415339, 0.0084354533, 0.0084280632, 0.0084219659, + 0.0084143765, 0.0084080948, 0.0084005259, 0.0083942665, 0.0083867237, 0.0083804848, 0.0083729587, 0.0083667338, + 0.0083592134, 0.0083529977, 0.008345508, 0.0083395019, 0.0083321892, 0.0083261617, 0.0083188443, 0.0083128056, + 0.0083052944, 0.0082990779, 0.0082915798, 0.0082853911, 0.008277935, 0.0082717696, 0.0082643321, 0.0082581956, + 0.0082507925, 0.0082448581, 0.0082376348, 0.008231678, 0.0082244277, 0.0082184467, 0.0082111992, 0.0082052238, + 0.00819779, 0.0081916396, 0.0081842337, 0.0081781223, 0.00817075, 0.0081646582, 0.0081573026, 0.0081512369, + 0.0081439195, 0.0081380531, 0.0081309117, 0.0081250258, 0.0081178686, 0.0081119705, 0.0081048161, 0.0080989236, + 0.0080917682, 0.0080858739, 0.0080787167, 0.0080728102, 0.0080656419, 0.0080597438, 0.0080524096, 0.0080463411, + 0.0080390377, 0.008033012, 0.0080257552, 0.0080197686, 0.0080125416, 0.0080067571, 0.0079997145, 0.007993916, + 0.0079868753, 0.0079810806, 0.0079740398, 0.0079682413, 0.0079611931, 0.0079553956, 0.0079483595, 0.007942575, + 0.0079355463, 0.0079297479, 0.0079227109, 0.0079169227, 0.0079098921, 0.007904103, 0.0078970827, 0.0078913039, + 0.0078842873, 0.0078785075, 0.007871503, 0.0078657437, 0.007858756, 0.0078529958, 0.0078460025, 0.0078402506, + 0.0078331018, 0.0078272019, 0.0078200921, 0.0078144083, 0.0078074997, 0.0078018163, 0.0077949106, 0.0077892281, + 0.0077823265, 0.0077766515, 0.007769757, 0.0077640889, 0.0077572023, 0.0077515431, 0.0077446741, 0.0077390294, + 0.007732166, 0.0077265208, 0.0077196537, 0.0077140131, 0.0077071711, 0.0077015497, 0.0076947277, 0.0076891175, + 0.0076822848, 0.0076766647, 0.0076698535, 0.0076642628, 0.0076574623, 0.0076518734, 0.0076450864, 0.0076395059, + 0.0076327254, 0.0076271547, 0.007620384, 0.0076148212, 0.0076080649, 0.0076025263, 0.0075957887, 0.007590252, + 0.0075835157, 0.0075779916, 0.0075712777, 0.0075657601, 0.0075590555, 0.0075535597, 0.0075468668, 0.0075413724, + 0.0075346995, 0.0075292173, 0.0075225485, 0.0075170775, 0.0075104176, 0.0075049521, 0.0074983016, 0.007492851, + 0.0074863886, 0.0074811024, 0.0074746246, 0.0074693193, 0.0074628168, 0.0074574952, 0.007450975, 0.007445639, + 0.007439123, 0.0074337875, 0.0074272612, 0.0074219145, 0.0074153906, 0.0074100471, 0.0074035302, 0.0073981867, + 0.007391667, 0.007386331, 0.0073798187, 0.0073744846, 0.00736797, 0.0073624593, 0.0073557971, 0.0073503279, + 0.0073436992, 0.0073382603, 0.0073316675, 0.0073262663, 0.007319707, 0.007314329, 0.0073077939, 0.007302436, + 0.0072959242, 0.0072905933, 0.0072841151, 0.0072788177, 0.0072725248, 0.0072673829, 0.0072610695, 0.0072559114, + 0.007249584, 0.007244416, 0.0072380877, 0.0072329235, 0.0072265998, 0.0072214324, 0.0072151013, 0.0072099227, + 0.007203585, 0.007198411, 0.0071920808, 0.0071867425, 0.0071802763, 0.0071749766, 0.0071685356, 0.0071632718, + 0.0071570356, 0.0071519474, 0.0071457056, 0.007140615, 0.0071343873, 0.0071293074, 0.0071230666, 0.0071179727, + 0.0071117347, 0.0071066478, 0.0071004159, 0.0070953341, 0.0070891045, 0.0070840241, 0.0070778076, 0.007072567, + 0.0070661912, 0.0070609823, 0.0070548183, 0.0070497901, 0.0070436285, 0.0070386031, 0.0070324377, 0.0070274174, + 0.007021267, 0.0070162546, 0.0070101023, 0.0070050852, 0.0069989394, 0.006993935, 0.0069878004, 0.0069826394, + 0.0069765244, 0.0069715478, 0.0069654402, 0.0069604605, 0.0069543514, 0.0069493819, 0.006943285, 0.006938322, + 0.0069322302, 0.0069272732, 0.0069211964, 0.0069162482, 0.0069101723, 0.0069050663, 0.0068990164, 0.0068940935, + 0.0068880557, 0.0068831495, 0.0068771229, 0.00687222, 0.0068661957, 0.0068612969, 0.0068552876, 0.0068503954, + 0.0068443851, 0.0068395068, 0.0068336739, 0.0068287835, 0.006822777, 0.0068178936, 0.0068119043, 0.0068070311, + 0.0068010464, 0.0067961896, 0.0067902221, 0.0067853737, 0.0067795888, 0.0067749065, 0.0067690914, 0.0067642168, + 0.0067582349, 0.0067533762, 0.0067474199, 0.0067425799, 0.0067366394, 0.0067318142, 0.0067260498, 0.0067213895, + 0.0067156157, 0.0067107813, 0.0067048534, 0.0067000408, 0.0066941194, 0.0066893115, 0.0066834153, 0.0066786339, + 0.0066729211, 0.006668299, 0.0066625676, 0.0066577704, 0.0066518816, 0.006647103, 0.0066412338, 0.0066364734, + 0.0066307895, 0.0066261976, 0.0066204993, 0.0066158916, 0.0066101854, 0.00660541, 0.0065995441, 0.0065947836, + 0.0065889438, 0.0065842178, 0.0065785688, 0.0065740081, 0.006568349, 0.0065636146, 0.0065578045, 0.006553099, + 0.0065473053, 0.0065426207, 0.0065370174, 0.0065324856, 0.0065268599, 0.0065221624, 0.0065163858, 0.0065117148, + 0.0065059694, 0.006501318, 0.0064957538, 0.0064912736, 0.0064857067, 0.0064810561, 0.0064753303, 0.0064706989, + 0.0064649945, 0.0064603826, 0.0064548613, 0.0064504133, 0.0064448779, 0.0064402553, 0.0064345691, 0.006429974, + 0.0064244694, 0.0064200414, 0.0064145299, 0.0064100912, 0.0064045722, 0.006399971, 0.0063943123, 0.006389746, + 0.0063842679, 0.0063798609, 0.0063743787, 0.006369967, 0.0063644759, 0.0063598938, 0.0063544135, 0.0063500083, + 0.0063445293, 0.0063401223, 0.0063346415, 0.0063300836, 0.0063244724, 0.0063199345, 0.0063145016, 0.0063101426, + 0.0063047106, 0.0063003371, 0.0062948987, 0.0062903762, 0.006284954, 0.0062805931, 0.0062751742, 0.0062708212, + 0.0062653995, 0.0062608956, 0.0062555023, 0.0062511652, 0.0062457607, 0.0062414245, 0.0062360317, 0.0062315431, + 0.0062260041, 0.0062215473, 0.0062162052, 0.0062119248, 0.0062065814, 0.0062022922, 0.0061969459, 0.006192503, + 0.0061871712, 0.0061829067, 0.0061775823, 0.0061733094, 0.006167979, 0.0061635487, 0.0061582378, 0.0061539854, + 0.0061486783, 0.0061444212, 0.00613927, 0.006135013, 0.0061297058, 0.0061254506, 0.0061201476, 0.0061159073, + 0.0061107692, 0.0061065126, 0.0061012073, 0.0060969666, 0.0060916771, 0.0060874377, 0.0060823094, 0.0060780635, + 0.0060727741, 0.0060685398, 0.0060632606, 0.0060588825, 0.0060536293, 0.0060494281, 0.0060441853, 0.0060399934, + 0.0060347635, 0.0060304278, 0.0060252231, 0.0060210642, 0.0060158633, 0.0060117147, 0.0060066786, 0.006002523, + 0.0059973244, 0.0059931693, 0.0059879827, 0.0059838453, 0.005978825, 0.0059746793, 0.0059694936, 0.00596536, + 0.0059601911, 0.0059559112, 0.0059507629, 0.0059466553, 0.0059415167, 0.0059374212, 0.0059324447, 0.0059283506, + 0.0059232255, 0.0059191328, 0.0059140096, 0.0059099356, 0.0059049786, 0.0059008938, 0.005895779, 0.0058917068, + 0.0058867619, 0.0058826879, 0.0058775814, 0.0058735162, 0.0058684289, 0.0058643781, 0.0058594542, 0.0058553996, + 0.0058503235, 0.0058462848, 0.005841373, 0.0058373353, 0.0058322703, 0.0058282446, 0.0058233491, 0.0058193132, + 0.005814258, 0.0058102445, 0.0058052037, 0.0058012055, 0.0057963436, 0.0057923496, 0.0057873325, 0.005783346, + 0.0057784957, 0.0057745161, 0.0057695159, 0.0057655438, 0.0057607042, 0.0057567353, 0.0057517537, 0.0057478035, + 0.0057429816, 0.0057391804, 0.005734344, 0.0057303747, 0.0057253959, 0.0057214433, 0.0057166237, 0.0057126712, + 0.005707711, 0.005703785, 0.0056989896, 0.0056950608, 0.005690122, 0.0056862063, 0.0056814309, 0.0056776721, + 0.0056728888, 0.0056689647, 0.0056641819, 0.0056604189, 0.0056556305, 0.0056517045, 0.0056469231, 0.0056431545, + 0.0056383591, 0.0056344322, 0.0056296526, 0.005625891, 0.005621112, 0.0056171934, 0.0056122784, 0.0056083966, + 0.0056036571, 0.0055997749, 0.0055948882, 0.0055910302, 0.0055863205, 0.0055824765, 0.0055776257, 0.0055737956, + 0.0055691106, 0.0055652861, 0.0055604549, 0.0055566453, 0.0055519887, 0.0055481899, 0.0055433842, 0.0055396035, + 0.0055349744, 0.0055311914, 0.0055264048, 0.0055226423, 0.0055180276, 0.0055142716, 0.0055095134, 0.00550577, + 0.0055011781, 0.0054974407, 0.0054927021, 0.0054889778, 0.0054844026, 0.0054806797, 0.0054759518, 0.005472247, + 0.0054676924, 0.0054639876, 0.0054594292, 0.0054558739, 0.005451309, 0.0054475986, 0.0054430412, 0.0054394784, + 0.0054349056, 0.0054311906, 0.005426629, 0.0054230676, 0.0054185037, 0.0054147877, 0.0054102275, 0.0054066712, + 0.0054021133, 0.0053984076, 0.0053938548, 0.0053903041, 0.0053857551, 0.0053820605, 0.0053775203, 0.0053739795, + 0.0053694365, 0.0053657498, 0.0053612231, 0.0053576906, 0.0053531588, 0.0053494861, 0.0053449729, 0.005341311, + 0.0053368108, 0.0053333016, 0.0053287898, 0.0053251334, 0.005320638, 0.0053171418, 0.0053126533, 0.0053090188, + 0.0053045419, 0.0053010588, 0.0052965768, 0.0052929497, 0.0052884854, 0.0052850205, 0.0052807056, 0.0052772257, + 0.0052727475, 0.0052691191, 0.0052646613, 0.0052612009, 0.0052567436, 0.0052531357, 0.005248691, 0.0052452437, + 0.0052408059, 0.0052372175, 0.0052327928, 0.0052293614, 0.0052250843, 0.0052216412, 0.0052172113, 0.0052136392, + 0.005209229, 0.0052058022, 0.0052013914, 0.0051978384, 0.0051934528, 0.00519006, 0.0051858174, 0.0051824087, + 0.0051780134, 0.0051744659, 0.0051700873, 0.0051667043, 0.0051623317, 0.0051588109, 0.0051544602, 0.0051510949, + 0.0051468927, 0.0051435251, 0.0051391614, 0.0051356452, 0.0051313043, 0.0051279543, 0.0051236167, 0.0051201293, + 0.0051158159, 0.0051124911, 0.0051083155, 0.0051049762, 0.0051006568, 0.0050971825, 0.0050928863, 0.0050895778, + 0.0050854231, 0.0050820997, 0.0050777886, 0.0050744731, 0.0050703227, 0.0050669988, 0.0050626933, 0.0050592362, + 0.0050549554, 0.0050516576, 0.005047523, 0.0050442223, 0.0050399434, 0.0050365124, 0.005032259, 0.0050289929, + 0.0050248853, 0.0050216052, 0.0050173495, 0.0050139385, 0.0050097033, 0.0050064572, 0.0050023692, 0.0049991142, + 0.0049948874, 0.0049916441, 0.0049875635, 0.0049843122, 0.0049802214, 0.0049769641, 0.0049727289, 0.0049694814, + 0.004965404, 0.0049621644, 0.004958088, 0.0049548405, 0.0049506193, 0.0049473876, 0.0049433238, 0.0049400902, + 0.0049360222, 0.0049327835, 0.0049285749, 0.0049253558, 0.0049213031, 0.0049180831, 0.00491403, 0.0049108132, + 0.0049066278, 0.0049034273, 0.0048993928, 0.0048961937, 0.0048921602, 0.0048889569, 0.004884786, 0.004881606, + 0.0048775962, 0.0048744176, 0.0048704036, 0.0048672189, 0.0048630685, 0.0048597669, 0.0048556491, 0.0048525124, + 0.0048485422, 0.0048454045, 0.0048414371, 0.0048382981, 0.0048341933, 0.0048310701, 0.0048271134, 0.0048239874, + 0.0048200334, 0.004816913, 0.0048128213, 0.0048097102, 0.0048057716, 0.0048026652, 0.0047987294, 0.0047956165, + 0.0047915401, 0.0047883145, 0.0047842744, 0.0047812136, 0.0047773155, 0.0047742445, 0.0047703492, 0.004767281, + 0.0047632437, 0.0047601876, 0.0047563012, 0.0047532464, 0.0047493596, 0.004746303, 0.004742418, 0.0047393604, + 0.004735339, 0.0047322991, 0.0047284304, 0.0047253887, 0.0047215219, 0.0047184834, 0.0047144797, 0.0047114547, + 0.0047076028, 0.0047045862, 0.0047007427, 0.0046977275, 0.0046938858, 0.0046908781, 0.0046869074, 0.004683916, + 0.0046800966, 0.0046771001, 0.0046732733, 0.0046702786, 0.0046664574, 0.0046634683, 0.0046595191, 0.0046565454, + 0.0046527432, 0.0046497695, 0.004645973, 0.0046430049, 0.0046392102, 0.0046362439, 0.0046324492, 0.0046296227, + 0.0046258233, 0.0046228464, 0.0046190438, 0.004616078, 0.0046122945, 0.0046093417, 0.004605561, 0.0046027419, + 0.004598951, 0.0045959894, 0.0045922049, 0.004589254, 0.0045854822, 0.0045825434, 0.0045787818, 0.0045758518, + 0.0045719617, 0.0045690443, 0.0045653041, 0.0045623961, 0.0045586615, 0.0045557567, 0.0045520277, 0.004549128, + 0.004545405, 0.0045425133, 0.0045386641, 0.0045357915, 0.0045320941, 0.0045292266, 0.0045255371, 0.0045226733, + 0.0045189876, 0.0045161289, 0.0045124446, 0.0045097223, 0.0045060306, 0.0045031663, 0.0044994815, 0.0044966233, + 0.0044929418, 0.0044900854, 0.0044864099, 0.0044835736, 0.0044799116, 0.0044772089, 0.0044736732, 0.0044709537, + 0.0044672689, 0.0044644149, 0.0044607427, 0.0044578961, 0.0044542304, 0.0044513973, 0.0044477405, 0.0044449139, + 0.0044412673, 0.0044385889, 0.004434939, 0.0044321171, 0.0044284794, 0.0044256765, 0.004422049, 0.0044192499, + 0.0044156322, 0.0044128462, 0.0044092378, 0.0044064559, 0.004402854, 0.0044002146, 0.0043966076, 0.0043938304, + 0.0043902388, 0.0043874807, 0.0043839007, 0.00438115, 0.0043775728, 0.0043748212, 0.0043712514, 0.004368512, + 0.0043649473, 0.0043623447, 0.0043589096, 0.0043562949, 0.0043527158, 0.0043499656, 0.0043463968, 0.0043436564, + 0.004340101, 0.004337376, 0.0043338262, 0.0043311063, 0.0043275678, 0.0043248599, 0.004321333, 0.0043187686, + 0.0043153702, 0.0043127905, 0.0043092449, 0.0043065306, 0.0043029985, 0.0043003, 0.0042967768, 0.0042940844, + 0.0042905738, 0.0042878971, 0.0042844005, 0.0042817355, 0.0042782482, 0.0042757182, 0.0042723524, 0.0042698029, + 0.0042664288, 0.0042638755, 0.0042603528, 0.0042576687, 0.0042541684, 0.0042515006, 0.0042480142, 0.0042453622, + 0.0042418931, 0.0042392518, 0.0042357887, 0.0042331512, 0.0042296946, 0.0042270748, 0.0042236359, 0.004221159, + 0.0042178459, 0.0042153504, 0.0042120209, 0.0042095119, 0.0042061722, 0.0042036581, 0.0042001875, 0.0041975542, + 0.004194099, 0.0041914745, 0.0041880338, 0.0041854279, 0.004182002, 0.0041794106, 0.0041760039, 0.004173432, + 0.0041700345, 0.0041674613, 0.0041640662, 0.004161506, 0.0041581267, 0.0041557103, 0.0041524596, 0.0041500265, + 0.0041467603, 0.004144311, 0.0041410322, 0.0041385815, 0.0041353009, 0.004132844, 0.0041294317, 0.0041268552, + 0.0041234596, 0.0041208994, 0.0041175168, 0.004114971, 0.004111609, 0.0041090772, 0.004105723, 0.004103201, + 0.0040998608, 0.0040973537, 0.0040940247, 0.0040915296, 0.0040882085, 0.0040857214, 0.004082419, 0.0040799486, + 0.0040766513, 0.0040743104, 0.0040711304, 0.0040687709, 0.0040655807, 0.0040632188, 0.0040600263, 0.0040576565, + 0.0040544537, 0.0040520742, 0.0040488639, 0.0040464788, 0.0040432625, 0.0040408741, 0.0040376568, 0.0040352684, + 0.0040320526, 0.0040296619, 0.0040264367, 0.0040240423, 0.0040208185, 0.0040184264, 0.0040150746, 0.0040125637, + 0.0040092445, 0.0040067653, 0.0040034666, 0.0040010088, 0.0039977306, 0.0039952868, 0.0039920239, 0.0039895982, + 0.0039863489, 0.0039839339, 0.0039806957, 0.0039782929, 0.0039750705, 0.0039726817, 0.0039694686, 0.0039670891, + 0.0039638844, 0.0039615189, 0.0039583305, 0.0039559752, 0.0039527938, 0.0039504482, 0.0039472757, 0.0039449339, + 0.0039417655, 0.0039394335, 0.003936281, 0.0039339638, 0.0039308169, 0.0039285058, 0.0039253682, 0.003923059, + 0.0039199209, 0.0039176187, 0.0039144936, 0.0039122044, 0.0039090835, 0.0039067939, 0.0039036786, 0.0039013992, + 0.0038982916, 0.0038960206, 0.0038929193, 0.003890651, 0.003887557, 0.0038852973, 0.0038822086, 0.0038799529, + 0.0038768682, 0.0038746158, 0.0038715319, 0.0038692828, 0.0038662076, 0.0038639624, 0.0038608902, 0.0038586557, + 0.0038555907, 0.003853356, 0.0038504207, 0.0038483082, 0.0038453494, 0.0038432169, 0.003840249, 0.0038381089, + 0.0038351265, 0.0038329661, 0.0038299703, 0.0038278021, 0.0038247972, 0.0038226217, 0.0038196116, 0.0038174328, + 0.0038144207, 0.0038122458, 0.0038092332, 0.0038070488, 0.003804036, 0.0038018553, 0.0037988336, 0.0037966429, + 0.003793621, 0.0037914333, 0.0037884079, 0.0037862188, 0.0037832006, 0.0037810169, 0.0037779978, 0.0037758092, + 0.0037727864, 0.0037704825, 0.0037673584, 0.0037650799, 0.0037619846, 0.0037597362, 0.003756661, 0.0037544328, + 0.003751375, 0.003749154, 0.0037461086, 0.0037439053, 0.0037409952, 0.0037389211, 0.0037360101, 0.0037339269, + 0.0037310058, 0.0037289192, 0.0037259921, 0.0037238961, 0.003720965, 0.0037188707, 0.0037159394, 0.0037138432, + 0.0037109109, 0.0037088131, 0.0037058797, 0.00370378, 0.0037008442, 0.0036986282, 0.0036955879, 0.0036933979, + 0.0036903825, 0.003688212, 0.0036852113, 0.0036830588, 0.0036802029, 0.003678177, 0.0036753104, 0.003673278, + 0.0036704044, 0.003668369, 0.0036654973, 0.0036634614, 0.0036605895, 0.0036585547, 0.0036556788, 0.0036536416, + 0.0036507673, 0.0036487291, 0.0036458534, 0.0036436943, 0.0036407094, 0.0036385767, 0.0036356191, 0.0036335026, + 0.0036306751, 0.0036286893, 0.0036258665, 0.0036238788, 0.0036210516, 0.003619062, 0.0036162313, 0.0036142375, + 0.0036114042, 0.0036094093, 0.0036065751, 0.0036045816, 0.003601748, 0.0035996318, 0.0035966912, 0.0035946013, + 0.0035916828, 0.0035896129, 0.003586831, 0.0035848881, 0.0035821008, 0.003580156, 0.003577369, 0.0035754165, + 0.0035726251, 0.0035706803, 0.0035678884, 0.003565934, 0.0035631401, 0.0035610669, 0.0035581675, 0.0035561225, + 0.0035533635, 0.0035514424, 0.0035486815, 0.00354676, 0.00354399, 0.0035420635, 0.0035392994, 0.0035373755, + 0.0035346046, 0.0035326758, 0.0035299091, 0.0035278678, 0.0035249908, 0.0035229668, 0.0035202347, 0.0035183483, + 0.0035156182, 0.0035137276, 0.003510992, 0.0035090963, 0.0035063573, 0.0035044614, 0.0035017198, 0.0034998239, + 0.0034970872, 0.0034950729, 0.0034923465, 0.0034904629, 0.0034877316, 0.0034858438, 0.0034831138, 0.0034812321, + 0.0034785119, 0.0034766358, 0.0034739105, 0.003472029, 0.0034693046, 0.003467306, 0.0034645966, 0.0034627316, + 0.0034600231, 0.0034581644, 0.0034554594, 0.0034535981, 0.0034508933, 0.0034490332, 0.0034463299, 0.0034443582, + 0.0034415538, 0.003439605, 0.0034369393, 0.0034351193, 0.0034324545, 0.0034306317, 0.0034279611, 0.0034261371, + 0.0034234643, 0.0034216403, 0.0034189762, 0.0034170372, 0.0034143794, 0.0034125685, 0.0034099093, 0.0034080991, + 0.0034054474, 0.0034036431, 0.0034009861, 0.0033991754, 0.003396523, 0.0033946019, 0.0033919597, 0.0033901648, + 0.0033875259, 0.0033857336, 0.0033830907, 0.0033813005, 0.0033786651, 0.0033768786, 0.0033742427, 0.0033723391, + 0.0033697193, 0.003367949, 0.0033653257, 0.0033635513, 0.0033609336, 0.003359166, 0.0033565452, 0.00335466, + 0.0033520556, 0.0033503005, 0.0033476953, 0.0033459389, 0.0033433326, 0.0033415775, 0.0033389719, 0.0033372201, + 0.0033346212, 0.0033327576, 0.0033301718, 0.0033284381, 0.0033258526, 0.0033241166, 0.0033215324, 0.0033198013, + 0.0033172152, 0.0033153614, 0.0033127896, 0.0033110685, 0.0033084971, 0.00330678, 0.0033042091, 0.0033024936, + 0.0032999259, 0.003298094, 0.0032955396, 0.0032938409, 0.0032912877, 0.0032895885, 0.0032870383, 0.0032853389, + 0.0032827838, 0.0032810825, 0.0032786466, 0.0032769397, 0.0032743816, 0.0032726771, 0.0032701218, 0.0032684209, + 0.0032658698, 0.003264176, 0.0032617424, 0.0032600439, 0.0032574947, 0.0032557959, 0.0032532474, 0.0032515593, + 0.0032490166, 0.003247217, 0.0032446908, 0.0032430161, 0.0032404885, 0.0032388216, 0.0032363029, 0.0032346426, + 0.0032321247, 0.0032303501, 0.0032278493, 0.0032262031, 0.0032236993, 0.0032220539, 0.0032195563, 0.0032179148, + 0.0032154205, 0.0032136717, 0.0032111944, 0.0032095718, 0.0032070894, 0.0032054631, 0.0032029806, 0.0032012449, + 0.0031987752, 0.0031971585, 0.0031946877, 0.0031930772, 0.003190608, 0.0031889989, 0.0031865353, 0.003184818, + 0.0031823651, 0.0031807686, 0.0031783124, 0.0031767148, 0.0031742607, 0.0031725543, 0.0031701145, 0.0031685331, + 0.0031660944, 0.0031645126, 0.0031620699, 0.0031604893, 0.0031580487, 0.003156356, 0.0031539288, 0.0031523616, + 0.0031499388, 0.0031483732, 0.0031459474, 0.0031442731, 0.0031418626, 0.0031403084, 0.0031378921, 0.0031363373, + 0.0031339272, 0.0031322667, 0.0031298674, 0.0031283281, 0.0031259242, 0.0031243823, 0.0031219819, 0.0031204433, + 0.0031181523, 0.0031165972, 0.0031141858, 0.0031126421, 0.003110239, 0.0031086965, 0.0031064022, 0.003104849, + 0.0031024406, 0.0031008942, 0.0030984778, 0.0030969295, 0.0030946354, 0.0030930797, 0.0030906701, 0.0030891311, + 0.0030867278, 0.003085186, 0.0030828987, 0.003081358, 0.0030789571, 0.0030774199, 0.0030750197, 0.0030734863, + 0.0030712043, 0.0030696709, 0.0030672727, 0.0030657391, 0.0030633477, 0.0030618224, 0.0030595446, 0.0030580177, + 0.0030556289, 0.0030541092, 0.0030517322, 0.0030502202, 0.0030479566, 0.0030464411, 0.0030440644, 0.0030425575, + 0.0030401913, 0.0030386932, 0.0030364404, 0.0030349358, 0.0030325665, 0.0030310645, 0.0030287048, 0.0030271045, + 0.0030247569, 0.0030232808, 0.0030209466, 0.0030194786, 0.0030171438, 0.0030155685, 0.0030132469, 0.0030117962, + 0.0030094793, 0.003008029, 0.0030057121, 0.0030041544, 0.0030018531, 0.0030004194, 0.0029981192, 0.0029966899, + 0.0029945043, 0.0029930691, 0.0029907627, 0.0029893257, 0.0029870246, 0.0029854842, 0.0029831943, 0.0029817775, + 0.0029794928, 0.0029780776, 0.0029757952, 0.0029742743, 0.0029720042, 0.0029706047, 0.0029683355, 0.002966933, + 0.0029647755, 0.0029633704, 0.0029610919, 0.0029596889, 0.0029574176, 0.0029559042, 0.002953639, 0.0029522504, + 0.0029499948, 0.0029486089, 0.0029464585, 0.0029450606, 0.0029427935, 0.0029414017, 0.0029391448, 0.0029376531, + 0.0029354079, 0.0029340324, 0.0029317883, 0.0029304174, 0.002928281, 0.0029268998, 0.0029246474, 0.0029232688, + 0.0029210213, 0.0029195426, 0.0029173107, 0.0029159491, 0.0029137181, 0.0029123586, 0.0029102359, 0.0029088724, + 0.002906637, 0.0029052778, 0.0029030491, 0.0029015851, 0.0028993655, 0.0028980232, 0.0028958041, 0.0028944591, + 0.0028923561, 0.0028910076, 0.0028887831, 0.0028874346, 0.0028852143, 0.0028837628, 0.0028815563, 0.0028802278, + 0.0028780263, 0.0028765951, 0.0028744056, 0.0028730896, 0.0028708982, 0.0028695862, 0.0028675089, 0.0028661888, + 0.0028639967, 0.0028626821, 0.0028604893, 0.0028590676, 0.0028568916, 0.002855588, 0.0028534087, 0.0028520019, + 0.0028498354, 0.0028485453, 0.0028463765, 0.0028450848, 0.0028430254, 0.0028417292, 0.0028395571, 0.0028382645, + 0.0028360982, 0.0028347024, 0.002832544, 0.0028312625, 0.0028291044, 0.0028277179, 0.0028255743, 0.0028243077, + 0.0028221626, 0.0028207896, 0.0028186548, 0.0028173975, 0.0028152622, 0.002814007, 0.0028119802, 0.0028107176, + 0.0028085774, 0.0028073129, 0.0028052754, 0.0028040076, 0.0028018623, 0.0028005957, 0.0027984499, 0.0027970786, + 0.0027949461, 0.0027936983, 0.0027915677, 0.0027902087, 0.0027880908, 0.002786855, 0.0027847381, 0.0027833967, + 0.0027812908, 0.0027800661, 0.0027779569, 0.0027767299, 0.0027747303, 0.0027734938, 0.0027713773, 0.0027701459, + 0.0027681447, 0.0027669109, 0.0027647919, 0.0027635572, 0.0027615475, 0.0027603055, 0.0027581861, 0.0027569509, + 0.0027549397, 0.0027536985, 0.0027515779, 0.0027503422, 0.0027482284, 0.0027468975, 0.0027447997, 0.0027435855, + 0.0027414882, 0.0027401703, 0.0027380914, 0.0027368967, 0.0027348136, 0.0027335114, 0.0027314429, 0.0027302601, + 0.0027281956, 0.0027269111, 0.0027248564, 0.0027236838, 0.0027216219, 0.0027203402, 0.0027182931, 0.0027171301, + 0.0027150796, 0.002713809, 0.0027117718, 0.0027106169, 0.0027085769, 0.0027073219, 0.0027052946, 0.0027041493, + 0.002702116, 0.0027008667, 0.0026988443, 0.0026977058, 0.002695678, 0.0026944317, 0.0026924175, 0.0026912864, + 0.0026892649, 0.0026880298, 0.0026860205, 0.0026848945, 0.0026828835, 0.0026816514, 0.0026796425, 0.0026785245, + 0.0026765177, 0.002675293, 0.0026732974, 0.0026721882, 0.0026702886, 0.002669163, 0.0026671502, 0.002666024, + 0.0026641132, 0.002662977, 0.0026609541, 0.0026598212, 0.002657905, 0.002656765, 0.002654739, 0.0026536055, + 0.0026516875, 0.0026505466, 0.0026485194, 0.0026472777, 0.0026452623, 0.0026441398, 0.0026421286, 0.002640906, + 0.0026389088, 0.0026378026, 0.0026358066, 0.0026345961, 0.0026326105, 0.0026315169, 0.0026295313, 0.0026283341, + 0.0026263602, 0.0026252735, 0.0026232961, 0.002622111, 0.002620148, 0.0026190726, 0.0026172064, 0.0026161168, + 0.002614141, 0.0026130592, 0.002611188, 0.0026100946, 0.0026081095, 0.0026069165, 0.0026049449, 0.0026038634, + 0.0026018946, 0.0026007188, 0.0025987646, 0.0025977031, 0.0025957483, 0.0025945825, 0.0025926346, 0.0025915785, + 0.0025897331, 0.0025886691, 0.0025867091, 0.0025856423, 0.0025837903, 0.0025827209, 0.0025807596, 0.0025795917, + 0.0025776401, 0.0025765849, 0.0025746364, 0.0025734797, 0.0025715441, 0.0025705057, 0.0025685711, 0.0025674279, + 0.0025655041, 0.0025644731, 0.0025626488, 0.0025616072, 0.0025596723, 0.0025585315, 0.0025566078, 0.002555581, + 0.0025536607, 0.0025525335, 0.0025506208, 0.0025496027, 0.0025476897, 0.0025465714, 0.0025446697, 0.0025436613, + 0.002541861, 0.0025408445, 0.0025389337, 0.0025378177, 0.0025359129, 0.0025349057, 0.0025330035, 0.0025318973, + 0.0025300062, 0.0025290113, 0.0025272218, 0.0025262178, 0.0025243124, 0.0025232022, 0.0025213081, 0.0025203137, + 0.0025184222, 0.00251733, 0.0025154529, 0.0025144701, 0.0025126881, 0.0025116925, 0.0025098016, 0.0025087092, + 0.0025068291, 0.0025058482, 0.0025039676, 0.002502884, 0.0025010149, 0.0025000444, 0.0024982751, 0.0024972938, + 0.0024954148, 0.0024943368, 0.0024924662, 0.002491496, 0.0024896297, 0.0024885584, 0.0024866976, 0.0024857393, + 0.0024839814, 0.0024830124, 0.0024811474, 0.0024800817, 0.0024782249, 0.0024772685, 0.002475414, 0.0024743583, + 0.0024725113, 0.0024715657, 0.00246982, 0.0024688656, 0.0024670118, 0.002465958, 0.0024641121, 0.0024631673, + 0.0024614208, 0.0024604653, 0.0024586108, 0.00245756, 0.0024557186, 0.0024547796, 0.0024529381, 0.0024519004, + 0.002450071, 0.0024491416, 0.0024474082, 0.0024464687, 0.002444627, 0.0024435895, 0.002441762, 0.0024408358, + 0.0024391059, 0.0024381685, 0.0024363287, 0.002435294, 0.002433467, 0.0024325475, 0.0024307258, 0.0024297091, + 0.002427899, 0.0024268895, 0.0024250862, 0.0024241845, 0.0024223807, 0.0024213796, 0.0024195814, 0.0024186869, + 0.0024169865, 0.002416081, 0.0024142717, 0.0024132694, 0.0024114719, 0.002410576, 0.0024088789, 0.0024079776, + 0.0024061706, 0.0024051706, 0.0024033743, 0.0024024823, 0.0024007838, 0.002399887, 0.0023980879, 0.0023970939, + 0.0023953039, 0.0023944192, 0.0023927237, 0.0023918243, 0.0023900233, 0.0023890326, 0.0023872457, 0.0023863644, + 0.002384674, 0.0023837821, 0.0023819872, 0.0023809993, 0.0023792153, 0.0023783399, 0.0023765583, 0.0023755857, + 0.0023738132, 0.00237285, 0.0023710872, 0.0023702292, 0.0023684662, 0.0023675137, 0.0023657614, 0.0023648159, + 0.0023630713, 0.0023622322, 0.0023605831, 0.0023597318, 0.0023579723, 0.0023570214, 0.0023552713, 0.0023544293, + 0.0023527762, 0.0023519231, 0.0023501609, 0.0023492139, 0.0023474672, 0.0023466253, 0.0023449727, 0.0023441231, + 0.0023423673, 0.0023414225, 0.0023396772, 0.0023388399, 0.0023371917, 0.0023363465, 0.0023345933, 0.0023336534, + 0.0023319144, 0.0023309861, 0.0023292566, 0.0023284357, 0.0023267036, 0.0023257819, 0.0023240584, 0.0023231499, + 0.0023214377, 0.0023206321, 0.0023189129, 0.0023180053, 0.0023162963, 0.0023153985, 0.0023136958, 0.0023129033, + 0.0023112942, 0.0023104895, 0.002308774, 0.0023078716, 0.002306167, 0.0023052737, 0.0023035738, 0.002302784, + 0.0023010834, 0.0023001961, 0.0022985027, 0.002297624, 0.0022959369, 0.0022951595, 0.0022935653, 0.0022927735, + 0.0022910703, 0.0022901827, 0.0022884919, 0.0022876163, 0.0022859336, 0.0022851592, 0.0022834737, 0.0022825995, + 0.0022809168, 0.0022800544, 0.0022783861, 0.0022776241, 0.0022760408, 0.0022752644, 0.0022735766, 0.0022727042, + 0.0022710233, 0.0022701605, 0.0022684871, 0.0022677246, 0.0022660526, 0.0022651979, 0.0022635334, 0.0022626852, + 0.0022610284, 0.0022602803, 0.0022587131, 0.0022579536, 0.00225628, 0.0022554239, 0.0022537594, 0.002252911, + 0.0022512542, 0.0022505077, 0.0022489422, 0.0022481836, 0.0022465123, 0.002245662, 0.0022440003, 0.0022431563, + 0.0022415025, 0.0022407614, 0.0022391055, 0.0022382694, 0.0022366219, 0.0022357928, 0.0022341534, 0.0022333302, + 0.0022316936, 0.0022309714, 0.0022293336, 0.0022285134, 0.0022268796, 0.002226064, 0.0022244395, 0.0022236349, + 0.0022220134, 0.0022213033, 0.0022196777, 0.0022188739, 0.0022172562, 0.0022164572, 0.0022148443, 0.0022140481, + 0.002212439, 0.0022117409, 0.0022101251, 0.0022093311, 0.0022077202, 0.0022069274, 0.0022053218, 0.0022045346, + 0.0022029309, 0.0022022403, 0.0022006324, 0.0021998459, 0.0021982447, 0.0021974638, 0.0021958682, 0.0021950922, + 0.0021934968, 0.002192813, 0.0021912111, 0.0021904281, 0.0021888327, 0.0021880618, 0.0021864725, 0.0021857035, + 0.0021841202, 0.002183357, 0.0021817763, 0.0021811076, 0.0021795195, 0.0021787519, 0.0021771693, 0.0021764098, + 0.0021748303, 0.0021740694, 0.0021724927, 0.0021718324, 0.0021702519, 0.0021694917, 0.0021679159, 0.0021671632, + 0.002165589, 0.0021648344, 0.0021632647, 0.0021625166, 0.0021609482, 0.0021602963, 0.0021587235, 0.0021579738, + 0.0021564043, 0.0021556574, 0.002154093, 0.0021533503, 0.0021517905, 0.0021511498, 0.0021495833, 0.0021488387, + 0.0021472771, 0.0021465423, 0.002144987, 0.0021442524, 0.0021426971, 0.0021419658, 0.0021404154, 0.0021397793, + 0.00213822, 0.0021374859, 0.0021359331, 0.0021352042, 0.002133654, 0.0021329271, 0.0021313825, 0.0021306628, + 0.002129121, 0.0021284954, 0.0021269454, 0.0021262197, 0.0021246751, 0.0021239547, 0.0021224101, 0.0021216935, + 0.0021201596, 0.0021194497, 0.0021179146, 0.0021172964, 0.0021157577, 0.002115045, 0.0021135102, 0.0021128007, + 0.0021112692, 0.0021105644, 0.0021090375, 0.0021083336, 0.0021068088, 0.0021061096, 0.0021045872, 0.0021039806, + 0.0021024495, 0.0021017485, 0.0021002246, 0.0020995259, 0.0020980039, 0.0020973084, 0.0020957885, 0.0020950972, + 0.0020935833, 0.0020929875, 0.0020914695, 0.0020907787, 0.0020892622, 0.0020885749, 0.0020870627, 0.0020863754, + 0.0020848645, 0.0020841821, 0.0020826771, 0.0020819998, 0.0020804966, 0.0020799122, 0.0020784035, 0.0020777232, + 0.0020762184, 0.0020755418, 0.0020740386, 0.0020733646, 0.0020718647, 0.0020711939, 0.0020697012, 0.0020690337, + 0.0020675387, 0.0020669643, 0.0020654637, 0.0020647938, 0.0020632967, 0.0020626273, 0.0020611344, 0.0020604732, + 0.0020589861, 0.0020583265, 0.0020568424, 0.0020561886, 0.0020547088, 0.0020541491, 0.002052661, 0.0020520021, + 0.0020505162, 0.002049861, 0.0020483793, 0.0020477262, 0.002046247, 0.0020456, 0.0020441278, 0.0020434849, + 0.0020420135, 0.0020413697, 0.0020398074, 0.0020391748, 0.0020377142, 0.0020370847, 0.002035629, 0.0020350036, + 0.002033547, 0.0020329177, 0.0020314606, 0.0020308355, 0.0020293805, 0.0020287563, 0.0020273034, 0.0020266816, + 0.0020251402, 0.0020245255, 0.0020230799, 0.002022465, 0.0020210207, 0.0020204082, 0.0020189662, 0.002018353, + 0.0020169083, 0.0020162978, 0.0020148579, 0.0020142498, 0.0020128111, 0.0020122011, 0.0020107627, 0.0020101538, + 0.0020086239, 0.0020080251, 0.0020065953, 0.0020059962, 0.0020045666, 0.0020039689, 0.0020025389, 0.0020019414, + 0.0020005163, 0.0019999233, 0.0019984951, 0.0019978972, 0.0019964704, 0.0019958769, 0.0019944515, 0.0019938573, + 0.0019923411, 0.0019917537, 0.0019903341, 0.001989749, 0.001988333, 0.0019877465, 0.0019863278, 0.0019857436, + 0.0019843269, 0.0019837432, 0.0019823294, 0.0019817459, 0.0019803299, 0.0019797459, 0.0019783292, 0.0019777471, + 0.0019762437, 0.0019755813, 0.0019740947, 0.0019735382, 0.0019721494, 0.0019715934, 0.001970201, 0.0019696394, + 0.0019682439, 0.0019676804, 0.0019662834, 0.0019657214, 0.0019643251, 0.0019637607, 0.0019623623, 0.0019617963, + 0.0019603977, 0.0019598333, 0.0019584352, 0.001957872, 0.0019563884, 0.0019558354, 0.0019544491, 0.0019538978, + 0.0019525082, 0.0019519519, 0.0019505627, 0.0019500087, 0.0019486204, 0.0019480676, 0.0019466785, 0.0019461266, + 0.0019447408, 0.0019441876, 0.0019427992, 0.0019422461, 0.0019408568, 0.0019403035, 0.0019389174, 0.0019383663, + 0.0019368915, 0.0019362619, 0.0019348059, 0.0019341925, 0.0019327513, 0.00193224, 0.0019308919, 0.0019303763, + 0.0019290226, 0.001928506, 0.0019271496, 0.0019266263, 0.0019252684, 0.0019247438, 0.0019233803, 0.0019228536, + 0.0019214895, 0.0019209601, 0.001919597, 0.0019190721, 0.0019177094, 0.0019171822, 0.0019158188, 0.0019152896, + 0.0019139246, 0.0019133978, 0.0019119466, 0.0019113399, 0.0019099051, 0.0019093158, 0.0019078963, 0.0019074063, + 0.0019060755, 0.0019055798, 0.0019042463, 0.0019037483, 0.0019024104, 0.0019019074, 0.0019005664, 0.0019000609, + 0.001898718, 0.0018982106, 0.0018968666, 0.0018963601, 0.0018950145, 0.001894507, 0.0018931624, 0.001892655, + 0.0018913097, 0.001890804, 0.0018894578, 0.00188895, 0.0018876045, 0.0018870956, 0.0018857479, 0.00188524, + 0.0018838084, 0.0018832238, 0.0018818072, 0.0018812371, 0.0018798362, 0.0018792796, 0.001877891, 0.0018773468, + 0.0018759685, 0.0018755213, 0.0018742302, 0.0018737732, 0.0018724753, 0.001872013, 0.0018707109, 0.0018702456, + 0.001868938, 0.001868468, 0.0018671595, 0.0018666894, 0.0018653779, 0.0018649036, 0.0018635889, 0.0018631138, + 0.0018617997, 0.001861323, 0.001860004, 0.001859523, 0.0018582034, 0.001857723, 0.0018564034, 0.0018559225, + 0.001854601, 0.0018541217, 0.001852804, 0.0018523255, 0.0018510069, 0.0018505267, 0.0018492074, 0.0018487278, + 0.0018474079, 0.0018469281, 0.0018456082, 0.0018451285, 0.0018438102, 0.0018433329, 0.0018419308, 0.0018413776, + 0.00183999, 0.0018394515, 0.0018380809, 0.0018375543, 0.0018361949, 0.0018356818, 0.0018343321, 0.0018338286, + 0.0018324888, 0.0018319942, 0.001830664, 0.001830176, 0.0018288521, 0.0018283746, 0.0018270587, 0.0018265855, + 0.0018252751, 0.0018248073, 0.0018235013, 0.0018230387, 0.0018217375, 0.0018212786, 0.0018199829, 0.0018195321, + 0.0018182379, 0.001817784, 0.0018164939, 0.0018160475, 0.0018147624, 0.0018143174, 0.0018130299, 0.0018125841, + 0.0018112994, 0.0018108595, 0.0018095808, 0.0018091438, 0.0018078657, 0.0018074284, 0.0018061512, 0.0018057158, + 0.0018044399, 0.0018040066, 0.0018027306, 0.0018022994, 0.0018010281, 0.0018005988, 0.0017993287, 0.0017989008, + 0.0017976307, 0.0017972055, 0.0017959375, 0.001795511, 0.0017942437, 0.0017938174, 0.0017925485, 0.0017921239, + 0.0017908593, 0.0017904359, 0.0017891716, 0.0017887499, 0.0017874866, 0.0017870645, 0.0017857992, 0.001785378, + 0.0017841154, 0.0017836947, 0.0017824309, 0.0017820119, 0.0017807503, 0.0017803318, 0.0017790712, 0.0017786529, + 0.0017773921, 0.0017769735, 0.0017757131, 0.001775297, 0.0017740394, 0.001773627, 0.0017723718, 0.0017719578, + 0.001770701, 0.0017702897, 0.0017690348, 0.0017686221, 0.0017673646, 0.0017669508, 0.0017656946, 0.0017652804, + 0.0017640247, 0.0017636138, 0.0017623596, 0.0017619493, 0.0017606955, 0.0017602846, 0.001759032, 0.0017586227, + 0.0017573703, 0.0017569637, 0.0017557137, 0.0017553067, 0.0017540577, 0.0017536518, 0.0017524008, 0.001751996, + 0.0017508327, 0.001750506, 0.0017493288, 0.0017489882, 0.0017477971, 0.0017474437, 0.0017462417, 0.0017458806, + 0.001744671, 0.0017443026, 0.0017430848, 0.0017427078, 0.0017414857, 0.0017411045, 0.0017398758, 0.0017394895, + 0.0017382579, 0.0017378697, 0.0017366356, 0.001736245, 0.001735009, 0.0017346155, 0.0017333739, 0.0017329778, + 0.0017317374, 0.0017312572, 0.001729938, 0.0017294704, 0.0017281659, 0.0017277137, 0.0017264256, 0.0017259871, + 0.0017247071, 0.0017242782, 0.0017230085, 0.0017225854, 0.0017213193, 0.0017209026, 0.0017196462, 0.0017192368, + 0.0017179862, 0.0017175835, 0.0017163403, 0.0017159439, 0.0017147044, 0.0017143117, 0.0017130767, 0.0017126882, + 0.0017114584, 0.0017110762, 0.0017099315, 0.0017096271, 0.0017084746, 0.0017081592, 0.0017069936, 0.0017066707, + 0.0017054969, 0.0017051634, 0.0017039841, 0.001703647, 0.0017024614, 0.0017021187, 0.0017009287, 0.0017005004, + 0.0016992338, 0.0016988177, 0.0016975619, 0.0016971561, 0.0016959084, 0.0016955095, 0.0016942706, 0.001693882, + 0.0016926508, 0.0016922683, 0.0016910435, 0.0016906676, 0.0016894497, 0.0016890798, 0.0016878662, 0.0016874998, + 0.0016862901, 0.001685928, 0.001684806, 0.0016845234, 0.0016833892, 0.0016830944, 0.001681949, 0.0016816456, + 0.0016804945, 0.0016801045, 0.0016788691, 0.0016784833, 0.0016772571, 0.0016768815, 0.0016756649, 0.0016752968, + 0.0016740846, 0.0016737209, 0.0016725153, 0.0016721579, 0.0016709574, 0.001670606, 0.00166941, 0.0016690615, + 0.0016678685, 0.0016675228, 0.0016664164, 0.0016661495, 0.0016650311, 0.0016647526, 0.0016636222, 0.0016633335, + 0.0016621937, 0.0016618164, 0.0016605968, 0.0016602265, 0.0016590154, 0.0016586549, 0.0016574517, 0.0016570966, + 0.0016558969, 0.0016555476, 0.0016543565, 0.0016540128, 0.0016528253, 0.0016524857, 0.001651302, 0.0016509636, + 0.0016497822, 0.001649449, 0.0016483513, 0.0016480946, 0.0016469862, 0.0016467199, 0.0016456029, 0.0016452475, + 0.0016440476, 0.0016436966, 0.0016425024, 0.0016421567, 0.0016409694, 0.0016406315, 0.0016394487, 0.0016391141, + 0.0016379355, 0.0016376044, 0.0016364282, 0.0016361017, 0.0016349321, 0.0016346098, 0.0016335231, 0.0016332755, + 0.0016321765, 0.0016318378, 0.0016306555, 0.0016303218, 0.0016291437, 0.0016288141, 0.0016276404, 0.0016273146, + 0.0016261442, 0.0016258205, 0.0016246543, 0.0016243368, 0.0016231752, 0.0016228631, 0.0016217059, 0.0016213945, + 0.0016203186, 0.0016200835, 0.0016189965, 0.0016186689, 0.0016174967, 0.0016171744, 0.0016160096, 0.001615694, + 0.0016145325, 0.001614219, 0.0016130608, 0.0016127502, 0.0016115946, 0.0016112883, 0.0016101374, 0.0016098325, + 0.0016087634, 0.0016085347, 0.0016074547, 0.0016071366, 0.0016059737, 0.001605659, 0.0016045008, 0.0016041911, + 0.0016030368, 0.0016027307, 0.0016015792, 0.0016012758, 0.0016001287, 0.0015998294, 0.0015986847, 0.0015983881, + 0.0015973272, 0.0015970276, 0.0015958821, 0.0015955839, 0.0015944407, 0.001594145, 0.0015930058, 0.0015927162, + 0.0015915806, 0.0015912908, 0.0015901559, 0.0015898686, 0.0015887363, 0.001588451, 0.0015873988, 0.0015871079, + 0.0015859739, 0.0015856882, 0.0015845554, 0.00158427, 0.0015831413, 0.0015828591, 0.0015817317, 0.001581451, + 0.0015803239, 0.0015800443, 0.0015789197, 0.0015786423, 0.0015775185, 0.0015771637, 0.0015760523, 0.0015757866, + 0.0015746757, 0.0015744102, 0.0015732979, 0.0015730328, 0.0015719222, 0.0015716573, 0.0015705454, 0.0015702803, + 0.0015691689, 0.0015689041, 0.0015678726, 0.0015676015, 0.0015664852, 0.0015662162, 0.0015651031, 0.0015648364, + 0.0015637239, 0.00156346, 0.0015623504, 0.0015620874, 0.001560978, 0.0015607161, 0.0015596086, 0.001559268, + 0.0015581681, 0.001557914, 0.0015568141, 0.0015565616, 0.0015554641, 0.0015552129, 0.0015541142, 0.001553861, + 0.0015527616, 0.0015525094, 0.0015514113, 0.0015510801, 0.001549989, 0.0015497435, 0.001548652, 0.0015484069, + 0.001547315, 0.0015470688, 0.0015459759, 0.001545729, 0.0015446377, 0.0015443923, 0.0015433016, 0.0015429785, + 0.0015418944, 0.0015416566, 0.0015405731, 0.0015403351, 0.0015392505, 0.0015390139, 0.0015379313, 0.0015376928, + 0.0015366079, 0.0015363696, 0.0015352822, 0.0015349629, 0.0015338863, 0.0015336549, 0.0015325772, 0.0015323439, + 0.0015312644, 0.0015310326, 0.0015299544, 0.0015297219, 0.0015286445, 0.0015283327, 0.0015272584, 0.0015270301, + 0.0015259563, 0.0015257285, 0.001524655, 0.0015244266, 0.001523352, 0.0015231229, 0.0015220478, 0.0015218181, + 0.0015207423, 0.0015204352, 0.0015193684, 0.0015191465, 0.001518078, 0.0015178528, 0.001516783, 0.0015165596, + 0.0015154891, 0.0015152626, 0.0015141912, 0.0015138894, 0.0015128271, 0.0015126086, 0.0015115442, 0.0015113263, + 0.0015102618, 0.0015100418, 0.0015089753, 0.0015087546, 0.0015076888, 0.0015073915, 0.0015063335, 0.0015061187, + 0.0015050591, 0.0015048466, 0.0015037876, 0.001503572, 0.0015025117, 0.001502296, 0.0015012337, 0.0015009393, + 0.0014998856, 0.0014996764, 0.0014986232, 0.0014984143, 0.0014973575, 0.0014971468, 0.0014960907, 0.0014958786, + 0.0014948213, 0.0014945329, 0.0014934861, 0.0014932828, 0.0014922324, 0.0014920272, 0.0014909767, 0.001490769, + 0.0014897157, 0.0014895083, 0.0014884572, 0.0014881741, 0.0014871293, 0.0014869284, 0.0014858834, 0.0014856823, + 0.0014846355, 0.0014844323, 0.0014833846, 0.0014831052, 0.0014819881, 0.001481723, 0.0014806968, 0.0014805136, + 0.0014794824, 0.001479294, 0.0014782626, 0.001478073, 0.0014770374, 0.0014767708, 0.0014756664, 0.0014754123, + 0.001474395, 0.0014742188, 0.0014731965, 0.0014730176, 0.0014719947, 0.0014717382, 0.0014706437, 0.0014703989, + 0.0014693916, 0.0014692257, 0.0014682133, 0.0014680413, 0.0014670227, 0.0014668489, 0.0014658304, 0.0014655771, + 0.0014644872, 0.0014642465, 0.0014632428, 0.0014630804, 0.0014620726, 0.0014619068, 0.0014608945, 0.0014606479, + 0.0014595637, 0.0014593275, 0.0014583275, 0.0014581688, 0.0014571646, 0.0014570031, 0.0014559954, 0.0014557526, + 0.0014546731, 0.0014544422, 0.0014534479, 0.0014532952, 0.0014522967, 0.0014521395, 0.0014511357, 0.0014509717, + 0.0014499618, 0.0014497181, 0.0014486375, 0.0014484056, 0.0014474116, 0.0014472591, 0.0014462612, 0.0014461051, + 0.0014451038, 0.001444868, 0.0014437947, 0.0014435687, 0.0014425804, 0.0014424318, 0.0014414376, 0.0014412847, + 0.0014402855, 0.0014400533, 0.0014389842, 0.0014387621, 0.0014377765, 0.0014376307, 0.0014366411, 0.0014364916, + 0.0014354975, 0.0014352689, 0.0014342022, 0.0014339826, 0.0014330004, 0.0014328597, 0.0014318745, 0.0014317281, + 0.0014307371, 0.0014305122, 0.0014294488, 0.0014292323, 0.0014282542, 0.001428116, 0.0014271309, 0.0014269863, + 0.0014259977, 0.0014257751, 0.0014247156, 0.0014245017, 0.0014235257, 0.0014233899, 0.0014224085, 0.0014222658, + 0.0014212797, 0.0014210589, 0.0014200014, 0.0014197925, 0.0014188213, 0.0014186886, 0.0014177118, 0.0014174999, + 0.0014164504, 0.0014162468, 0.0014152055, 0.0014150111, 0.001414053, 0.0014139317, 0.0014129664, 0.0014127651, + 0.0014117274, 0.0014115343, 0.0014105032, 0.001410316, 0.0014093654, 0.0014092524, 0.0014082943, 0.0014081, + 0.0014070703, 0.0014068856, 0.0014059355, 0.0014058227, 0.0014048652, 0.00140467, 0.0014036382, 0.0014034514, + 0.0014024278, 0.0014022486, 0.0014013064, 0.0014012001, 0.001400249, 0.0014000611, 0.0013990364, 0.0013988566, + 0.0013978397, 0.0013976662, 0.0013967294, 0.0013966291, 0.0013956842, 0.0013955008, 0.0013944812, 0.0013943054, + 0.001393366, 0.0013932615, 0.0013923144, 0.0013921312, 0.0013911114, 0.0013909341, 0.0013899179, 0.0013897457, + 0.0013888107, 0.0013887129, 0.001387773, 0.0013875955, 0.0013865799, 0.0013864056, 0.0013854697, 0.0013853692, + 0.0013844254, 0.0013842433, 0.0013832257, 0.0013830522, 0.0013820424, 0.0013818768, 0.001380948, 0.0013808536, + 0.0013799162, 0.00137974, 0.0013787273, 0.0013785576, 0.0013776275, 0.0013775324, 0.0013765923, 0.001376414, + 0.0013754014, 0.0013752326, 0.0013742276, 0.0013740649, 0.0013731393, 0.0013729748, 0.0013719737, 0.0013718142, + 0.0013708181, 0.0013706645, 0.0013697494, 0.0013696678, 0.0013687434, 0.0013685805, 0.0013675812, 0.0013674219, + 0.0013664273, 0.0013662761, 0.001365363, 0.0013652091, 0.0013642191, 0.0013640694, 0.0013630834, 0.0013629381, + 0.0013620306, 0.0013618835, 0.0013609007, 0.0013607573, 0.0013597785, 0.0013596385, 0.0013587365, 0.0013586684, + 0.001357757, 0.0013576047, 0.0013566158, 0.0013564678, 0.0013555578, 0.0013554808, 0.001354563, 0.0013544062, + 0.0013534146, 0.0013532622, 0.0013522755, 0.0013521289, 0.0013512213, 0.0013510737, 0.0013500903, 0.0013499473, + 0.0013489705, 0.001348832, 0.0013479325, 0.0013477913, 0.0013468158, 0.0013466796, 0.001345707, 0.0013455742, + 0.0013446817, 0.0013445449, 0.0013435725, 0.00134344, 0.0013424734, 0.001342346, 0.0013414562, 0.0013413236, + 0.001340357, 0.0013402307, 0.0013392699, 0.0013391448, 0.0013382562, 0.0013381261, 0.0013371632, 0.001337037, + 0.0013360757, 0.0013359537, 0.0013349969, 0.0013348761, 0.0013339948, 0.0013338709, 0.0013329128, 0.0013327912, + 0.0013318351, 0.001331716, 0.0013308348, 0.0013307112, 0.0013297544, 0.0013296346, 0.0013286807, 0.0013285636, + 0.0013276866, 0.0013275684, 0.001326616, 0.0013264986, 0.0013255484, 0.0013254358, 0.0013245618, 0.0013244433, + 0.0013234915, 0.0013233768, 0.0013224286, 0.0013223159, 0.0013214409, 0.0013213223, 0.0013203713, 0.0013202559, + 0.0013193073, 0.0013191944, 0.0013183221, 0.0013182071, 0.0013172592, 0.0013171467, 0.0013162005, 0.0013160172, + 0.001315082, 0.0013149811, 0.0013140462, 0.0013139455, 0.0013130112, 0.0013128398, 0.0013119151, 0.0013118224, + 0.0013108952, 0.0013108021, 0.001309876, 0.0013097115, 0.001308793, 0.0013087073, 0.0013077883, 0.0013077024, + 0.0013067821, 0.0013066232, 0.0013057099, 0.0013056289, 0.0013047153, 0.0013046343, 0.0013037915, 0.0013037018, + 0.0013027786, 0.0013026907, 0.0013017699, 0.0013016814, 0.0013008318, 0.0013007356, 0.0012998082, 0.0012997153, + 0.0012987893, 0.0012986958, 0.0012978435, 0.001297745, 0.0012968151, 0.0012967183, 0.001295791, 0.001295625, + 0.0012947066, 0.001294621, 0.0012937019, 0.0012936146, 0.0012926962, 0.0012925375, 0.0012916262, 0.0012915462, + 0.001290634, 0.0012905527, 0.0012896394, 0.0012894882, 0.0012885841, 0.0012885102, 0.0012876042, 0.0012875283, + 0.0012866941, 0.0012866132, 0.0012857006, 0.0012856195, 0.0012847059, 0.0012845516, 0.0012836454, 0.0012835704, + 0.0012826665, 0.0012825929, 0.0012816855, 0.0012815378, 0.0012806377, 0.001280566, 0.0012796636, 0.0012795923, + 0.0012786905, 0.0012785472, 0.0012776514, 0.0012775864, 0.001276691, 0.0012766252, 0.0012758004, 0.0012757264, + 0.0012748223, 0.001274747, 0.0012738417, 0.0012736957, 0.001272799, 0.0012727325, 0.0012718348, 0.0012717657, + 0.001270868, 0.0012707287, 0.0012698375, 0.0012697739, 0.0012688808, 0.0012688168, 0.0012679934, 0.0012679207, + 0.0012670194, 0.0012669478, 0.0012660465, 0.0012659031, 0.0012650086, 0.0012649432, 0.0012640492, 0.0012639841, + 0.0012630887, 0.0012629513, 0.0012620639, 0.001262004, 0.0012611154, 0.0012609847, 0.0012601027, 0.0012600457, + 0.0012591595, 0.0012591025, 0.0012582159, 0.0012580861, 0.0012572063, 0.0012571524, 0.0012562707, 0.0012562155, + 0.0012553307, 0.001255202, 0.0012543242, 0.001254273, 0.0012533921, 0.0012532668, 0.0012523907, 0.0012523409, + 0.0012514641, 0.0012514127, 0.0012505336, 0.0012504114, 0.0012495386, 0.0012494908, 0.001248615, 0.001248493, + 0.0012476229, 0.0012475781, 0.0012467051, 0.0012466591, 0.0012457856, 0.0012456662, 0.001244797, 0.0012447534, + 0.0012438821, 0.0012437667, 0.0012429019, 0.0012428612, 0.0012419937, 0.0012419512, 0.0012410817, 0.0012409657, + 0.0012401008, 0.0012400598, 0.0012391921, 0.0012390791, 0.0012382166, 0.0012381775, 0.001237313, 0.001237273, + 0.0012364051, 0.0012362925, 0.0012354318, 0.0012353928, 0.0012345274, 0.0012344157, 0.0012335556, 0.0012335201, + 0.0012326596, 0.0012326208, 0.0012317557, 0.0012316445, 0.001230787, 0.0012307523, 0.0012298904, 0.0012297807, + 0.0012289223, 0.0012288885, 0.0012280291, 0.0012279218, 0.0012269962, 0.0012268991, 0.0012260543, 0.0012260305, + 0.001225181, 0.0012250833, 0.0012242384, 0.0012242153, 0.0012233668, 0.0012232692, 0.0012223533, 0.0012222643, + 0.0012214266, 0.0012214113, 0.0012205712, 0.0012204819, 0.0012196419, 0.0012196213, 0.0012187787, 0.0012186879, + 0.0012177788, 0.0012176966, 0.0012168661, 0.0012167847, 0.0012158841, 0.0012158101, 0.0012149882, 0.0012149846, + 0.0012141555, 0.0012140768, 0.0012132496, 0.0012132406, 0.0012124071, 0.0012123227, 0.0012114212, 0.0012113441, + 0.0012105192, 0.0012105138, 0.0012096849, 0.0012096054, 0.0012087775, 0.0012087678, 0.0012079346, 0.0012078506, + 0.0012070206, 0.0012070087, 0.0012061746, 0.0012060902, 0.0012051895, 0.0012051134, 0.001204291, 0.0012042865, + 0.0012034569, 0.0012033754, 0.0012025487, 0.0012025398, 0.0012017074, 0.0012016237, 0.0012007243, 0.0012006487, + 0.0011998283, 0.0011997569, 0.0011988691, 0.0011988051, 0.0011979941, 0.0011979287, 0.0011970474, 0.0011969884, + 0.0011961835, 0.0011961935, 0.0011953801, 0.0011953142, 0.0011945025, 0.0011945061, 0.0011936876, 0.0011936153, + 0.0011927278, 0.0011926633, 0.0011918547, 0.0011917911, 0.001190912, 0.0011908551, 0.0011900525, 0.0011900646, + 0.0011892546, 0.0011891896, 0.0011883802, 0.0011883853, 0.0011875686, 0.0011874983, 0.0011866147, 0.0011865532, + 0.0011857472, 0.0011856859, 0.0011848109, 0.0011847558, 0.0011839552, 0.0011839006, 0.0011830315, 0.0011829818, + 0.001182186, 0.001182134, 0.0011812693, 0.001181224, 0.0011804334, 0.0011804542, 0.001179654, 0.0011795989, + 0.0011787307, 0.0011786821, 0.0011778888, 0.0011778382, 0.0011769753, 0.0011769306, 0.0011761402, 0.0011760929, + 0.001175234, 0.0011751939, 0.0011744081, 0.0011743649, 0.0011735082, 0.0011734682, 0.0011726851, 0.0011727138, + 0.0011719217, 0.001171872, 0.001171078, 0.0011710966, 0.0011702974, 0.0011702402, 0.0011693718, 0.0011693233, + 0.0011685322, 0.0011684818, 0.001167619, 0.0011675742, 0.001166787, 0.0011667414, 0.0011658844, 0.0011658447, + 0.0011650623, 0.0011650217, 0.0011641692, 0.0011641331, 0.001163353, 0.0011633139, 0.0011624647, 0.0011624314, + 0.001161654, 0.0011616175, 0.001160771, 0.0011607396, 0.0011598967, 0.0011598675, 0.0011590958, 0.0011590638, + 0.0011582223, 0.0011581959, 0.0011574257, 0.0011573958, 0.0011565568, 0.0011565303, 0.0011557613, 0.0011557316, + 0.0011548924, 0.001154867, 0.0011540984, 0.0011540689, 0.0011532302, 0.0011532056, 0.0011524392, 0.0011524118, + 0.0011515748, 0.0011515516, 0.0011507873, 0.001150761, 0.0011499244, 0.0011499012, 0.0011491373, 0.0011491125, + 0.0011482787, 0.0011482569, 0.0011474936, 0.0011474674, 0.0011466321, 0.001146609, 0.0011457778, 0.0011456918, + 0.0011448709, 0.0011448605, 0.00114404, 0.0011440313, 0.0011432809, 0.0011432655, 0.0011424427, 0.0011424304, + 0.0011416775, 0.0011416614, 0.001140836, 0.001140822, 0.0011400679, 0.0011400502, 0.0011392258, 0.0011392112, + 0.0011384551, 0.0011384373, 0.0011376113, 0.0011375968, 0.0011368428, 0.0011368243, 0.0011359986, 0.0011359826, + 0.0011352274, 0.0011352079, 0.001134382, 0.0011343674, 0.0011336133, 0.0011335944, 0.0011327706, 0.001132755, + 0.0011319993, 0.0011319808, 0.0011311565, 0.0011311417, 0.001130388, 0.0011303686, 0.0011295443, 0.0011295296, + 0.0011287765, 0.001128758, 0.0011279345, 0.0011279205, 0.0011271687, 0.0011271527, 0.0011263296, 0.0011263136, + 0.0011255614, 0.0011255447, 0.0011247231, 0.0011247096, 0.0011239575, 0.0011239405, 0.0011231203, 0.0011231068, + 0.0011223566, 0.0011223404, 0.0011215204, 0.0011215084, 0.0011207592, 0.0011207438, 0.0011199255, 0.0011199148, + 0.0011191667, 0.0011191517, 0.0011183346, 0.0011183236, 0.001117576, 0.0011175616, 0.0011167458, 0.0011167378, + 0.0011159917, 0.0011159786, 0.0011151633, 0.0011151548, 0.0011144108, 0.0011143994, 0.0011135869, 0.0011135797, + 0.001112835, 0.001112823, 0.0011120102, 0.0011120019, 0.0011112572, 0.0011112449, 0.0011104334, 0.0011104266, + 0.0011096847, 0.0011096745, 0.0011088633, 0.0011088571, 0.0011081164, 0.0011081077, 0.001107299, 0.001107295, + 0.0011065555, 0.001106547, 0.0011057394, 0.0011057362, 0.0011049985, 0.0011049913, 0.0011041848, 0.0011041819, + 0.0011034447, 0.0011034382, 0.0011026326, 0.00110263, 0.0011018937, 0.001101888, 0.0011010822, 0.0011010789, + 0.0011003442, 0.00110034, 0.0010995365, 0.001099469, 0.0010986757, 0.0010986846, 0.0010978935, 0.0010978371, + 0.0010970533, 0.001097071, 0.0010962894, 0.001096242, 0.0010954656, 0.0010954886, 0.0010947138, 0.0010946725, + 0.0010939039, 0.0010939348, 0.0010931641, 0.0010931266, 0.0010923631, 0.0010923976, 0.0010916324, 0.0010916002, + 0.0010908399, 0.0010908763, 0.0010901135, 0.0010900841, 0.001089327, 0.0010893669, 0.0010886067, 0.0010885771, + 0.0010878221, 0.0010878636, 0.0010871051, 0.0010870786, 0.0010863254, 0.0010863679, 0.0010856772, 0.0010857108, + 0.0010849467, 0.0010849141, 0.0010841549, 0.0010841922, 0.0010834333, 0.0010834045, 0.0010826493, 0.0010826899, + 0.0010819327, 0.001081907, 0.0010811557, 0.001081199, 0.0010804444, 0.0010804179, 0.0010796662, 0.0010797103, + 0.0010789564, 0.0010789316, 0.0010781819, 0.001078227, 0.0010774739, 0.0010774499, 0.0010767013, 0.001076748, + 0.0010759978, 0.0010759747, 0.0010752269, 0.0010752078, 0.0010744649, 0.0010745141, 0.0010737658, 0.0010737445, + 0.0010729993, 0.0010730483, 0.0010723016, 0.0010722819, 0.0010715387, 0.0010715879, 0.0010708402, 0.0010708207, + 0.0010700769, 0.0010701248, 0.0010693772, 0.0010693569, 0.0010686124, 0.0010686612, 0.0010679165, 0.001067898, + 0.0010671555, 0.0010672057, 0.0010664612, 0.0010664435, 0.0010657017, 0.001065686, 0.0010649471, 0.0010649987, + 0.0010642553, 0.0010642385, 0.001063499, 0.0010635511, 0.0010628086, 0.0010627911, 0.0010620512, 0.001062101, + 0.0010613576, 0.0010613415, 0.0010606026, 0.0010606538, 0.0010599126, 0.0010598965, 0.0010591591, 0.0010591458, + 0.0010583462, 0.0010583422, 0.001057615, 0.0010576121, 0.001056888, 0.0010569516, 0.0010562208, 0.0010562139, + 0.0010554858, 0.0010555459, 0.001054813, 0.0010548045, 0.0010540748, 0.0010541327, 0.0010533989, 0.001053388, + 0.0010526567, 0.0010526495, 0.0010518569, 0.0010518576, 0.0010511372, 0.0010511386, 0.0010504194, 0.0010504866, + 0.0010497632, 0.0010497625, 0.0010490404, 0.0010491038, 0.0010483766, 0.0010483718, 0.0010476477, 0.0010476448, + 0.0010468573, 0.0010468626, 0.0010461475, 0.0010461539, 0.0010453763, 0.0010453881, 0.0010446801, 0.0010446936, + 0.0010439863, 0.0010440618, 0.0010433465, 0.0010433521, 0.0010426383, 0.0010426444, 0.0010418679, 0.0010418814, + 0.0010411752, 0.0010411879, 0.0010404174, 0.0010404373, 0.0010397374, 0.0010397551, 0.0010390539, 0.0010391354, + 0.0010384275, 0.0010384381, 0.0010377308, 0.0010377421, 0.0010369703, 0.0010369874, 0.0010362869, 0.0010363044, + 0.0010355387, 0.0010355611, 0.0010348649, 0.0010348846, 0.0010341867, 0.0010342703, 0.001033565, 0.0010335775, + 0.0010328729, 0.0010328856, 0.0010321166, 0.0010321356, 0.0010314372, 0.0010314549, 0.0010306922, 0.0010307168, + 0.001030024, 0.0010300465, 0.0010293513, 0.0010294357, 0.0010287326, 0.0010287468, 0.0010280453, 0.0010280601, + 0.0010272952, 0.0010273173, 0.0010266232, 0.0010266445, 0.0010258844, 0.0010259093, 0.0010252181, 0.0010252415, + 0.0010245492, 0.0010245719, 0.0010238151, 0.0010238437, 0.0010231558, 0.0010231823, 0.0010224289, 0.0010224583, + 0.0010217729, 0.0010218011, 0.0010211135, 0.0010212028, 0.0010205079, 0.0010205281, 0.0010198337, 0.0010198534, + 0.0010190965, 0.0010191229, 0.0010184337, 0.0010184568, 0.0010177019, 0.0010177311, 0.0010170467, 0.0010170741, + 0.001016387, 0.001016413, 0.0010156613, 0.001015691, 0.0010150061, 0.0010150343, 0.0010142864, 0.0010143199, + 0.0010136393, 0.0010136703, 0.001012988, 0.0010130171, 0.0010122699, 0.0010123051, 0.0010116277, 0.0010116607, + 0.0010109175, 0.0010109553, 0.0010102789, 0.0010103127, 0.0010096346, 0.0010096664, 0.0010089217, 0.0010089581, + 0.0010082828, 0.0010083171, 0.0010075753, 0.0010076129, 0.0010069387, 0.0010069738, 0.0010062963, 0.0010063295, + 0.001005589, 0.0010056273, 0.0010049533, 0.0010049893, 0.0010042505, 0.0010042897, 0.001003617, 0.0010036535, + 0.0010029797, 0.0010030144, 0.0010022755, 0.0010023148, 0.0010016437, 0.0010016805, 0.0010009444, 0.0010009869, + 0.0010003168, 0.0010003541, 0.00099968235, 0.00099971902, 0.00099898304, 0.00099902332, 0.00099835184, + 0.00099838874, 0.00099765416, 0.000997697, 0.00099702994, 0.00099706941, 0.00099639886, 0.00099643529, + 0.00099570048, 0.00099574181, 0.00099507545, 0.00099511608, 0.00099438452, 0.00099436601, 0.00099364296, + 0.00099369371, 0.00099303667, 0.00099308614, 0.0009923639, 0.00099241547, 0.00099175726, 0.00099180441, + 0.00099108065, 0.00099106797, 0.00099035318, 0.00099041138, 0.00098976074, 0.00098981522, 0.00098909799, + 0.00098915352, 0.00098850182, 0.00098855398, 0.00098783616, 0.00098782848, 0.00098711834, 0.00098718109, + 0.0009865358, 0.00098659378, 0.00098588155, 0.00098587759, 0.00098517188, 0.00098523812, 0.00098459667, + 0.00098465756, 0.00098394882, 0.00098401122, 0.00098336546, 0.00098342204, 0.00098270958, 0.00098270539, + 0.00098200107, 0.00098206778, 0.00098142773, 0.00098148838, 0.00098078034, 0.00098078058, 0.00098008022, + 0.00098014902, 0.00097951142, 0.00097957393, 0.00097886776, 0.00097893109, 0.00097828812, 0.00097834633, + 0.00097763713, 0.0009776348, 0.00097693386, 0.00097700162, 0.0009763639, 0.00097642571, 0.00097572029, + 0.00097572122, 0.00097502302, 0.00097509456, 0.00097446045, 0.00097452442, 0.00097382028, 0.00097388541, + 0.00097324722, 0.0009733077, 0.00097260141, 0.00097260164, 0.00097190344, 0.00097197114, 0.00097133522, + 0.00097139936, 0.0009706975, 0.00097070029, 0.00097000587, 0.00097007689, 0.00096944417, 0.00096951018, + 0.00096881023, 0.00096881442, 0.00096812117, 0.00096819369, 0.0009675016, 0.00096751202, 0.00096682512, + 0.00096690306, 0.00096627814, 0.00096635072, 0.00096565799, 0.00096566771, 0.00096498156, 0.00096505898, + 0.00096443348, 0.00096450438, 0.00096381141, 0.00096382148, 0.0009631362, 0.00096321321, 0.00096258783, + 0.00096265913, 0.00096196751, 0.00096197758, 0.00096129125, 0.00096136745, 0.00096068042, 0.00096069375, + 0.00096001307, 0.00096009596, 0.00095947733, 0.00095955416, 0.00095886772, 0.00095888134, 0.0009582006, + 0.0009582818, 0.00095766212, 0.00095773616, 0.00095704803, 0.00095706113, 0.00095638004, 0.0009564599, + 0.00095583923, 0.00095591269, 0.00095522543, 0.00095523731, 0.00095455523, 0.00095463434, 0.00095395226, + 0.00095396902, 0.00095329271, 0.00095331494, 0.00095264264, 0.00095273025, 0.00095205748, 0.00095208274, + 0.00095141458, 0.00095144327, 0.00095077924, 0.00095087319, 0.00095020625, 0.00095023646, 0.0009495726, + 0.00094960612, 0.00094894605, 0.00094904302, 0.00094838021, 0.00094841339, 0.00094775419, 0.00094785192, + 0.00094725098, 0.00094734173, 0.00094667211, 0.00094669801, 0.00094603206, 0.00094612385, 0.00094551843, + 0.00094560254, 0.00094492815, 0.00094494992, 0.00094428036, 0.00094436813, 0.00094375876, 0.00094383874, + 0.00094316166, 0.00094318192, 0.00094251207, 0.0009425981, 0.00094192591, 0.00094194867, 0.00094128191, + 0.00094131031, 0.00094064814, 0.0009407418, 0.0009400784, 0.00094010867, 0.0009394486, 0.00093948195, 0.0009388249, + 0.00093892321, 0.00093826401, 0.00093829789, 0.00093764311, 0.00093768165, 0.00093703065, 0.00093713257, + 0.00093647675, 0.00093651301, 0.00093585905, 0.0009358977, 0.00093524822, 0.00093535165, 0.00093469897, + 0.00093473779, 0.00093408837, 0.00093412993, 0.00093348231, 0.00093358755, 0.00093293661, 0.00093297678, + 0.00093232875, 0.00093237084, 0.00093172578, 0.00093183218, 0.00093118323, 0.0009312249, 0.00093057851, + 0.00093062205, 0.00092997792, 0.0009300856, 0.00092943839, 0.00092948065, 0.00092883618, 0.00092888152, + 0.00092823833, 0.00092834502, 0.00092769816, 0.00092774024, 0.00092709617, 0.00092714111, 0.00092649861, + 0.00092660578, 0.00092595984, 0.00092600216, 0.00092535745, 0.00092540233, 0.00092476193, 0.00092486979, + 0.00092422438, 0.0009242674, 0.00092362537, 0.00092367106, 0.00092303107, 0.0009230788, 0.0009223813, + 0.00092243607, 0.00092180428, 0.00092185958, 0.00092122989, 0.00092128618, 0.00092059455, 0.0009206548, + 0.00092003087, 0.00092009263, 0.00091946812, 0.00091952889, 0.00091890554, 0.00091902725, 0.00091839675, + 0.00091845274, 0.00091782468, 0.00091788132, 0.00091725279, 0.00091736927, 0.00091673533, 0.00091678667, + 0.00091615535, 0.00091620878, 0.00091557798, 0.00091569242, 0.00091505673, 0.00091510656, 0.00091447379, + 0.00091452606, 0.00091389549, 0.00091400882, 0.00091337349, 0.00091342232, 0.00091278867, 0.00091283926, + 0.00091220747, 0.00091225991, 0.0009115694, 0.00091162854, 0.00091100484, 0.00091106357, 0.00091044005, + 0.00091049983, 0.00090981642, 0.00090988126, 0.00090926443, 0.00090932893, 0.00090871152, 0.00090877607, + 0.00090809789, 0.00090816728, 0.00090755534, 0.00090762309, 0.00090700999, 0.00090707821, 0.00090646447, + 0.00090658985, 0.00090596813, 0.00090602855, 0.00090540882, 0.00090546976, 0.00090484996, 0.00090491161, + 0.00090423331, 0.00090429996, 0.00090368564, 0.00090375193, 0.00090313808, 0.00090320356, 0.00090252917, + 0.00090260059, 0.00090199057, 0.00090205873, 0.0009014486, 0.00090151752, 0.00090084603, 0.00090091943, + 0.00090031215, 0.00090038322, 0.00089977577, 0.00089984731, 0.00089923962, 0.00089930842, 0.00089863868, + 0.0008987133, 0.00089810923, 0.00089818222, 0.00089757633, 0.00089764787, 0.00089698198, 0.0008970591, + 0.00089645659, 0.00089653028, 0.00089592626, 0.00089599885, 0.00089533272, 0.00089540886, 0.00089480792, + 0.00089488301, 0.00089428108, 0.00089435553, 0.00089375244, 0.00089382532, 0.00089316088, 0.00089323887, + 0.00089263846, 0.00089271215, 0.00089210953, 0.00089218304, 0.00089152087, 0.00089159864, 0.00089099928, + 0.00089107524, 0.00089047517, 0.00089055055, 0.00088988879, 0.00088990742, 0.00088925642, 0.00088934478, + 0.00088875694, 0.00088884158, 0.0008882499, 0.00088833185, 0.00088767736, 0.00088776089, 0.0008871691, + 0.00088725128, 0.00088665809, 0.00088673737, 0.00088608224, 0.00088610576, 0.00088545989, 0.00088555133, + 0.00088496698, 0.00088505476, 0.00088446727, 0.00088455179, 0.00088390254, 0.00088398927, 0.00088340149, + 0.00088348583, 0.00088289543, 0.00088297646, 0.00088232523, 0.00088235043, 0.00088170724, 0.00088180078, + 0.00088121992, 0.00088130916, 0.00088072411, 0.00088080933, 0.00088016188, 0.00088025024, 0.00087966718, + 0.00087975367, 0.00087916682, 0.00087925035, 0.00087860163, 0.00087862898, 0.00087798864, 0.00087808236, + 0.00087750371, 0.00087759353, 0.00087701093, 0.00087709754, 0.00087645301, 0.00087654276, 0.00087595999, + 0.00087604433, 0.00087545672, 0.00087553897, 0.00087489135, 0.00087491737, 0.0008742786, 0.00087437336, + 0.00087379612, 0.00087388628, 0.00087330537, 0.00087339192, 0.00087274954, 0.00087278057, 0.00087214721, + 0.00087224552, 0.00087167311, 0.00087176688, 0.0008711901, 0.00087128003, 0.00087064086, 0.00087073317, + 0.00087015517, 0.00087024429, 0.00086966436, 0.00086975005, 0.00086910813, 0.00086913886, 0.00086850574, + 0.00086860266, 0.00086802954, 0.00086812064, 0.00086754316, 0.00086763193, 0.0008669931, 0.0008670261, + 0.00086639682, 0.00086649606, 0.00086592702, 0.00086602243, 0.0008653893, 0.00086542702, 0.00086480245, + 0.00086484716, 0.00086422969, 0.00086433912, 0.00086377887, 0.00086388161, 0.00086325826, 0.00086330355, + 0.00086268655, 0.00086279574, 0.00086223712, 0.00086234137, 0.00086177798, 0.00086187583, 0.00086124789, + 0.00086128834, 0.00086066796, 0.00086077501, 0.00086021505, 0.00086031621, 0.00085975131, 0.00085984799, + 0.00085921888, 0.00085925887, 0.00085863913, 0.00085874472, 0.00085818465, 0.00085828517, 0.00085766113, + 0.00085770409, 0.00085708703, 0.00085713709, 0.00085652707, 0.00085663982, 0.00085608603, 0.00085619243, + 0.00085557555, 0.00085562404, 0.00085501309, 0.0008550671, 0.00085446122, 0.00085457851, 0.0008540306, + 0.00085414131, 0.00085352868, 0.00085358089, 0.00085297326, 0.00085302943, 0.00085242698, 0.00085254561, + 0.00085199979, 0.00085211202, 0.0008515013, 0.00085155445, 0.00085095013, 0.00085100904, 0.00085040892, + 0.00085052964, 0.00084998627, 0.00085009966, 0.00084949174, 0.00084954657, 0.00084894372, 0.00084900256, + 0.00084840361, 0.00084852555, 0.00084798492, 0.00084809971, 0.00084749336, 0.00084754889, 0.00084694731, + 0.00084700738, 0.00084641075, 0.0008465331, 0.00084599265, 0.00084610732, 0.00084550126, 0.00084555737, + 0.00084495678, 0.00084501633, 0.00084442052, 0.00084454176, 0.00084400194, 0.0008441172, 0.00084351341, + 0.0008435701, 0.0008429712, 0.00084303069, 0.00084243459, 0.00084255723, 0.00084201933, 0.00084213499, + 0.00084153254, 0.00084158906, 0.0008409911, 0.00084105204, 0.00084045727, 0.00084057945, 0.00084004155, + 0.00084015634, 0.00083955453, 0.00083961076, 0.00083901308, 0.00083907373, 0.00083847961, 0.00083860179, + 0.00083806488, 0.00083817984, 0.00083757879, 0.00083763595, 0.00083704042, 0.00083710306, 0.00083651155, + 0.00083663472, 0.00083610002, 0.00083621615, 0.0008356162, 0.00083567284, 0.00083507714, 0.00083513814, + 0.00083454786, 0.00083461392, 0.00083402731, 0.00083415327, 0.00083356368, 0.00083362969, 0.00083304371, + 0.00083311327, 0.00083253166, 0.00083260477, 0.00083202583, 0.00083215983, 0.00083157874, 0.00083165074, + 0.00083107158, 0.00083114568, 0.00083056797, 0.00083064474, 0.00083006953, 0.00083020492, 0.00082968397, + 0.00082981132, 0.000829225, 0.00082929234, 0.00082870823, 0.00082877727, 0.0008281974, 0.00082827051, + 0.00082769361, 0.00082782609, 0.00082724611, 0.00082731951, 0.0008267425, 0.00082681747, 0.00082624221, + 0.00082631869, 0.00082574616, 0.00082588266, 0.0008253064, 0.00082538108, 0.0008248071, 0.00082488509, + 0.00082431332, 0.00082439184, 0.00082382193, 0.0008239033, 0.00082333578, 0.00082347519, 0.00082290272, + 0.00082298019, 0.00082240929, 0.00082248921, 0.00082192116, 0.00082200265, 0.00082143571, 0.00082157546, + 0.00082100439, 0.00082108256, 0.00082051399, 0.00082059461, 0.00082002761, 0.0008201095, 0.00081954326, + 0.00081962545, 0.00081900402, 0.00081909361, 0.00081853522, 0.00081862463, 0.00081806653, 0.00081815571, + 0.0008175979, 0.00081768708, 0.00081712956, 0.00081727636, 0.00081671326, 0.00081679778, 0.00081623637, + 0.00081632135, 0.00081576052, 0.00081584626, 0.00081528624, 0.00081537344, 0.00081475789, 0.00081485062, + 0.00081429764, 0.00081438979, 0.00081383518, 0.00081392558, 0.00081337121, 0.00081346271, 0.00081290957, + 0.00081305741, 0.00081249711, 0.0008125829, 0.00081202481, 0.00081211218, 0.00081155513, 0.00081164273, + 0.00081108604, 0.00081117387, 0.00081061706, 0.000810761, 0.00081019953, 0.00081028324, 0.00080972287, + 0.00080980727, 0.00080924825, 0.00080933282, 0.00080877496, 0.00080886169, 0.00080824806, 0.00080834009, + 0.00080778945, 0.00080788112, 0.00080732978, 0.00080742146, 0.00080687046, 0.00080696208, 0.00080641214, + 0.00080650428, 0.000805897, 0.00080599432, 0.00080544921, 0.00080554531, 0.00080499833, 0.00080509263, + 0.00080454559, 0.00080463989, 0.00080409215, 0.00080418575, 0.00080358266, 0.00080368278, 0.00080314022, + 0.00080323714, 0.00080269255, 0.0008027883, 0.00080224307, 0.00080233859, 0.000801794, 0.00080194534, + 0.00080139353, 0.0008014823, 0.00080093229, 0.00080102246, 0.00080047268, 0.00080056273, 0.00080001313, + 0.00080010353, 0.00079949881, 0.0007995952, 0.00079905131, 0.00079914631, 0.00079860236, 0.00079869706, + 0.00079815183, 0.00079824508, 0.00079770078, 0.0007977949, 0.00079719373, 0.00079729263, 0.00079675281, + 0.00079685025, 0.00079630897, 0.00079640531, 0.00079586398, 0.00079595979, 0.00079541799, 0.00079551362, + 0.00079491525, 0.00079496001, 0.00079437252, 0.00079448288, 0.00079395482, 0.00079406198, 0.0007935313, + 0.00079363625, 0.00079310418, 0.00079320709, 0.00079261669, 0.0007926664, 0.0007920838, 0.00079219858, + 0.0007916764, 0.00079178816, 0.00079126237, 0.00079137058, 0.00079084293, 0.00079094997, 0.00079036423, + 0.00079041766, 0.0007898396, 0.00078995689, 0.00078943721, 0.00078954967, 0.00078902632, 0.00078913663, + 0.00078861183, 0.00078872021, 0.00078819256, 0.00078829797, 0.00078771217, 0.00078782177, 0.00078729639, + 0.00078740396, 0.00078687572, 0.00078698044, 0.00078645069, 0.00078655308, 0.00078602182, 0.00078612333, + 0.00078553549, 0.00078558532, 0.00078500569, 0.00078511989, 0.0007845998, 0.00078471086, 0.00078418804, + 0.00078429567, 0.00078376994, 0.00078387529, 0.00078329217, 0.00078334595, 0.00078277127, 0.00078288768, + 0.00078237162, 0.00078248646, 0.00078196789, 0.00078207842, 0.00078155636, 0.00078166433, 0.00078108424, + 0.00078113918, 0.00078056788, 0.00078063179, 0.00078006822, 0.00078019325, 0.00077968533, 0.00077980582, + 0.00077929482, 0.00077941141, 0.0007788958, 0.00077900832, 0.00077843387, 0.00077849365, 0.00077792734, + 0.00077804975, 0.0007775409, 0.0007776593, 0.00077714643, 0.00077726063, 0.00077674363, 0.00077685463, + 0.00077628065, 0.0007763399, 0.00077577325, 0.00077583792, 0.0007752782, 0.00077540579, 0.00077490212, + 0.00077502412, 0.00077451603, 0.00077463337, 0.00077412149, 0.00077423546, 0.00077366456, 0.00077372452, + 0.00077316153, 0.00077322929, 0.00077267253, 0.00077280257, 0.0007723039, 0.00077242858, 0.00077192421, + 0.00077204406, 0.00077147904, 0.0007715447, 0.0007709869, 0.00077105773, 0.00077050546, 0.00077063718, + 0.00077014056, 0.00077026733, 0.00076976628, 0.00076988863, 0.00076938263, 0.00076949963, 0.00076893409, + 0.00076899829, 0.00076844066, 0.00076851132, 0.00076796021, 0.00076809159, 0.00076759432, 0.00076771912, + 0.00076721772, 0.0007673385, 0.00076683331, 0.00076695113, 0.00076638733, 0.00076645083, 0.00076589361, + 0.00076596311, 0.00076541182, 0.00076554302, 0.00076504814, 0.00076517405, 0.00076467387, 0.00076479436, + 0.00076428999, 0.00076440664, 0.00076384336, 0.00076390803, 0.00076335296, 0.00076342252, 0.00076287339, + 0.00076300523, 0.00076251093, 0.00076263602, 0.00076213665, 0.00076225656, 0.00076175318, 0.00076187012, + 0.00076130836, 0.00076137192, 0.00076081714, 0.00076088728, 0.0007603392, 0.0007604147, 0.00075987238, + 0.00076000817, 0.00075951946, 0.00075964897, 0.00075915514, 0.00075928, 0.00075872708, 0.00075879687, + 0.00075824861, 0.00075832388, 0.00075778295, 0.00075786456, 0.00075732812, 0.00075746753, 0.00075698388, + 0.00075711712, 0.00075662736, 0.00075675372, 0.00075620378, 0.00075627683, 0.00075573358, 0.00075581128, + 0.00075527362, 0.00075535633, 0.00075482135, 0.00075496186, 0.00075448159, 0.00075461628, 0.00075412972, + 0.00075425842, 0.00075371179, 0.00075378653, 0.00075324601, 0.00075332512, 0.00075278885, 0.00075287226, + 0.00075234001, 0.00075242663, 0.00075189804, 0.0007520431, 0.00075156713, 0.00075170479, 0.00075122277, + 0.0007513538, 0.00075081113, 0.00075088791, 0.00075035024, 0.00075043138, 0.00074989826, 0.00074998371, + 0.00074945536, 0.00074954447, 0.00074901956, 0.00074916624, 0.00074869412, 0.00074883341, 0.00074829871, + 0.00074838183, 0.00074785209, 0.00074793841, 0.00074741134, 0.00074750109, 0.00074697798, 0.00074707082, + 0.00074655062, 0.00074669992, 0.00074623106, 0.00074637268, 0.00074589637, 0.00074603129, 0.00074549433, + 0.00074557378, 0.00074504188, 0.00074512587, 0.00074459863, 0.00074468605, 0.00074416114, 0.00074425101, + 0.00074372889, 0.00074387656, 0.00074340851, 0.00074354972, 0.00074307481, 0.00074320874, 0.00074267189, + 0.00074275129, 0.00074222113, 0.00074230484, 0.00074177753, 0.00074186525, 0.00074134319, 0.00074143364, + 0.00074091356, 0.00074100628, 0.00074048876, 0.00074063789, 0.00074017199, 0.00074031379, 0.00073978631, + 0.00073987234, 0.00073934917, 0.00073943852, 0.00073891913, 0.00073901197, 0.00073849427, 0.00073858805, + 0.00073807425, 0.00073817198, 0.00073765981, 0.0007378122, 0.00073735096, 0.00073749572, 0.00073697191, + 0.00073705887, 0.00073653867, 0.00073663011, 0.00073611335, 0.00073620724, 0.00073569396, 0.00073579035, + 0.00073527871, 0.00073537667, 0.00073486584, 0.00073501893, 0.00073456037, 0.00073470594, 0.00073418481, + 0.00073427352, 0.00073375518, 0.00073384668, 0.0007333312, 0.00073342485, 0.0007329128, 0.00073300942, + 0.00073250016, 0.000732599, 0.00073209201, 0.00073219271, 0.00073168636, 0.00073184137, 0.0007313317, + 0.00073142943, 0.00073092111, 0.00073102023, 0.00073051371, 0.00073061517, 0.00073011138, 0.00073021348, + 0.0007297094, 0.00072981208, 0.00072930998, 0.00072941306, 0.00072891172, 0.00072901661, 0.00072851661, + 0.00072867592, 0.00072817114, 0.0007282733, 0.00072777132, 0.00072787405, 0.00072737201, 0.0007274751, + 0.00072697463, 0.00072707934, 0.0007265798, 0.00072668394, 0.00072618516, 0.00072629133, 0.00072579359, + 0.00072589924, 0.0007254011, 0.00072556123, 0.00072505919, 0.00072516111, 0.00072466023, 0.00072476332, + 0.00072426384, 0.00072436786, 0.00072386919, 0.00072397396, 0.00072347629, 0.00072358176, 0.00072308525, + 0.00072319142, 0.00072269584, 0.00072280219, 0.00072230567, 0.00072246592, 0.00072196615, 0.00072206883, + 0.0007215704, 0.00072167366, 0.00072117528, 0.00072127942, 0.00072078267, 0.00072088721, 0.0007203914, + 0.00072049786, 0.00072000275, 0.00072010845, 0.0007196138, 0.0007197205, 0.0007192269, 0.00071938755, + 0.00071888918, 0.00071899133, 0.00071849459, 0.00071859831, 0.00071810209, 0.00071820559, 0.00071771111, + 0.0007178167, 0.00071732252, 0.00071742869, 0.00071693648, 0.00071704359, 0.0007165515, 0.00071665843, + 0.00071616593, 0.00071627251, 0.00071572774, 0.00071583979, 0.00071535277, 0.00071546464, 0.00071497797, + 0.00071508897, 0.00071460311, 0.00071471563, 0.00071423012, 0.0007143424, 0.00071385619, 0.00071396679, + 0.00071347982, 0.00071359007, 0.00071310223, 0.00071321195, 0.00071272516, 0.00071283593, 0.00071229599, + 0.00071241031, 0.00071192818, 0.00071204209, 0.00071155984, 0.00071167393, 0.00071119104, 0.0007113039, + 0.00071081979, 0.00071093137, 0.00071044732, 0.0007105585, 0.00071007409, 0.00071018579, 0.0007097022, + 0.00070981384, 0.00070933026, 0.00070944248, 0.00070890551, 0.00070896861, 0.00070844119, 0.00070856564, + 0.00070809497, 0.00070821692, 0.00070774363, 0.000707864, 0.00070738915, 0.00070750777, 0.00070703169, + 0.00070714857, 0.00070667057, 0.00070678658, 0.00070630881, 0.00070642441, 0.00070594531, 0.00070605922, + 0.00070552755, 0.00070559344, 0.00070506998, 0.00070519693, 0.00070472964, 0.00070485327, 0.00070438365, + 0.00070450589, 0.00070403487, 0.0007041553, 0.00070368242, 0.00070380123, 0.00070332712, 0.00070344412, + 0.00070296886, 0.00070308492, 0.00070260966, 0.00070272532, 0.00070219557, 0.00070226233, 0.00070174196, + 0.00070181658, 0.00070130406, 0.00070143846, 0.00070098031, 0.00070111168, 0.00070065074, 0.00070077833, + 0.00070031453, 0.00070043892, 0.00069997256, 0.00070009608, 0.00069962739, 0.00069974788, 0.00069927773, + 0.00069939572, 0.00069892401, 0.00069904159, 0.00069851673, 0.00069858611, 0.00069807022, 0.00069814734, + 0.00069763866, 0.00069772179, 0.00069721963, 0.0006973616, 0.00069691229, 0.0006970485, 0.00069659459, + 0.00069672702, 0.00069626956, 0.00069639896, 0.00069593894, 0.00069606473, 0.00069560111, 0.00069572462, + 0.00069526047, 0.00069538318, 0.00069491705, 0.00069503696, 0.00069451664, 0.00069458788, 0.00069407589, + 0.00069415401, 0.00069364923, 0.00069373421, 0.00069323584, 0.00069337885, 0.00069293182, 0.00069306907, + 0.00069261825, 0.00069275155, 0.00069229677, 0.0006924257, 0.0006919672, 0.00069209305, 0.00069163163, + 0.00069175544, 0.00069129333, 0.00069141522, 0.00069089851, 0.00069097173, 0.00069046358, 0.0006905435, + 0.00069004227, 0.00069012895, 0.00068963354, 0.00068972417, 0.00068923261, 0.00068932778, 0.00068884139, + 0.00068899331, 0.00068855769, 0.00068870228, 0.00068826013, 0.0006883993, 0.0006879525, 0.00068808714, + 0.00068763667, 0.00068776822, 0.0006873146, 0.0006874415, 0.00068698445, 0.00068710954, 0.00068659795, + 0.00068667327, 0.00068616949, 0.00068625185, 0.00068575598, 0.00068584475, 0.00068535336, 0.00068544637, + 0.00068495941, 0.00068505609, 0.00068457308, 0.00068472506, 0.00068429246, 0.00068443827, 0.00068400044, + 0.00068414165, 0.00068369874, 0.00068383472, 0.00068338768, 0.00068351952, 0.00068306865, 0.00068319717, + 0.0006827435, 0.00068286958, 0.00068236102, 0.00068243605, 0.00068193494, 0.00068201777, 0.00068152306, + 0.00068161107, 0.00068112282, 0.00068121636, 0.00068073242, 0.00068082992, 0.00068034895, 0.0006804486, + 0.00067997177, 0.00068012683, 0.00067969842, 0.00067984615, 0.00067941286, 0.00067955529, 0.00067911623, + 0.00067925313, 0.00067880977, 0.00067894312, 0.00067849644, 0.00067862624, 0.00067817606, 0.00067830266, + 0.00067779771, 0.00067787326, 0.00067737524, 0.00067745883, 0.00067696779, 0.00067705591, 0.00067656935, + 0.00067666289, 0.00067618233, 0.00067628053, 0.00067580363, 0.00067590491, 0.00067543099, 0.0006755346, + 0.00067506335, 0.00067522179, 0.00067479943, 0.0006749499, 0.00067452184, 0.00067466561, 0.00067423051, + 0.00067436945, 0.00067393063, 0.00067406468, 0.00067362038, 0.00067375053, 0.00067325245, 0.00067333353, + 0.00067284232, 0.00067292905, 0.00067244383, 0.00067253457, 0.00067205296, 0.00067214848, 0.00067167182, + 0.00067177159, 0.00067129912, 0.00067140191, 0.00067093212, 0.00067103747, 0.00067057088, 0.00067067891, + 0.00067021401, 0.0006703228, 0.00066985935, 0.00067002152, 0.00066960626, 0.00066975964, 0.0006693374, + 0.00066948507, 0.00066905707, 0.0006691991, 0.0006687658, 0.00066890253, 0.00066846394, 0.00066859607, + 0.00066810299, 0.000668186, 0.00066770084, 0.00066779018, 0.00066730921, 0.00066740229, 0.00066692615, + 0.00066702336, 0.00066655094, 0.00066665141, 0.00066618202, 0.00066628528, 0.00066581921, 0.00066592469, + 0.00066546013, 0.00066556799, 0.00066510652, 0.00066521624, 0.00066475652, 0.00066486734, 0.00066440896, + 0.00066452118, 0.00066406495, 0.00066423102, 0.00066382234, 0.00066397834, 0.00066356105, 0.00066370988, + 0.00066328584, 0.00066342868, 0.00066299998, 0.00066313887, 0.00066265499, 0.00066274212, 0.00066226214, + 0.00066235434, 0.00066188053, 0.00066197675, 0.00066150673, 0.00066160655, 0.00066114002, 0.00066124287, + 0.00066077855, 0.0006608839, 0.00066042313, 0.00066053093, 0.00066007202, 0.00066018122, 0.00065972406, + 0.00065983523, 0.00065937993, 0.00065949245, 0.00065903779, 0.00065915007, 0.0006586971, 0.00065881124, + 0.00065835915, 0.00065847434, 0.00065802369, 0.00065813906, 0.00065768854, 0.00065785588, 0.00065745274, + 0.00065761106, 0.00065719901, 0.00065735029, 0.00065693306, 0.000657078, 0.00065660308, 0.00065669534, + 0.00065622473, 0.00065632194, 0.00065585511, 0.00065595511, 0.00065549224, 0.00065559562, 0.00065513508, + 0.00065523997, 0.00065478188, 0.00065488921, 0.00065443368, 0.00065454323, 0.00065409002, 0.00065420149, + 0.00065374974, 0.00065386289, 0.00065341202, 0.00065352512, 0.00065307593, 0.00065318978, 0.00065274106, + 0.00065285602, 0.00065240869, 0.00065252511, 0.00065207866, 0.00065219519, 0.00065174932, 0.00065186567, + 0.00065141922, 0.00065153558, 0.00065109134, 0.00065120903, 0.00065076438, 0.0006508822, 0.00065043848, + 0.00065055647, 0.00065011281, 0.00065028237, 0.00064983492, 0.00064994831, 0.00064950134, 0.00064961653, + 0.00064917054, 0.00064928614, 0.00064884027, 0.00064895529, 0.00064851006, 0.00064862613, 0.00064818299, + 0.0006483008, 0.00064785819, 0.00064797542, 0.00064753252, 0.00064765068, 0.00064720924, 0.00064732687, + 0.00064688484, 0.00064700254, 0.00064656086, 0.00064667873, 0.00064623752, 0.00064635574, 0.00064591464, + 0.00064603263, 0.00064559124, 0.00064570917, 0.00064526888, 0.00064538722, 0.00064494694, 0.00064506469, + 0.00064462447, 0.00064474315, 0.00064430316, 0.00064442051, 0.00064398069, 0.00064409932, 0.00064365967, + 0.00064377743, 0.00064333819, 0.00064345647, 0.0006430177, 0.00064313615, 0.00064269744, 0.00064281537, + 0.0006423759, 0.00064249372, 0.00064205466, 0.00064217253, 0.00064168399, 0.00064175687, 0.00064127735, + 0.00064135826, 0.00064088777, 0.000641027, 0.00064060831, 0.00064074423, 0.0006403228, 0.00064045581, + 0.00064003258, 0.00064016349, 0.00063973828, 0.00063986733, 0.00063943974, 0.00063956704, 0.0006391388, + 0.00063926453, 0.00063883484, 0.00063895923, 0.00063852902, 0.00063865248, 0.00063822069, 0.00063834339, + 0.00063791196, 0.00063803454, 0.00063760212, 0.00063772296, 0.00063728995, 0.00063741038, 0.00063697656, + 0.00063709664, 0.00063666352, 0.00063678384, 0.00063635071, 0.00063647085, 0.00063603767, 0.00063615746, + 0.00063572457, 0.00063584442, 0.00063541078, 0.0006355294, 0.00063509541, 0.00063521357, 0.00063477951, + 0.00063489872, 0.00063446647, 0.00063458516, 0.00063415122, 0.00063426938, 0.00063383544, 0.00063395337, + 0.00063352019, 0.00063363835, 0.00063320517, 0.00063332327, 0.0006328898, 0.00063300732, 0.00063257484, + 0.000632693, 0.00063226093, 0.00063237938, 0.00063194666, 0.00063206401, 0.00063163054, 0.00063174794, + 0.00063131581, 0.0006314338, 0.00063095166, 0.00063102419, 0.00063055078, 0.0006306314, 0.00063016661, + 0.00063025433, 0.0006297963, 0.00062989013, 0.00062943716, 0.00062953512, 0.00062908727, 0.00062919024, + 0.00062874681, 0.00062885368, 0.00062841387, 0.00062852341, 0.0006280868, 0.00062819978, 0.00062776572, + 0.00062787998, 0.00062744814, 0.00062756479, 0.00062713539, 0.00062725425, 0.00062682701, 0.00062694715, + 0.0006265206, 0.00062664179, 0.00062621647, 0.00062638818, 0.00062600913, 0.00062617264, 0.00062578631, + 0.00062594371, 0.00062555121, 0.00062570255, 0.00062530424, 0.0006254504, 0.00062504836, 0.00062518974, + 0.0006247831, 0.00062492077, 0.00062451087, 0.00062464544, 0.00062423293, 0.00062436512, 0.00062395009, + 0.00062407996, 0.00062366325, 0.0006237909, 0.00062337314, 0.00062349951, 0.00062308006, 0.00062320469, + 0.00062278367, 0.00062290742, 0.0006224853, 0.00062260707, 0.00062218419, 0.00062230573, 0.00062188262, + 0.00062200334, 0.00062157959, 0.00062169961, 0.00062127452, 0.00062139292, 0.00062096823, 0.00062108709, + 0.00062066165, 0.00062077981, 0.00062035478, 0.00062047259, 0.00062004715, 0.00062016438, 0.00061973848, + 0.00061985548, 0.00061942986, 0.00061954651, 0.00061911996, 0.00061923667, 0.00061881088, 0.00061892672, + 0.00061850034, 0.00061861624, 0.00061818957, 0.00061830517, 0.00061787933, 0.00061799504, 0.00061756914, + 0.00061768526, 0.00061725976, 0.00061737542, 0.00061694987, 0.00061706582, 0.00061664096, 0.00061675679, + 0.00061633176, 0.00061644759, 0.00061602297, 0.00061613967, 0.00061571569, 0.00061583106, 0.00061540643, + 0.00061552267, 0.00061509851, 0.00061521475, 0.00061479182, 0.000614908, 0.00061448466, 0.00061460084, + 0.00061417819, 0.00061429478, 0.00061387196, 0.00061398902, 0.00061356719, 0.00061368436, 0.00061326294, + 0.00061337976, 0.00061295781, 0.00061307516, 0.00061265385, 0.00061277114, 0.0006123507, 0.00061246834, + 0.00061204814, 0.00061216537, 0.00061174488, 0.00061186316, 0.00061144371, 0.00061156094, 0.00061114109, + 0.00061125885, 0.00061083888, 0.00061095675, 0.00061053789, 0.00061065535, 0.00061023672, 0.00061035505, + 0.00060993683, 0.00061005546, 0.00060963741, 0.00060975587, 0.00060933823, 0.00060945773, 0.00060903985, + 0.0006091579, 0.00060874055, 0.00060885935, 0.00060844264, 0.00060856098, 0.00060814456, 0.00060826342, + 0.00060784695, 0.00060796633, 0.00060755067, 0.00060766935, 0.00060725276, 0.00060737174, 0.00060695654, + 0.00060707622, 0.00060666137, 0.00060678076, 0.00060636655, 0.00060648675, 0.00060607214, 0.00060619193, + 0.00060577795, 0.00060589751, 0.00060548331, 0.00060560351, 0.00060519011, 0.00060531037, 0.00060489774, + 0.00060501811, 0.00060460484, 0.00060472457, 0.00060431182, 0.0006044319, 0.00060401921, 0.00060413952, + 0.00060372695, 0.00060384726, 0.00060343486, 0.00060355436, 0.00060314202, 0.0006032621, 0.0006028504, + 0.00060292211, 0.00060246623, 0.00060254568, 0.00060209807, 0.00060218625, 0.00060174766, 0.00060184288, + 0.00060140883, 0.00060150825, 0.00060107943, 0.00060118356, 0.00060075946, 0.00060086738, 0.00060044666, + 0.00060055783, 0.00060014083, 0.00060025556, 0.00059984124, 0.0005999573, 0.00059954537, 0.00059966481, + 0.00059925509, 0.00059937511, 0.00059896696, 0.00059908832, 0.00059868145, 0.0005988045, 0.00059839943, + 0.00059852347, 0.00059811905, 0.00059824379, 0.00059784076, 0.00059796666, 0.00059756439, 0.00059769023, + 0.00059728837, 0.00059741532, 0.00059701491, 0.00059714215, 0.00059674116, 0.00059686857, 0.00059646892, + 0.00059659657, 0.00059619651, 0.00059632369, 0.00059592386, 0.00059605157, 0.00059565186, 0.00059577933, + 0.00059538014, 0.00059550797, 0.00059510866, 0.00059523608, 0.00059483742, 0.0005949653, 0.00059456634, + 0.00059469335, 0.00059429405, 0.00059442141, 0.00059402199, 0.00059414876, 0.00059374992, 0.00059387728, + 0.00059347879, 0.00059360539, 0.00059320632, 0.00059333286, 0.00059293403, 0.00059306069, 0.00059266214, + 0.00059278839, 0.00059238879, 0.00059251388, 0.00059211464, 0.00059224048, 0.00059184141, 0.00059196621, + 0.00059156673, 0.00059169269, 0.00059129356, 0.00059141824, 0.00059106783, 0.00059123657, 0.0005908765, + 0.00059103698, 0.00059066986, 0.0005908226, 0.00059044809, 0.00059059501, 0.00059021619, 0.0005903581, + 0.00058997347, 0.00059006235, 0.00058963039, 0.00058972492, 0.00058929931, 0.00058939884, 0.0005889762, + 0.00058907783, 0.00058865867, 0.00058876403, 0.00058834819, 0.00058845611, 0.00058804301, 0.00058815308, + 0.0005877419, 0.00058785349, 0.00058744353, 0.00058755622, 0.00058714894, 0.00058726349, 0.00058685715, + 0.00058697263, 0.00058656756, 0.0005866845, 0.0005862806, 0.00058639795, 0.00058599433, 0.00058611186, + 0.00058570941, 0.00058582763, 0.00058542547, 0.00058554451, 0.00058514334, 0.00058526249, 0.00058486208, + 0.00058498187, 0.00058458198, 0.00058470236, 0.00058430363, 0.0005844243, 0.0005840254, 0.00058414589, + 0.00058374635, 0.00058386644, 0.00058346824, 0.00058358954, 0.00058319222, 0.00058331375, 0.0005829166, + 0.00058303814, 0.00058264151, 0.00058276334, 0.00058236666, 0.00058248872, 0.00058209238, 0.00058221346, + 0.00058181677, 0.00058193837, 0.00058154308] + data = np.array([run1, run2, run3]) + pl = PltData(data) + pl.linePlot("../results/lm3runs", legend=legend, xLegend="Anzahl der Loops", + yLegend="Mittlerer quadratischer Fehler", pltDiff=False) + return +#plotLerningCurveResults() +def plotStHCandBackpropagation(): + hillClimber = [0.0028601581371644072, 0.00045080809018611858, 0.00041390039241275776, 0.00041390039241275776, 0.00041390039241275776, 9.1719143410278712e-06, 9.1719143410278712e-06, 9.1719143410278712e-06, 9.1719143410278712e-06, 9.1719143410278712e-06, 9.1719143410278712e-06, 9.1719143410278712e-06, 9.1719143410278712e-06, 9.1719143410278712e-06, 9.1719143410278712e-06, 9.1719143410278712e-06, 1.0566753421730754e-07, 1.0566753421730754e-07, 1.0566753421730754e-07, 1.0566753421730754e-07, 1.0566753421730754e-07, 1.0566753421730754e-07, 1.0566753421730754e-07, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 6.150817391395504e-09, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 7.2859891985603836e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11, 5.538098780423211e-11] + bpNull = [0.00095506187, 0.0006840342, 0.00047308338, 0.00031915712, 0.00021138863, 0.00013813192, 8.9303343e-05, 5.7274588e-05, 3.6487163e-05, 2.3113473e-05, 1.4572544e-05, 9.1421916e-06, 5.7129173e-06, 3.5552675e-06, 2.2030304e-06, 1.3590599e-06, 8.3316957e-07, 5.1032492e-07, 3.1011524e-07, 1.8796347e-07, 1.1353738e-07, 6.7730824e-08, 4.0452502e-08, 2.3912325e-08, 1.4158002e-08, 8.2278611e-09, 4.7803708e-09, 2.7823039e-09, 1.6264707e-09, 8.9706848e-10, 4.9069959e-10, 2.999434e-10, 1.6086989e-10, 8.578039e-11, 4.5204788e-11, 2.3656863e-11, 1.2249372e-11, 6.2541704e-12, 3.1147177e-12, 1.5406274e-12, 7.5786388e-13, 3.7696457e-13, 1.6868538e-13, 8.2548768e-14, 4.1884953e-14, 1.5400496e-14, 6.9090241e-15, 2.5762812e-15, 1.7369461e-15, 1.6224543e-15, 9.8797923e-16, 9.3029967e-16, 4.8924623e-16, 4.5883436e-16, 4.2939827e-16, 4.0093796e-16, 3.7345344e-16, 1.2490009e-16, 1.1470859e-16, 1.0495077e-16, 9.5626632e-17, 8.6736174e-17, 7.8279397e-17, 7.0256301e-17, 6.2666886e-17, 5.9034808e-17, 5.5511151e-17, 5.2095914e-17, 4.8789098e-17, 4.5590701e-17, 4.2500725e-17, 3.9519169e-17, 3.6646033e-17, 3.3881318e-17, 3.1225023e-17, 2.8677147e-17, 2.6237693e-17, 2.3906658e-17, 2.1684043e-17, 1.9569849e-17, 1.7564075e-17, 1.5666721e-17, 1.3877788e-17, 1.2197274e-17, 1.0625181e-17, 9.1615084e-18, 7.8062556e-18, 6.5594231e-18, 5.4210109e-18, 4.3910188e-18, 3.469447e-18, 2.6562953e-18, 1.9515639e-18, 1.9515639e-18, 1.3552527e-18, 1.3552527e-18, 1.3552527e-18, 1.3552527e-18, 1.3552527e-18, 1.3552527e-18, 1.3552527e-18, 8.6736174e-19, 8.6736174e-19, 8.6736174e-19, 8.6736174e-19, 8.6736174e-19, 8.6736174e-19, 8.6736174e-19, 8.6736174e-19, 8.6736174e-19, 4.8789098e-19, 4.8789098e-19, 4.8789098e-19, 4.8789098e-19, 4.8789098e-19, 4.8789098e-19, 4.8789098e-19, 4.8789098e-19, 4.8789098e-19, 4.8789098e-19, 4.8789098e-19, 2.1684043e-19, 2.1684043e-19, 2.1684043e-19, 2.1684043e-19, 2.1684043e-19, 2.1684043e-19, 2.1684043e-19, 2.1684043e-19, 2.1684043e-19, 2.1684043e-19, 2.1684043e-19, 2.1684043e-19, 2.1684043e-19, 2.1684043e-19, 2.1684043e-19, 2.1684043e-19, 5.4210109e-20, 5.4210109e-20, 5.4210109e-20, 5.4210109e-20, 5.4210109e-20, 5.4210109e-20, 5.4210109e-20, 5.4210109e-20, 5.4210109e-20, 5.4210109e-20, 5.4210109e-20, 5.4210109e-20, 5.4210109e-20, 5.4210109e-20, 5.4210109e-20, 5.4210109e-20, 5.4210109e-20, 5.4210109e-20, 5.4210109e-20, 5.4210109e-20, 5.4210109e-20, 5.4210109e-20, 5.4210109e-20, 5.4210109e-20, 5.4210109e-20, 5.4210109e-20, 5.4210109e-20, 5.4210109e-20, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0] + bpNotNull = [0.00045088687, 0.00027274559, 0.00015260832, 8.0811478e-05, 4.1239451e-05, 2.0536905e-05, 1.0053858e-05, 4.86523e-06, 2.3305261e-06, 1.1080973e-06, 5.2112517e-07, 2.437049e-07, 1.1329674e-07, 5.1994455e-08, 2.3518133e-08, 1.0735391e-08, 4.709706e-09, 2.0746591e-09, 9.2309854e-10, 4.2004164e-10, 1.7079312e-10, 6.8476183e-11, 2.7059787e-11, 1.0591814e-11, 4.0767945e-12, 1.5302412e-12, 5.8072736e-13, 2.1074301e-12, 7.6640083e-13, 2.6837392e-13, 9.5316333e-14, 3.298143e-14, 1.0023449e-14, 3.2539618e-15, 1.2360447e-15, 3.2141173e-16, 2.3613923e-16, 1.1975013e-16, 1.0977547e-16, 1.9569849e-17, 1.7564075e-17, 1.5666721e-17, 1.3877788e-17, 1.2197274e-17, 1.0625181e-17, 9.1615084e-18, 7.8062556e-18, 6.5594231e-18, 5.4210109e-18, 4.3910188e-18, 4.3910188e-18, 4.3910188e-18, 4.3910188e-18, 3.469447e-18, 3.469447e-18, 3.469447e-18, 3.469447e-18, 3.469447e-18, 2.6562953e-18, 2.6562953e-18, 2.6562953e-18, 2.6562953e-18, 2.6562953e-18, 2.6562953e-18, 1.9515639e-18, 1.9515639e-18, 1.9515639e-18, 1.9515639e-18, 1.9515639e-18, 1.9515639e-18, 1.9515639e-18, 1.3552527e-18, 1.3552527e-18, 1.3552527e-18, 1.3552527e-18, 1.3552527e-18, 1.3552527e-18, 1.3552527e-18, 1.3552527e-18, 8.6736174e-19, 8.6736174e-19, 8.6736174e-19, 8.6736174e-19, 8.6736174e-19, 8.6736174e-19, 8.6736174e-19, 8.6736174e-19, 8.6736174e-19, 4.8789098e-19, 4.8789098e-19, 4.8789098e-19, 4.8789098e-19, 4.8789098e-19, 4.8789098e-19, 4.8789098e-19, 4.8789098e-19, 4.8789098e-19, 4.8789098e-19, 4.8789098e-19, 2.1684043e-19, 2.1684043e-19, 2.1684043e-19, 2.1684043e-19, 2.1684043e-19, 2.1684043e-19, 2.1684043e-19, 2.1684043e-19, 2.1684043e-19, 2.1684043e-19, 2.1684043e-19, 2.1684043e-19, 2.1684043e-19, 2.1684043e-19, 2.1684043e-19, 2.1684043e-19, 2.1684043e-19, 1.2197274e-17, 9.1615084e-18, 2.1684043e-19, 1.2197274e-17, 5.9034808e-17, 1.522762e-16, 7.1692869e-16, 3.5527137e-15, 2.0570351e-14, 1.2213543e-13, 7.6151672e-13, 5.0262333e-12, 2.4486165e-11, 1.5717634e-10, 1.1135249e-09, 8.2872296e-09, 6.5007704e-08, 5.1567662e-07, 3.0398892e-06, 6.2681725e-06, 7.1649861e-06, 7.612211e-06, 7.9691517e-06, 8.2959523e-06, 8.6020427e-06, 8.9013001e-06, 9.2022019e-06, 9.4987581e-06, 9.7917573e-06, 1.0088142e-05, 1.038714e-05, 1.0681981e-05, 1.0972761e-05, 1.1266317e-05, 1.1561963e-05, 1.1859494e-05, 1.2158172e-05, 1.2457803e-05, 1.2757813e-05, 1.3057996e-05, 1.3357853e-05, 1.3657239e-05, 1.3955645e-05, 1.4253031e-05, 1.4548834e-05, 1.4843014e-05, 1.5142926e-05, 1.544822e-05, 1.575018e-05, 1.6048918e-05, 1.6352024e-05, 1.6659371e-05, 1.6961967e-05, 1.7259928e-05, 1.7561171e-05, 1.7865721e-05, 1.816425e-05, 1.8456989e-05, 1.8752169e-05, 1.9049867e-05, 1.9349289e-05, 1.9650526e-05, 1.9952984e-05, 2.0256653e-05, 2.0551874e-05, 2.0848112e-05, 2.1144671e-05, 2.1432517e-05, 2.1720505e-05, 2.2018219e-05, 2.2315324e-05, 2.2611979e-05, 2.2907647e-05, 2.320249e-05, 2.3495859e-05, 2.3788156e-05, 2.408836e-05, 2.4386914e-05, 2.4683162e-05, 2.497728e-05, 2.5268573e-05, 2.5557545e-05, 2.5843472e-05, 2.6136961e-05, 2.6437187e-05, 2.6734104e-05, 2.7026979e-05, 2.7316233e-05, 2.7601212e-05, 2.7882468e-05, 2.816991e-05, 2.8463843e-05, 2.8752625e-05, 2.9036828e-05, 2.9326568e-05, 2.9622226e-05, 2.9911953e-05, 3.0196383e-05, 3.0485795e-05, 3.0780575e-05, 3.1068605e-05, 3.1350653e-05, 3.1637101e-05, 3.192859e-05, 3.221272e-05, 3.2501601e-05, 3.2794305e-05, 3.3079956e-05, 3.335773e-05, 3.3639906e-05, 3.3925502e-05, 3.4203535e-05, 3.4484819e-05, 3.4770033e-05, 3.5058194e-05, 3.535e-05, 3.5632314e-05, 3.5918121e-05, 3.6206333e-05, 3.6485617e-05, 3.6767262e-05, 3.7052061e-05, 3.7338683e-05, 3.7628019e-05, 3.7906742e-05, 3.8188125e-05, 3.8470935e-05, 3.8756145e-05, 3.9042614e-05, 3.9318747e-05, 3.9595969e-05, 3.9875267e-05, 4.0155446e-05, 4.0437513e-05, 4.0720275e-05, 4.100466e-05, 4.1289361e-05, 4.1575386e-05, 4.1861684e-05, 4.214915e-05, 4.2436368e-05, 4.2724525e-05, 4.2999243e-05, 4.3274842e-05, 4.3550037e-05, 4.3826065e-05, 4.4114808e-05, 4.4403874e-05, 4.4678523e-05, 4.4953591e-05, 4.5241144e-05, 4.5528668e-05, 4.5814792e-05, 4.6100711e-05, 4.6385027e-05, 4.6669007e-05, 4.6951252e-05, 4.7232974e-05, 4.7512855e-05, 4.7792109e-05, 4.8069116e-05, 4.8345468e-05, 4.8619513e-05, 4.8892703e-05, 4.9163493e-05, 4.9433143e-05, 4.9700255e-05, 4.9966369e-05, 5.022977e-05, 5.0492068e-05, 5.0765771e-05, 5.1052146e-05, 5.1335141e-05, 5.1616316e-05, 5.1894185e-05, 5.2170111e-05, 5.2442094e-05, 5.2712108e-05, 5.2978525e-05, 5.3242904e-05, 5.3518048e-05, 5.3805521e-05, 5.4088701e-05, 5.4369328e-05, 5.4645527e-05, 5.4918943e-05, 5.5187986e-05, 5.5454308e-05, 5.5730921e-05, 5.6004403e-05, 5.6272966e-05, 5.6553599e-05, 5.6829085e-05, 5.7101224e-05, 5.7368114e-05, 5.763158e-05, 5.7905043e-05, 5.8190075e-05, 5.8469464e-05, 5.8745143e-05, 5.9014954e-05, 5.928085e-05, 5.9556347e-05, 5.9827791e-05, 6.0093083e-05, 6.0369883e-05, 6.0640363e-05, 6.0906477e-05, 6.1181854e-05, 6.1452767e-05, 6.1717001e-05, 6.1992454e-05, 6.2261068e-05, 6.2525003e-05, 6.2797859e-05, 6.3081701e-05, 6.3358253e-05, 6.3629741e-05, 6.390972e-05, 6.4184394e-05, 6.4451604e-05, 6.4729596e-05, 6.4999796e-05, 6.5264416e-05, 6.5537555e-05, 6.5805063e-05, 6.6064524e-05, 6.6334775e-05, 6.6613182e-05, 6.6885601e-05, 6.7149638e-05, 6.7424065e-05, 6.7706394e-05, 6.798251e-05, 6.8249981e-05, 6.8511152e-05, 6.8780166e-05, 6.9059359e-05, 6.9329246e-05, 6.9592701e-05, 6.9847243e-05, 7.0111833e-05, 7.0383867e-05, 7.0649083e-05, 7.0904869e-05, 7.1170813e-05, 7.1443988e-05, 7.1709976e-05, 7.1983064e-05, 7.2265968e-05, 7.253886e-05, 7.2804447e-05, 7.3076997e-05, 7.3359057e-05, 7.3630639e-05, 7.3894553e-05, 7.4165255e-05, 7.4445496e-05, 7.4714881e-05, 7.4976291e-05, 7.5244439e-05, 7.5522017e-05, 7.5788543e-05, 7.6046919e-05, 7.6311713e-05, 7.6585595e-05, 7.6848264e-05, 7.7102704e-05, 7.7363373e-05, 7.7633289e-05, 7.7891709e-05, 7.8141573e-05, 7.8397636e-05, 7.8662822e-05, 7.893407e-05, 7.921426e-05, 7.9482103e-05, 7.9740901e-05, 8.0005469e-05, 8.0278733e-05, 8.0539678e-05, 8.0791469e-05, 8.1048915e-05, 8.1315222e-05, 8.1586913e-05, 8.1848928e-05, 8.2098304e-05, 8.2356455e-05, 8.2619954e-05, 8.2891944e-05, 8.316926e-05, 8.3436593e-05, 8.369064e-05, 8.3953273e-05, 8.4220766e-05, 8.4496307e-05, 8.4776671e-05, 8.5046689e-05, 8.5302949e-05, 8.5567553e-05, 8.5836771e-05, 8.6095548e-05, 8.6340398e-05, 8.6593463e-05, 8.6851294e-05, 8.7117209e-05, 8.738746e-05, 8.764692e-05, 8.7910819e-05, 8.8182634e-05, 8.8439665e-05, 8.870459e-05, 8.8973815e-05, 8.9231806e-05, 8.9493929e-05, 8.9763773e-05, 9.0018497e-05, 9.0280999e-05, 9.0547466e-05, 9.0802394e-05, 9.1061076e-05, 9.1327231e-05, 9.1578033e-05, 9.1836482e-05, 9.2098686e-05, 9.2349095e-05, 9.2603179e-05, 9.286464e-05, 9.3129463e-05, 9.3401606e-05, 9.3657385e-05, 9.392052e-05, 9.4187111e-05, 9.4441406e-05, 9.4698968e-05, 9.4963791e-05, 9.5231859e-05, 9.5506708e-05, 9.5764728e-05, 9.6010161e-05, 9.6258591e-05, 9.6514021e-05, 9.6772426e-05, 9.7037911e-05, 9.7306154e-05, 9.7561075e-05, 9.779886e-05, 9.8043856e-05, 9.8291377e-05, 9.8545919e-05, 9.8803182e-05, 9.9067038e-05, 9.933309e-05, 9.9605801e-05, 9.9880861e-05, 0.00010014222, 0.00010038558, 0.00010063576, 0.00010088813, 0.0001011471, 0.0001014082, 0.0001016757, 0.00010194498, 0.00010220015, 0.0001024572, 0.00010272063, 0.00010296553, 0.0001032168, 0.00010346972, 0.00010372902, 0.00010398986, 0.00010423642, 0.00010448432, 0.0001047383, 0.00010499409, 0.00010525592, 0.00010551911, 0.0001057882, 0.00010603754, 0.00010629291, 0.00010654951, 0.00010679129, 0.0001070344, 0.00010728346] + + legend = ['Stochastischer Hill Climber', "Fehlerrückübertragung - konvergiert", "Fehlerrückübertragung - konvergiert nicht"] + data = np.array([hillClimber, bpNull, bpNotNull]) + pl = PltData(data) + pl.linePlot("../results/hillClimberBackP", legend=legend, xLegend="Anzahl der Loops", + yLegend="Mittlerer quadratischer Fehler", pltDiff=False) + + + + + zoomin = 10 + + data = np.array([hillClimber[zoomin:-400], bpNull[zoomin:-400], bpNotNull[zoomin:-400]]) + pl = PltData(data) + pl.linePlot("../results/hillClimberBackPZoom", legend=legend, xLegend="Anzahl der Loops", + yLegend="Mittlerer quadratischer Fehler", pltDiff=False) + return +#plotStHCandBackpropagation() + +def searchForThreshold(): + ''' + Funktion überprüft den Zusammenhang zwischen dem anfänglichem MSE und ob der MSE auf ein lokales Maximum steigt. + :return: + ''' + grow = [] + notGrow = [] + i = 0 + while i < 1000: + value, growing = testSomething(numberOfNeurons=[1, 98, 1], activationFunctions=["linear", "sigmoid", "linear"], featureReduction='mean', + numberLoops=100000001, loss='mean_squared_error', printVecs = False, plotModel=False, cLM = False, stepWise=True, searchForThreshold=True) + if growing: + grow.append(value) + else: + notGrow.append(value) + print(repr(grow)) + print(repr(notGrow)) + i += 1 + +def plotResultSearchForThreshold(): + + grow = [0.024079174, 0.039771743, 0.039146718, 0.03756436, 0.02281956, 0.0035938651, 0.0001105033, 0.0001710262, 0.056928281, 0.0069151851, 0.039870616, 0.042332299, 0.013184379, 0.01501829, 0.032634027, 0.039601475, 0.089674182, 0.17793597, 0.0021299671, 0.003677472, 0.0047185868, 0.0013119344, 0.0099356389, 0.010082411, 0.0022071493, 0.0090817995, 0.0095441425, 0.014651851, 0.0004744078, 0.0045104069, 0.012665771, 0.058654238, 0.0030636177, 0.012076562, 0.012560363, 0.0026141703, 0.013689535, 0.098466277, 0.00022242502, 0.080409624, 0.048981436, 0.023433149, 0.037293915, 0.027347488, 0.047098499, 0.0037568596, 0.023725243, 0.0041229487, 0.0095038041, 0.013646821, 0.0011982141, 0.016057743, 0.010628701, 0.001319126, 0.0072147977, 0.010802578, 0.10179428, 0.003125886, 0.010501947, 0.004862098, 6.1164877e-07, 0.014719273, 0.010127937, 0.086046241, 1.3059132e-05, 0.014058954, 0.0040534716, 0.0097545153, 0.037667755, 0.036909785, 3.3192024e-05, 0.04450848, 1.5240735e-07, 0.0043764538, 0.049541313, 0.0026996885, 0.057185147, 0.014993154, 0.00011234835, 0.012730586, 0.041715655, 9.8099208e-06, 0.0032115094, 0.0089800311, 0.0001367248, 0.0061124493, 4.9496608e-05, 0.0001915364, 0.097973064, 0.049323615, 0.011467421, 0.052351899, 0.0028749213, 0.0034391887, 0.011474202, 0.015609559, 0.086486824, 0.013378018, 0.0064500566, 0.062432248, 3.6487472e-05, 0.021930248, 0.01091972, 0.0026491762, 0.059765305, 0.061525028, 0.077596657, 0.036393903, 0.0030755734, 0.024773812, 6.8615052e-05, 0.098542988, 0.018335097, 0.026214186, 1.6740669e-10, 4.9662485e-05, 0.086126544, 0.032328974, 0.0046913424, 0.015091182, 0.0001658987, 0.090527065, 0.013581879, 0.05189446, 0.00080031797, 2.8217803e-05, 0.018793974, 0.00015974999, 0.0060679154, 0.02398145, 0.0026440409, 0.028358337, 0.011899445, 0.060367502, 0.016167736, 0.0069827028, 0.025943018, 0.033823568, 0.079245865, 0.01112537, 0.0061553265, 0.0041315374, 0.0046428433, 0.010130634, 0.0074813291, 0.029312382, 0.00020355043, 0.023750365, 0.021004032, 0.0018534659, 0.005755913, 0.028141743, 0.0014141194, 0.020924048, 0.044028092, 0.00051871064, 0.012514875, 0.044799313, 0.014395762, 0.05607973, 0.10690337, 0.0017644052, 0.076860271, 0.052452877, 0.010279533, 0.034699764, 0.0058353171, 0.037274849, 0.049168557, 0.043404017, 0.036178529, 0.042114269, 0.00050496892, 0.0087436493, 0.0057855234, 0.0027291449, 0.0088550821, 0.0024033508, 0.021166414, 0.0011951615, 0.15239808, 0.00099947385, 0.1382679, 0.035781585, 0.06576813, 0.0055732285, 0.017872769, 0.00062530034, 0.0038396053, 0.013413759, 0.0058034835, 0.0074885422, 0.010685465, 0.0022798982, 0.010259066, 0.034906324, 0.0017234955, 0.013739014, 0.015156376, 0.00028316694, 0.01794051, 0.009108454, 0.049328722, 0.019848343, 0.0014947285, 0.0057089585, 3.9939846e-06, 0.00031855528, 0.032401569, 0.040547907, 4.7175676e-05, 0.043453351, 0.062867641, 0.014287934, 0.058905754, 0.030465906, 0.033593997, 0.0011034551, 0.033907268, 0.05053765, 0.018914422, 0.015673459, 0.0088317823, 0.038275972, 0.055635825, 0.0046912301, 0.0063289255, 0.13176528, 0.13611215, 0.004673209, 0.0011371573, 0.015494588, 0.042748511, 0.012534895, 0.016121374, 0.045128342, 0.0076359869, 0.0036512669, 0.062062927, 6.5764289e-06, 0.012531201, 0.01056081, 0.0012001946, 0.00044060947, 0.059725553, 0.0098478524, 0.019325204, 0.00068263331, 0.00050438388, 0.012272159, 9.6076386e-05, 0.014567514, 0.0022918186, 0.011319398, 0.00061092159, 6.3688487e-05, 0.011403041, 3.6484722e-05, 0.017725255, 0.099782676, 0.001605013, 0.045271408, 0.011175017, 0.05380455, 0.0017435474, 0.092033915, 0.017797792, 0.0024485018, 0.022104328, 0.0015960446, 0.0036886903, 0.048137859, 0.00048995053, 0.0081517557, 0.048828039, 0.018769909, 0.018668555, 0.011371773, 0.0029322242, 0.0016617539, 0.022838797, 0.020761339, 0.039335765, 0.030509951, 0.0027543961, 0.00012974707, 0.095389478, 0.012338391, 0.043572553, 0.040923283, 5.4752518e-06, 0.013555553, 0.0793157, 0.081821322, 0.016244469, 0.00025073218, 0.014135472, 0.10499715, 0.004111127, 0.025636023, 0.0013752478, 0.029825054, 0.035396896, 0.008203974, 0.024664801, 0.017725207, 0.01074526, 0.018681228, 0.08116401, 0.0011817472, 0.0036700596, 0.0062352256, 0.015956908, 0.028759392, 0.010369242, 0.0060364073, 0.022453124, 0.011940468, 0.029420938, 0.0049052127, 0.019887973, 0.007887261, 0.086460903, 0.059192456, 0.030165009, 0.010715985, 0.048482616, 0.032500152, 0.0055671036, 0.079587601, 0.0010138905, 0.0004501334, 0.019893331, 0.062784739, 0.02691685, 0.00012848766, 0.017098064, 0.02960952, 0.0035472973, 0.059069954, 0.0015454782, 0.00067382929, 0.067353539, 0.0007450807, 0.0046202531, 0.0047944919, 0.0019672869, 0.04285736, 0.000139904, 0.016496744, 0.0363531, 0.026236175, 0.0023044697, 0.0080547398, 0.025972582, 0.05663994, 0.023171734, 0.00010166824, 0.078484938, 0.32730091, 0.017901491, 0.010509725, 3.4098081e-05, 0.026795685, 0.043773372, 0.0035437371, 0.0099709593, 0.014390329, 0.0055845953, 0.0095613487, 0.026472326, 0.028011922, 0.00047779127, 0.022913478, 0.0013849913, 0.0072855777, 0.0037690136, 0.069069512, 0.0013013809, 0.02626702, 0.00022161446, 0.0016347766, 0.021293741, 0.067912392, 0.012626223, 0.0019008201, 0.0028060363, 0.028269133, 0.00031798176, 0.0070089758, 6.8084475e-05, 0.072210521, 0.00013471297, 0.038213447, 0.012402163, 0.014603818, 0.0087303454, 0.022001255, 0.057109337, 0.026400438, 0.014311777, 0.03234854, 0.10314435, 0.02026853, 0.018553399, 0.035306714, 0.00019399902, 0.049711805, 0.0086855302, 0.0041810167, 5.5547926e-06, 0.027226727, 8.3584135e-05, 0.086632043, 0.016996039, 0.0035514596, 0.0060081696, 0.0057591754, 0.013308598, 0.036153253, 0.0065215905, 0.00059143291, 0.03007661, 0.031973362, 0.0059868344, 0.024294497, 0.14173111, 5.7269845e-05, 0.015045939, 0.0095341643, 0.011972107, 0.0074409675, 0.056870673, 0.018459655, 0.010325762, 0.0036262621, 2.6962449e-05, 0.021911852, 0.02673088, 0.00054069108, 0.0016910452, 0.020160768, 0.010110341, 0.010711203, 0.024106286, 0.0021643653, 0.023797575, 0.004215369, 0.024453264, 0.0041805049, 0.0031973068, 0.086481132, 0.0067150751, 0.0059344606, 0.028815661, 0.098018438, 0.053341687, 0.019046023, 0.020414876, 0.0051504695, 0.021208467, 0.056157399, 0.060347572, 0.0023368828, 0.00030339253, 0.0041714781, 0.026630195, 0.00022007231, 0.051141169, 0.023366554, 0.0045483448, 0.0073137912, 4.8849784e-06, 0.032610189, 0.0040547508, 0.013610167, 0.009298848, 0.019099191, 0.034232058, 0.0050844601, 0.0014477688, 0.0027988646, 0.0176783, 0.0013366076, 0.00029733885, 0.00040994913, 0.046919465, 0.01675247, 0.02716299, 0.002176485, 0.014276918, 1.1830021e-08, 0.012517503, 0.0039966404, 5.8549622e-06, 0.0003875675, 0.026510661, 0.0023942802, 0.015186471, 0.011195091, 0.033174869, 0.11517508, 0.00011412223, 0.017845022, 0.044510484, 0.00018727986, 0.0028262252, 0.092022814, 0.054403521, 0.0013843082, 0.028159013, 0.026863137, 0.12819657, 0.0017693115, 0.034056921, 0.00039716176, 0.0031442605, 0.080810644, 0.00033428785, 0.0043381602, 0.030757139, 0.065406524, 0.014441419, 0.040058639, 0.058796253, 0.023948681, 0.035361353, 0.011161803, 0.12053779, 0.0070199608, 0.022715058, 0.011045972, 0.1012762, 0.010528336, 0.015086884, 0.018541003, 0.085574307, 0.016614228, 0.00047318247, 0.011149105, 0.0074820188, 0.043724485, 0.00023853684, 0.028374925, 0.017556919, 0.0011357573, 6.5247594e-05, 0.098314911, 0.023684751, 0.002342155, 0.0065032281, 0.010474686, 0.020433182, 0.00033640742, 0.051789712, 0.0060721566, 0.0050372994, 0.0053622178, 0.0004275727, 0.0055022831, 0.00020206024, 0.015148907, 0.0042532119, 3.1128784e-05, 0.056890536, 0.1365431, 0.021004451, 0.0007496989, 0.0040098797, 0.042483579, 0.0049578752, 0.0082705682, 0.017122483, 0.0024507719, 0.065531842, 0.0071255215, 0.033804718, 0.026482942, 0.0056586037, 0.0076717068, 0.0024398568, 7.2920731e-05, 0.0026112322, 0.032162625, 0.0023091163, 0.0051483931, 0.0069455276, 0.0014797687, 0.0069567151, 0.0067189098, 0.036419235, 0.00036497272, 0.00083604117, 0.00036575287, 1.0304496e-05, 0.0052399891, 0.0073932763, 1.8426186e-05, 0.082386211, 0.023834771, 2.9912449e-06, 0.0032921487, 3.0426365e-06, 0.0084478464, 0.045242772, 0.0092688715, 0.0014989168, 0.0055566034, 0.0006355017, 0.013278815, 0.0002135813, 3.5513403e-05, 0.026849052, 0.0077205547, 0.026674204, 3.7785878e-05, 0.0087310262, 0.024347166, 0.006876254, 0.024997555, 0.0064327167, 0.050061546, 0.021541363, 0.04737734, 0.0017452427, 0.00031868854, 0.0042012539, 0.00044464562, 0.016953006, 0.025410697, 0.00030713074, 0.00086464599, 0.042775281, 0.0092605799, 0.0086541157, 0.027550854, 3.6191497e-05, 0.096994646, 0.036106765, 0.021153746, 0.00010829419, 0.0010955487, 0.027839221, 0.00030260024, 0.054320194, 0.012479784, 0.010346491, 0.025543997, 0.00016494053, 0.001301482, 0.00028686825, 0.0082663801, 0.079351068, 0.06958089, 3.2871128e-07, 0.02135537, 0.034024019, 0.073321126, 0.044032067, 0.012940367, 0.0054330854, 0.000559657, 0.0056550419, 0.014265358, 0.00033408089, 0.00015483549, 0.0009162926, 0.0052512577, 0.0055052382, 0.043361112, 0.052906536, 0.0024968293, 0.0014341573, 0.038542043, 0.02300372, 0.023983426, 0.002469697, 0.081005022, 0.026997084, 6.9394844e-07, 0.02591718, 0.029430198, 0.00084013236, 0.025684264, 0.0090989321, 0.013408272, 0.098013848, 0.019645629, 0.015564402, 0.052325707, 0.01250695, 0.025584562, 0.01617616, 0.080386862, 0.017251745, 0.010536948, 0.015876345, 0.0093895774, 0.026963746, 0.011343594, 0.0043968665, 0.071242087, 0.011258585, 0.0046877768, 0.011640015, 0.00033559353, 0.0052904557, 0.00032258872, 0.0024337801, 0.013493386, 0.090300739, 0.016379634, 0.039935656, 0.023095705, 1.9725203e-05, 0.056588423, 0.0083144959, 9.7740958e-05, 0.016786348, 0.0022389772, 0.00097569643, 0.0018700926, 0.018725023, 0.0029613939, 0.019903429, 9.9624649e-06, 0.001967666, 0.0069305156, 0.076184303, 0.0098900637, 2.7471939e-05, 0.0079362737, 0.0016123619, 0.068126746, 0.021728817, 0.0077629141, 0.080058739, 0.016334219, 0.00044840394, 0.0045586224, 0.0050788634, 0.0035180757, 0.015406097, 0.0011916268, 0.00071257638, 0.01294368, 0.010579418, 2.3679291e-05, 0.052720148, 0.01546826, 0.0018150227, 0.010087226, 0.005787923, 0.0050023338, 0.00042399295, 0.010259592, 0.021842703, 0.0031392074, 0.027005697, 0.0007182241, 0.0030787687, 0.0041781003, 0.00064339594, 0.0030921139, 0.021422399, 0.012074822, 0.010168156, 8.1411217e-06, 0.00024534084, 0.018708078, 0.0048074187, 0.0015377793, 0.025508434, 0.080088302, 0.011520135, 0.039432712, 0.022862498, 0.17636646, 0.0051274579, 0.0090115024, 0.051679567, 0.020768154, 0.036808319, 0.044410024, 0.0048759002, 0.00020475055, 0.016195524, 4.0733124e-05, 0.12364601, 0.0052412297, 0.066701807, 2.1551908e-07, 0.021624738, 3.6704398e-05, 0.081373028, 0.00087527343, 0.045338344, 4.4438906e-08, 0.00059840153, 0.01848417, 3.9971161e-05, 0.024251739, 0.014328639, 0.0033676804, 0.063558824, 0.018935772, 0.010871201, 0.011530302] + notGrow = [0.0030557869, 0.10547081, 0.0021625783, 0.0047344053, 0.0010159885, 0.028511919, 0.0057373811, 0.0033177002, 0.0006792238, 0.0012989225, 0.0028261743, 0.0093779759, 0.0018208793, 0.0013943744, 0.0032440522, 0.002174254, 0.025455592, 0.0091511235, 0.0010983603, 0.0025394927, 0.00091744144, 0.00065813999, 0.0014295635, 0.0030913409, 0.001163197, 0.0012258826, 0.006445311, 0.0010656227, 0.018986981, 0.0020754735, 0.0058108559, 0.024365643, 0.00092702609, 0.032957014, 0.0011197436, 0.0073422561, 0.001718812, 0.0040783356, 0.0090676742, 0.00092763064, 0.00091898954, 0.02845813, 0.040257972, 0.0031984674, 0.0014068754, 0.035244063, 0.00095780153, 0.0044614174, 0.008698999, 0.0022734043, 0.044070981, 0.0029712028, 0.004986288, 0.0015513079, 0.0015818638, 0.027490037, 0.0069449181, 0.0021168168, 0.00082480814, 0.0010315349, 0.00078093517, 0.0031805499, 0.0070516057, 0.0061280001, 0.00091545505, 0.0024979676, 0.0021258965, 0.0066225654, 0.001505038, 0.0064259432, 0.0063697016, 0.0019539604, 0.014675939, 0.0024803621, 0.0011956115, 0.0016881136, 0.0018304953, 0.0022078317, 0.0024125988, 0.017614514, 0.011117575, 0.0013481757, 0.011182704, 0.0012580079, 0.005324706, 0.0010564758, 0.004215748, 0.0033871769, 0.014042715, 0.034003232, 0.0071792384, 0.0034835387, 0.0089206919, 0.0017173643, 0.0030466339, 0.0020367142, 0.001233738, 0.00099138299, 0.010213023, 0.0017206712, 0.0011061487, 0.00093791221, 0.0019119745, 0.0022968512, 0.028952675, 0.00079621247, 0.0046243104, 0.0026391607, 0.003881654, 0.0020319682, 0.0091876397, 0.0032373567, 0.0043766242, 0.032589648, 0.0091509139, 0.0047743293, 0.0061580492, 0.0011212477, 0.045109779, 0.0017314022, 0.0026356257, 0.00068954192, 0.00095981627, 0.0072937813, 0.0087513495, 0.0023631444, 0.0089493217, 0.0074268836, 0.0018821864, 0.0098871076, 0.006205013, 0.0016513647, 0.0053458805, 0.0065481397, 0.0042927656, 0.019819211, 0.00078145199, 0.0048880274, 0.024623925, 0.010000046, 0.00059689424, 0.0054604709, 0.0026969449, 0.0014257834, 0.0014527168, 0.00081086316, 0.016177775, 0.0014043609, 0.0018973381, 0.004913487, 0.00095489528, 0.011948123, 0.0080183288, 0.0014466534, 0.017187292, 0.044417471, 0.0424641, 0.002077041, 0.00081430323, 0.016867599, 0.0060540363, 0.0032805193, 0.0071629477, 0.0086884489, 0.0032195258, 0.0021750834, 0.0038349149, 0.0015056829, 0.0014029563, 0.0020667117, 0.0011862534, 0.012791142, 0.0017061589, 0.033142835, 0.0060767438, 0.0046015996, 0.0066248528, 0.0014951119, 0.0010564224, 0.0095320214, 0.0026780467, 0.067813464, 0.0076448987, 0.0084719658, 0.0046497937, 0.00084101921, 0.0056215632, 0.00089708623, 0.0017032968, 0.00074122136, 0.0013306759, 0.034723975] + labels = ["grow", "notgrow"] + data = np.array([grow, notGrow]) + plt = PltData(None) + plt.plotPoints(data, labels, filename='../images/threshold.png', xlabel="anfänglicher mittlere quadratischer Fehler") + +def plotResultCheckLM(beginGrowing, stopGrowing, LM, neurons, path, fileName): + ''' + Plottet die Daten aus checkLM + :param beginGrowing: + :param stopGrowing: + :param LM: + :param neurons: + :param path: + :param fileName: + :return: + ''' + pl = PltData(beginGrowing) + pl.linePlot(path + "beginGrowing"+ fileName, neurons, xLegend="Anzahl der Neuronen in der versteckten Schicht", yLegend="Anzahl der Loops") + + pl = PltData(stopGrowing) + pl.linePlot(path + "stopGrowing"+ fileName, neurons, xLegend="Anzahl der Neuronen in der versteckten Schicht", yLegend="Anzahl der Loops") + + pl = PltData(LM) + pl.linePlot(path + "LM"+ fileName, neurons, xLegend="Anzahl der Neuronen in der versteckten Schicht", yLegend="lokales Maximum") + +def checkLM(plotData=True, maxNumberOfNeurons=200, featureReduction = "rfft"): + ''' + Funktion startet die Untersuchung nach der Größe des lokalen Maximum, der Anzahl der Loops wenn der MSE anfängt zu + steigen und der Anzahl der Loops wenn das lokale Maximum erreicht ist. + :param plotData: Boolean, gibt an ob die Daten der Untersuchung direkt geplottet werden sollen + :param maxNumberOfNeurons: Die Anzahl der Neuronen in der versteckten Schicht. Ab dem übergebenen Wert wird + sukzessive auf 1 herunter gezählt + :param featureReduction: die Feature Reudzierungsmethode + :return: Die Ergebnisse der Untersuchung + ''' + stopGrowing = np.array([]) + beginGrowing = np.array([]) + LM = np.array([]) + neurons = np.array([]) + i = maxNumberOfNeurons + while i > 0: + print("neurons " + str(i)) + bG, sG, lm = testSomething(numberOfNeurons=[1, i, 1], activationFunctions=["sigmoid", "linear"], featureReduction=featureReduction, + numberLoops=100000, loss='mean_squared_error', printVecs = False, plotModel=False, cLM = True, stepWise=False, searchForThreshold=False) + stopGrowing = np.append(stopGrowing, np.array([sG])) + beginGrowing = np.append(beginGrowing, np.array([bG])) + LM = np.append(LM, np.array([lm])) + neurons = np.append(neurons,np.array([i])) + i -= 1 + result = {"beginGrowing": beginGrowing, + "stopGrowing": stopGrowing, + "LM": LM} + print(result, neurons) + if plotData: + plotResultCheckLM(beginGrowing, stopGrowing, LM, neurons, "../results/", "_"+featureReduction+".png") + + return result, neurons + +def plotResultCheckLMStatistical(fileName,result, neurons, featureReduction, numberOfExperiments): + ''' + Plottet die Ergebnisse von checkLMStatistical + :param fileName: + :param result: + :param neurons: + :param featureReduction: + :param numberOfExperiments: + :return: + ''' + legend = ["AVG", "MAX", "MIN"] + pl = PltData(result) + pl.linePlot("../results/statistical_run2_"+fileName+"_"+str(numberOfExperiments)+".png", neurons, width = 1600, xLegend="Anzahl der Neuronen in der versteckten Schicht", + yLegend="lokales Maximum / Anzahl der Loops", text="feature Reduction: " + + featureReduction+ "\nAnzahl der Experimente: " + str(numberOfExperiments), legend=legend, pltDiff=False) + +def checkLMStatistical(numberOfExperiments, maxNumberOfNeurons=200, featureReduction = "rfft"): + ''' + Durchläuft die checkLM Funktion numberOfExperiments mal, berechnet den Maximalwert, den Durchschnitt und das Minimum + von beginGrowing, stopGrowing, LM + :param numberOfExperiments: + :param maxNumberOfNeurons: + :param featureReduction: + :return: + ''' + i = 1 + mSum = {} + mMax = {} + mMin = {} + prob = np.array([0.] * maxNumberOfNeurons) + + while i <= numberOfExperiments: + print("experiment " + str(i)) + result, neurons = checkLM(False, maxNumberOfNeurons, featureReduction) + for key, mValue in result.items(): + if i == 1: + mSum[key] = np.array(mValue) + mMin[key] = np.array(mValue) + mMax[key] = np.array(mValue) + else: + mSum[key] += mValue + x = 0 + for value in mValue: + if value > mMax[key][x]: + mMax[key][x] = value + if value < mMin[key][x]: + mMin[key][x] = value + x += 1 + x = 0 + if key == "LM": + for value in mValue: + print(value) + if not value > 0.0: + prob[x] += 1 + x += 1 + result = np.array([mSum[key] / i, mMax[key], mMin[key]]) + plotResultCheckLMStatistical(key, result, neurons, featureReduction, i) + pl = PltData(prob/i) + pl.linePlot("../results/statisticalWahrscheinlichkeit_run2_" + str(i) + ".png", neurons, + width=1600, xLegend="Anzahl der Neuronen in der versteckten Schicht", + yLegend="Wahrscheinlichkeit", + text="Wahrscheinlichkeit, dass MSE sofort konvergiert\nAnzahl der Experimente: " + str(i), + pltDiff=False) + i += 1 +#checkLMStatistical(100, maxNumberOfNeurons=200, featureReduction="rfft") + +def checkScaleOfFunction(numberOfExperiments=400): + ''' + überprüft den Wertebereich des neuronalen Netzes, ob dieser durch null verläuft und null direkt getroffen wird. + Plottet anschließend die Ergebnisse + :param numberOfExperiments: + :return: + ''' + data = np.arange(-1000, 1000, 1) + i = numberOfExperiments + throughNull = [] + nullIsNull = [] + notThroughNull = [] + featureReduction = "rfft" + while i > 0: + nn = NeuralNetwork(numberOfNeurons=[1, 76, 1], activationFunctions=["sigmoid", "linear"], + featureReduction=featureReduction, numberLoops=10000, loss='mean_squared_error', + printVectors=False) + nn.addLayers() + nn.fit(False, False, False, True) + pData = nn.model.predict(data) + sc = Functions.calcScale(pData) + print(i) + if 0. == round(pData[1000][0],3): + nullIsNull.append(sc) + if max(pData)>0 and min(pData)<0: + throughNull.append(sc) + else: + notThroughNull.append(sc) + i-=1 + data = [throughNull, notThroughNull, nullIsNull] + plt = PltData(None) + plt.plotPoints(data, ["durch Null", "nicht durch Null", "null wird auf null abgebildet"], "../results/"+ nn.getFileName() + "throughNull_notThroughNull_-1000_1000.png", "Größenordnung der Skala ") +#checkScaleOfFunction() + +def plotValueRepresentation(numberOfExperiments=1): + ''' + Plottet die Wert-Repräsentation die als Eingabe in das Netz dient. + :param numberOfExperiments: Anzahl der Ausführung + :return: Plots in /results/valueRepresentation/ + ''' + i = 1 + featureReduction = "mean" + legend = [] + while i <= numberOfExperiments: + nn = NeuralNetwork(numberOfNeurons=[1, 600, 1], activationFunctions=["sigmoid", "linear"], + featureReduction=featureReduction, numberLoops=10000, loss='mean_squared_error', printVectors=False) + nn.addLayers() + nn.fit(False, False, False) + data = np.array(nn.dataHistory) + data = np.reshape(data, (-1, len(data))) + text = "konvergiert " + if sum(nn.result[-1000:]) == 0.0: + text += "TRUE" + else: + text += "FALSE" + pl = PltData(data) + pl.linePlot("../results/valueRepresentation/" + nn.getFileName() + "_run_" +str(i)+ ".png", + width=1600, xLegend="Anzahl der Loops", text=text, + yLegend="Wert Repräsentation " + featureReduction, pltDiff=False) + legend.append("run " + str(i)) + i+=1 + +plotValueRepresentation() + +def plotResultCheckLMMean(): + ''' + Gespeichert Ergebnisse aus plotResultCheckLMStatistical für FR mean + :return: + ''' + beginGrowingMean = np.array([194., 132., 35., 110., 20., 49., 37., 63., 30., + 20., 20., 57., 85., 45., 117., 38., 20., 78., + 110., 124., 84., 72., 87., 55., 20., 58., 58., + 20., 20., 80., 20., 20., 105., 84., 37., 117., + 20., 56., 20., 112., 53., 117., 84., 90., 115., + 109., 24., 131., 126., 84., 68., 102., 70., 80., + 89., 97., 108., 52., 67., 20., 103., 160., 21., + 167., 161., 20., 64., 69., 159., 122., 102., 131., + 75., 101., 120., 31., 50., 132., 100., 90., 104., + 56., 91., 124., 78., 20., 118., 99., 85., 125., + 88., 133., 119., 139., 91., 126., 70., 104., 99., + 168., 26., 33., 31., 115., 126., 52., 94., 74., + 100., 108., 47., 155., 20., 20., 108., 98., 74., + 88., 139., 74., 20., 84., 67., 134., 117., 101., + 110., 70., 106., 52., 94., 96., 99., 108., 123., + 113., 158., 20., 120., 20., 130., 38., 113., 20., + 112., 83., 150., 144., 125., 183., 86., 20., 121., + 70., 158., 172., 173., 87., 168., 89., 112., 193., + 20., 120., 168., 181., 121., 151., 87., 157., 121., + 155., 70., 141., 156., 125., 86., 106., 148., 152., + 87., 227., 157., 155., 167., 29., 216., 43., 186., + 20., 113., 51., 191., 93., 127., 171., 211., 75., + 157., 35.]) + stopGrowingMean = np.array([0., 1363., 1188., 1297., 1168., 0., 1262., 1387., + 1205., 1196., 1170., 0., 1324., 0., 1356., 1270., + 1172., 1380., 1340., 1401., 1424., 1314., 1389., 1300., + 1223., 1283., 0., 1223., 1234., 1356., 1239., 1224., + 1396., 1322., 1340., 1580., 1252., 0., 1257., 1402., + 1362., 1411., 1396., 1422., 1437., 1382., 1297., 1479., + 1461., 1420., 1505., 1459., 1446., 1423., 0., 1472., + 1476., 1395., 1446., 1327., 1500., 0., 1357., 0., + 1930., 1347., 1474., 1515., 1550., 1576., 1580., 1656., + 1589., 1536., 1595., 1411., 1633., 1596., 1568., 1555., + 1568., 0., 1592., 0., 1544., 1455., 1617., 1634., + 1662., 1661., 1650., 1754., 1740., 1745., 1667., 0., + 1651., 1699., 0., 1755., 1585., 0., 0., 1761., + 1784., 1698., 1759., 1740., 1769., 2145., 0., 1855., + 1631., 1671., 2012., 0., 2069., 0., 1929., 2124., + 1739., 1844., 1882., 1973., 1971., 1997., 0., 1957., + 2003., 2005., 2000., 0., 2093., 0., 2124., 2068., + 2134., 1915., 2132., 1927., 2197., 2039., 2155., 2066., + 2210., 2227., 2373., 2206., 2205., 2434., 2336., 2208., + 0., 0., 2399., 2602., 2558., 2319., 2465., 2602., + 2674., 2796., 2534., 2726., 2617., 0., 2675., 0., + 0., 2848., 0., 3048., 0., 2909., 3131., 0., + 0., 3396., 0., 3259., 3031., 3376., 3395., 3089., + 0., 3709., 0., 0., 3825., 3577., 0., 0., + 0., 4571., 0., 0., 0., 0., 0., 0.]) + LMMean = np.array([1.27376253e-02, 0.00000000e+00, 1.23603251e-02, + 1.22351227e-02, 1.20515013e-02, 1.20484615e-02, + 1.19321831e-02, 1.17523698e-02, 0.00000000e+00, + 1.17189493e-02, 1.14743141e-02, 0.00000000e+00, + 0.00000000e+00, 1.12422742e-02, 1.10958796e-02, + 1.09747117e-02, 1.10317674e-02, 0.00000000e+00, + 1.06650013e-02, 1.07158776e-02, 0.00000000e+00, + 0.00000000e+00, 1.04241576e-02, 1.02695301e-02, + 0.00000000e+00, 1.01617277e-02, 0.00000000e+00, + 9.93330870e-03, 0.00000000e+00, 9.74661764e-03, + 9.78551060e-03, 0.00000000e+00, 9.43027437e-03, + 9.37462691e-03, 0.00000000e+00, 0.00000000e+00, + 9.10348725e-03, 8.96185730e-03, 0.00000000e+00, + 0.00000000e+00, 8.72960687e-03, 8.60470627e-03, + 8.54940712e-03, 8.44890252e-03, 0.00000000e+00, + 8.35873839e-03, 0.00000000e+00, 0.00000000e+00, + 8.00671801e-03, 8.00968800e-03, 0.00000000e+00, + 7.82481581e-03, 7.75517384e-03, 7.69167580e-03, + 7.56405061e-03, 0.00000000e+00, 7.40486477e-03, + 7.33968755e-03, 0.00000000e+00, 0.00000000e+00, + 7.05261063e-03, 7.02200364e-03, 6.97310176e-03, + 0.00000000e+00, 6.72991341e-03, 6.72476273e-03, + 6.57004118e-03, 6.54877629e-03, 6.48126937e-03, + 6.34397520e-03, 6.29083347e-03, 6.20024092e-03, + 0.00000000e+00, 6.00253418e-03, 6.00352371e-03, + 5.95861534e-03, 0.00000000e+00, 5.77683654e-03, + 5.74756181e-03, 0.00000000e+00, 0.00000000e+00, + 0.00000000e+00, 5.41439326e-03, 0.00000000e+00, + 5.26201259e-03, 5.19405212e-03, 0.00000000e+00, + 0.00000000e+00, 0.00000000e+00, 4.93953936e-03, + 4.86263447e-03, 4.81196353e-03, 4.73453850e-03, + 4.67745168e-03, 4.58785286e-03, 4.49417531e-03, + 0.00000000e+00, 4.41262452e-03, 0.00000000e+00, + 4.26086737e-03, 4.21934808e-03, 4.14823927e-03, + 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, + 3.87981650e-03, 3.80442943e-03, 3.75341205e-03, + 3.70774721e-03, 3.62680503e-03, 3.59290047e-03, + 3.51874996e-03, 0.00000000e+00, 3.40527203e-03, + 0.00000000e+00, 3.26709962e-03, 0.00000000e+00, + 0.00000000e+00, 0.00000000e+00, 3.05800326e-03, + 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, + 2.83491495e-03, 2.79287691e-03, 0.00000000e+00, + 0.00000000e+00, 2.61075771e-03, 0.00000000e+00, + 0.00000000e+00, 0.00000000e+00, 2.40248186e-03, + 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, + 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, + 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, + 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, + 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, + 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, + 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, + 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, + 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, + 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, + 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, + 0.00000000e+00, 7.62329653e-21, 0.00000000e+00, + 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, + 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, + 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, + 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, + 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, + 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, + 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, + 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, + 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, + 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, + 0.00000000e+00, 0.00000000e+00]) + neurons = np.array([200., 199., 198., 197., 196., 195., 194., 193., 192., + 191., 190., 189., 188., 187., 186., 185., 184., 183., + 182., 181., 180., 179., 178., 177., 176., 175., 174., + 173., 172., 171., 170., 169., 168., 167., 166., 165., + 164., 163., 162., 161., 160., 159., 158., 157., 156., + 155., 154., 153., 152., 151., 150., 149., 148., 147., + 146., 145., 144., 143., 142., 141., 140., 139., 138., + 137., 136., 135., 134., 133., 132., 131., 130., 129., + 128., 127., 126., 125., 124., 123., 122., 121., 120., + 119., 118., 117., 116., 115., 114., 113., 112., 111., + 110., 109., 108., 107., 106., 105., 104., 103., 102., + 101., 100., 99., 98., 97., 96., 95., 94., 93., + 92., 91., 90., 89., 88., 87., 86., 85., 84., + 83., 82., 81., 80., 79., 78., 77., 76., 75., + 74., 73., 72., 71., 70., 69., 68., 67., 66., + 65., 64., 63., 62., 61., 60., 59., 58., 57., + 56., 55., 54., 53., 52., 51., 50., 49., 48., + 47., 46., 45., 44., 43., 42., 41., 40., 39., + 38., 37., 36., 35., 34., 33., 32., 31., 30., + 29., 28., 27., 26., 25., 24., 23., 22., 21., + 20., 19., 18., 17., 16., 15., 14., 13., 12., + 11., 10., 9., 8., 7., 6., 5., 4., 3., + 2., 1.]) + plotResultCheckLM(beginGrowingMean, stopGrowingMean, LMMean, neurons, "../results/", "_mean.png") + +def plotResultCheckLMRfft(): + ''' + Gespeichert Ergebnisse aus plotResultCheckLMStatistical für FR rfft + :return: + ''' + beginGrowingRffT = np.array([ 0., 166., 20., 80., 0., 53., 55., 187., 184., + 20., 0., 99., 0., 174., 103., 45., 0., 126., + 20., 0., 150., 0., 165., 0., 80., 20., 78., + 20., 0., 116., 112., 0., 58., 154., 20., 83., + 178., 103., 155., 136., 0., 64., 0., 20., 0., + 153., 30., 0., 55., 153., 20., 0., 0., 32., + 144., 0., 72., 151., 79., 139., 110., 20., 20., + 188., 0., 181., 213., 123., 90., 174., 0., 0., + 117., 0., 0., 0., 0., 0., 38., 106., 44., + 20., 102., 0., 146., 20., 182., 33., 48., 165., + 40., 0., 72., 89., 86., 0., 0., 0., 140., + 214., 0., 122., 44., 0., 113., 173., 45., 0., + 0., 136., 99., 125., 179., 21., 182., 0., 0., + 123., 70., 186., 0., 81., 99., 0., 0., 0., + 0., 120., 91., 0., 0., 185., 189., 0., 0., + 0., 0., 165., 204., 41., 110., 20., 0., 0., + 0., 0., 0., 87., 0., 0., 189., 20., 20., + 0., 0., 96., 202., 173., 0., 210., 248., 0., + 0., 0., 0., 0., 0., 0., 0., 0., 0., + 63., 192., 0., 123., 0., 93., 0., 121., 430., + 0., 0., 167., 0., 0., 187., 0., 0., 0., + 251., 293., 0., 0., 0., 0., 0., 174., 0., + 0., 0.]) + stopGrowingRfft = np.array([ 0., 1315., 1159., 1266., 0., 1283., 1312., 1363., + 1362., 1187., 0., 600., 0., 1378., 1293., 1290., + 0., 1361., 1203., 0., 1348., 0., 1375., 0., + 1344., 1218., 1339., 1234., 0., 1365., 1388., 0., + 1338., 1413., 1237., 1387., 1426., 1402., 1429., 1419., + 0., 1392., 0., 1277., 0., 1431., 1349., 0., + 556., 1453., 1318., 0., 0., 1353., 1452., 0., + 1392., 1511., 1458., 1498., 1464., 1345., 1344., 1548., + 0., 1545., 1576., 624., 1494., 1552., 0., 0., + 1536., 0., 0., 0., 0., 0., 1484., 1599., + 1561., 1460., 1624., 0., 1609., 1469., 683., 1532., + 1589., 1673., 1587., 0., 1609., 590., 1607., 0., + 0., 0., 1725., 1779., 0., 1699., 1688., 0., + 1728., 1797., 1676., 0., 0., 1804., 1814., 1831., + 1859., 1715., 1894., 0., 0., 624., 1862., 1944., + 0., 1871., 1951., 0., 0., 0., 0., 1985., + 2004., 0., 0., 2110., 2124., 0., 0., 0., + 0., 2167., 2236., 542., 2185., 2071., 0., 0., + 0., 0., 0., 2366., 0., 0., 2492., 2296., + 2318., 0., 0., 2496., 2616., 2636., 0., 2781., + 2795., 0., 0., 0., 0., 0., 0., 0., + 0., 0., 0., 3169., 3295., 0., 3387., 0., + 3531., 0., 3688., 4069., 0., 0., 4105., 0., + 0., 688., 0., 0., 0., 5458., 5774., 0., + 0., 0., 0., 0., 0., 0., 0., 0.]) + LMRfft = np.array([ 0. , 0.01246273, 0.01236291, 0.01235204, 0. , + 0.01217434, 0.01211087, 0.01191843, 0.01182644, 0.01172699, + 0. , 0. , 0. , 0.01130819, 0.01123692, + 0.01098786, 0. , 0.01083943, 0.01087086, 0. , + 0.01060294, 0. , 0.01035907, 0. , 0.01019001, + 0.01012991, 0.01002466, 0.00992996, 0. , 0.00970889, + 0.00976401, 0. , 0.009406 , 0.00939607, 0.00921049, + 0.00923866, 0.00906672, 0.00906639, 0.00888964, 0.00890279, + 0. , 0.00876378, 0. , 0.008377 , 0. , + 0.00830176, 0.00826046, 0. , 0. , 0.0080324 , + 0.00802006, 0. , 0. , 0.00763123, 0.00751105, + 0. , 0.00734201, 0.00741164, 0.00723157, 0.00717582, + 0.00702972, 0.00698959, 0.00689237, 0.00689027, 0. , + 0.00676233, 0.00659089, 0. , 0.00644573, 0.00640182, + 0. , 0. , 0.00618931, 0. , 0. , + 0. , 0. , 0. , 0.00569425, 0.00565515, + 0.00556778, 0.00551312, 0.0054436 , 0. , 0.00529607, + 0.0052075 , 0. , 0.0050856 , 0.00501091, 0.00491748, + 0.00481877, 0. , 0.00471564, 0. , 0.00457544, + 0. , 0. , 0. , 0.00437157, 0.00425268, + 0. , 0.00415205, 0.00407894, 0. , 0.00397404, + 0.00388737, 0.00382149, 0. , 0. , 0.00364659, + 0.00359648, 0.00350228, 0.00346691, 0.00339486, 0.00334032, + 0. , 0. , 0. , 0.00311957, 0.00304781, + 0. , 0.00294933, 0.00288248, 0. , 0. , + 0. , 0. , 0.00261791, 0.00256505, 0. , + 0. , 0.00239334, 0.00236052, 0. , 0. , + 0. , 0. , 0.00210735, 0.00205513, 0. , + 0.00196112, 0.0019123 , 0. , 0. , 0. , + 0. , 0. , 0.00163581, 0. , 0. , + 0.00149844, 0.00146177, 0.00141933, 0. , 0. , + 0.00129148, 0.00125141, 0.0012076 , 0. , 0.00113074, + 0.00108925, 0. , 0. , 0. , 0. , + 0. , 0. , 0. , 0. , 0. , + 0. , 0.0006907 , 0.00065968, 0. , 0.00059605, + 0. , 0.00053444, 0. , 0.00047348, 0.00044913, + 0. , 0. , 0.00036125, 0. , 0. , + 0. , 0. , 0. , 0. , 0.00019128, + 0.0001689 , 0. , 0. , 0. , 0. , + 0. , 0. , 0. , 0. , 0. ]) + neurons = np.array([200., 199., 198., 197., 196., 195., 194., 193., 192., + 191., 190., 189., 188., 187., 186., 185., 184., 183., + 182., 181., 180., 179., 178., 177., 176., 175., 174., + 173., 172., 171., 170., 169., 168., 167., 166., 165., + 164., 163., 162., 161., 160., 159., 158., 157., 156., + 155., 154., 153., 152., 151., 150., 149., 148., 147., + 146., 145., 144., 143., 142., 141., 140., 139., 138., + 137., 136., 135., 134., 133., 132., 131., 130., 129., + 128., 127., 126., 125., 124., 123., 122., 121., 120., + 119., 118., 117., 116., 115., 114., 113., 112., 111., + 110., 109., 108., 107., 106., 105., 104., 103., 102., + 101., 100., 99., 98., 97., 96., 95., 94., 93., + 92., 91., 90., 89., 88., 87., 86., 85., 84., + 83., 82., 81., 80., 79., 78., 77., 76., 75., + 74., 73., 72., 71., 70., 69., 68., 67., 66., + 65., 64., 63., 62., 61., 60., 59., 58., 57., + 56., 55., 54., 53., 52., 51., 50., 49., 48., + 47., 46., 45., 44., 43., 42., 41., 40., 39., + 38., 37., 36., 35., 34., 33., 32., 31., 30., + 29., 28., 27., 26., 25., 24., 23., 22., 21., + 20., 19., 18., 17., 16., 15., 14., 13., 12., + 11., 10., 9., 8., 7., 6., 5., 4., 3., + 2., 1.]) + + plotResultCheckLM(beginGrowingRffT, stopGrowingRfft, LMRfft, neurons, "../results/", "_rfft.png") + +#plotResultCheckLMRfft() \ No newline at end of file diff --git a/related/EP/src/threshold.png b/related/EP/src/threshold.png new file mode 100644 index 0000000..31df300 Binary files /dev/null and b/related/EP/src/threshold.png differ diff --git a/related/EP/test/TestFeatureReduction.py b/related/EP/test/TestFeatureReduction.py new file mode 100644 index 0000000..6c1ca9d --- /dev/null +++ b/related/EP/test/TestFeatureReduction.py @@ -0,0 +1,49 @@ +import unittest +import numpy as np + +from src.FeatureReduction import FeatureReduction + +class TestFeatureReduction(unittest.TestCase): + + def testfft(self): + data = np.array([1,2,3,4]) + d = FeatureReduction("mean").mean(FeatureReduction('mean').shuffelVec(data,4),2) + print(d) + + def testVecMean(self): + data = np.array([1,2,3,4,5,6,7,8,9]) + d = FeatureReduction("mean").mean(data, 1) + self.assertEqual(np.array([45/9]),d) + + d = FeatureReduction("mean").mean(data, 2) + np.testing.assert_array_equal(np.array([round(12.5/4.5,6), round(32.5/4.5,6)]), d) + + d = FeatureReduction("mean").mean(data, 3) + np.testing.assert_array_equal(np.array([2, 5, 8]), d) + + d = FeatureReduction("mean").mean(data, 4) + np.testing.assert_array_equal(np.array([round(3.75/2.25,6), round(8.75/2.25,6), round(13.75 / 2.25,6), round(18.75/2.25,6)]), d) + + d = FeatureReduction("mean").mean(data, 5) + np.testing.assert_array_equal(np.array([round(2.6 / 1.8,6), round(5.8 / 1.8,6), round(9 / 1.8,6), + round(12.2 / 1.8,6), round(15.4/1.8,6)]), d) + + d = FeatureReduction("mean").mean(data, 6) + np.testing.assert_array_equal(np.array([round(2 / 1.5,6), round(4 / 1.5,6), round(6.5 / 1.5,6), + round(8.5 / 1.5,6), round(11/1.5,6),round(13/1.5,6)]), d) + + d = FeatureReduction("mean").mean(data, 9) + np.testing.assert_array_equal(np.array([1,2,3,4,5,6,7,8,9]), d) + + def testWeigthsToVec(self): + test =np.array([[ 0.04457645, -0.03319572]], dtype=np.float32), np.array([ 0., 0.], dtype=np.float32), np.array([[-0.03747094], + [ 0.01189486]], dtype=np.float32), np.array([ 0.], dtype=np.float32) + FeatureReduction("mean").calc(test, 1) + + def testShuffelVec(self): + vec = np.array([1,2,3,4,5,6,7,8,9,10]) + print(FeatureReduction('mean').shuffelVec(vec,2)) + + def testPP(self): + vec = np.array([1., 5., 3.]) + print(FeatureReduction('mean').calc(vec, 1)) \ No newline at end of file diff --git a/related/EP/test/TestFunctions.py b/related/EP/test/TestFunctions.py new file mode 100644 index 0000000..b0465d3 --- /dev/null +++ b/related/EP/test/TestFunctions.py @@ -0,0 +1,29 @@ +import unittest +import numpy as np + +import src.Functions + +class TestFunctions(unittest.TestCase): + + def testcalcMeanSquaredError(self): + a = np.array([1, 2, 3, 4, 5]) + b = np.array([1.1, 2.05, 2.95, 4.01, 4.5]) + self.assertEqual(0.05, src.Functions.calcMeanSquaredError(a, b)) + + a = np.array(['1', '2', '3', '4', '5']) + b = np.array(['1.1', '2.05', '2.95', '4.01', '4.5']) + self.assertEqual(0.05, src.Functions.calcMeanSquaredError(a, b)) + + def testGetRandomLayer(self): + layer = (1, 3) + self.assertEqual(layer, np.shape(src.Functions.getRandomLayer(layer))) + layer = (3, 1) + self.assertEqual(layer, np.shape(src.Functions.getRandomLayer(layer))) + layer = (8, 2) + self.assertEqual(layer, np.shape(src.Functions.getRandomLayer(layer))) + layer = (100, 1) + self.assertEqual(layer, np.shape(src.Functions.getRandomLayer(layer))) + layer = (1, 1) + self.assertEqual(layer, np.shape(src.Functions.getRandomLayer(layer))) + layer = (4, 50) + self.assertEqual(layer, np.shape(src.Functions.getRandomLayer(layer))) diff --git a/related/EP/test/testPlotData.py b/related/EP/test/testPlotData.py new file mode 100644 index 0000000..2ec6315 --- /dev/null +++ b/related/EP/test/testPlotData.py @@ -0,0 +1,41 @@ +import unittest +import numpy as np + +from src.PltData import PltData + +class TestPlotData(unittest.TestCase): + + def testPlotNNModel(self): + #[2, 3, 5] Netz + nn = np.array([[-0.00862074, -0.00609563], [ 0.03935056, 0.0159397 ]], dtype=np.float32),\ + np.array([ 0., 0.], dtype=np.float32),\ + np.array([[ 0.01351449, 0.04824072, 0.04954299], [ 0.04268739, -0.04188565, 0.03875775]], dtype=np.float32),\ + np.array([ 0., 0., 0.], dtype=np.float32),\ + np.array([[ 0.01074128, -0.00355459, 0.00787288, -0.02870593, -0.0204265 ], [ 0.01399798, -0.0096233 , 0.03152497, 0.03874204, -0.0466414 ], [ 0.04445429, -0.02976017, 0.00065653, -0.04210887, -0.02864893]], dtype=np.float32),\ + np.array([ 0., 0., 0., 0., 0.], dtype=np.float32) + + #[2, 1, 2] Netz + nn2 =np.array([[ 0.01390548, -0.01149112], [ 0.02786468, -0.02605006]], dtype=np.float32), \ + np.array([ 0., 0.], dtype=np.float32), \ + np.array([[-0.03265964],[ 0.013609 ]], dtype=np.float32), \ + np.array([ 0.], dtype=np.float32), \ + np.array([[ 0.02287653, 0.02650055]], dtype=np.float32), \ + np.array([ 0., 0.], dtype=np.float32) + + #[4,2,2] + nn3 = np.array([[ 0.03519103, -0.04059422, 0.04508766, -0.04067679], [ 0.01457861, 0.01178179, -0.01784203, 0.00051603], [-0.00807861, 0.01152407, 0.0136507 , 0.02639047], [ 0.04526602, -0.01604335, 0.00661949, 0.0434478 ]], dtype=np.float32), \ + np.array([ 0., 0., 0., 0.], dtype=np.float32),\ + np.array([[ 0.03728329, -0.01507163], [ 0.00789828, 0.0494065 ], [-0.00945786, -0.04301547], [-0.01999701, -0.01306728]], dtype=np.float32),\ + np.array([ 0., 0.], dtype=np.float32),\ + np.array([[-0.03051615, -0.03279487], [ 0.01100482, -0.02652025]], dtype=np.float32),\ + np.array([ 0., 0.], dtype=np.float32) + + # [1, 1, 2] Netz + nn4 = np.array([[0.01390548]], dtype=np.float32), \ + np.array([0.], dtype=np.float32), \ + np.array([[-0.03265964]], dtype=np.float32), \ + np.array([0.], dtype=np.float32), \ + np.array([[0.02287653, 0.02650055]], dtype=np.float32), \ + np.array([0., 0.], dtype=np.float32) + + PltData(None).plotNNModel(nn3, "test.png") \ No newline at end of file